From 8e478e89090fae0045f688a2a4690fda2c253392 Mon Sep 17 00:00:00 2001 From: Mark Date: Sun, 25 Oct 2020 12:55:57 +0000 Subject: [PATCH] doc: minor typo/English improvements (#6678) --- doc/docs.md | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/doc/docs.md b/doc/docs.md index 497d083b8e..ef8ea8bd51 100644 --- a/doc/docs.md +++ b/doc/docs.md @@ -773,7 +773,7 @@ if x is Abc { } ``` -If you have a struct field which should be checked, there is also a way to name a alias. +If you have a struct field which should be checked, there is also a way to name an alias. ```v if x.bar is MyStruct as bar { // x.bar cannot be cast automatically @@ -794,7 +794,7 @@ m := {'one': 1, 'two': 2} println('one' in m) // true ``` -It's also useful for writing more clear and compact boolean expressions: +It's also useful for writing boolean expressions that are clearer and more compact: ```v if parser.token == .plus || parser.token == .minus || @@ -1314,7 +1314,7 @@ fn bar_function(foo Foo) { ``` If a function argument is immutable (like `foo` in the examples above) -V can pass it either value or reference. The compiler will determine this by itself, +V can pass it either by value or by reference. The compiler will decide, and the developer doesn't need to think about it. You no longer need to remember whether you should pass the struct by value @@ -1330,7 +1330,7 @@ fn (foo &Foo) bar() { ``` `foo` is still immutable and can't be changed. For that, -`(mut foo Foo)` has to be used. +`(mut foo Foo)` must be used. In general, V's references are similar to Go pointers and C++ references. For example, a tree structure definition would look like this: @@ -1442,10 +1442,10 @@ fn print_backtrace() ## Modules Every file in the root of a folder is part of the same module. -Simple programs don't need to have a module name - it defaults to 'main'. +Simple programs don't need to specify module name, in which case it defaults to 'main'. V is a very modular language. Creating reusable modules is encouraged and is -very simple. +quite easy to do. To create a new module, create a directory with your module's name containing .v files with code: @@ -1619,7 +1619,7 @@ fn land(w World) { `match` must have a pattern for each variant or have an `else` branch. -There are 2 ways to access the cast variant inside a match branch: +There are two ways to access the cast variant inside a match branch: - the shadowed match variable - using `as` to specify a variable name @@ -1883,7 +1883,7 @@ those in Go. You can push objects into a channel on one end and pop objects from Channels can be buffered or unbuffered and it is possible to `select` from multiple channels. #### Syntax and Usage -Channels have the type `chan objtype`. An optional buffer length can specified as `cap` property +Channels have the type `chan objtype`. An optional buffer length can specified as the `cap` property in the declaration: ```v @@ -1994,7 +1994,7 @@ Usage of these methods and properties in production is not recommended - algorithms based on them are often subject to race conditions. Use `select` instead. Data can be exchanged between a coroutine and the calling thread via a shared variable. -This variable should be created as reference and passed to the coroutine as `mut`. +Such variables should be created as references and passed to the coroutine as `mut`. The underlying `struct` should also contain a `mutex` to lock concurrent access: ```v @@ -2115,11 +2115,11 @@ producing the correct output. V executes all test functions in the file. * Test function names must begin with `test_` to mark them for execution. * Normal functions can also be defined in test files, and should be called manually. Other symbols can also be defined in test files e.g. types. -* There are 2 kinds of tests: external and internal. -* The internal tests, have to *declare* their module, just like all other .v -files from the same module. Internal tests can call even private functions in +* There are two kinds of tests: external and internal. +* Internal tests must *declare* their module, just like all other .v +files from the same module. Internal tests can even call private functions in the same module. -* The external tests, have to *import* the modules which they test. They do not +* External tests must *import* the modules which they test. They do not have access to the private functions/types of the modules. They can test only the external/public API that a module provides.