Merge branch 'master' of https://github.com/flaviut/nimrod-by-example

content/block.md

@@ -21,18 +21,7 @@ block:
   let b = "3"  # Probably a dumb idea
 ```
 
-Parentheses can be used as an expression, but they do not provide end of statement inference, so it is necessary to place semicolons yourself.
-
-``` nimrod
-square((
-  var result = newSeq[float]();
-  for i in 0..1000:
-  	result[i] = i;
-  result
-))
-```
-
-An interesting and unexpected side effect of this syntax is that Nimrod is suitable even for brace purists!
+Parentheses can be used as an expression, but they do not provide end of statement inference, so it is necessary to place semicolons yourself. An interesting and unexpected side effect of this syntax is that Nimrod is suitable even for brace purists!
 
 ``` nimrod
 proc square(inSeq: seq[float]): seq[float] = (
@@ -41,4 +30,11 @@ proc square(inSeq: seq[float]): seq[float] = (
     result[i] = v*v;
   )
 )
-```
+
+square((  # A 1001 long sequence to be squared
+  var result = newSeq[float]();
+  for i in 0..1000:
+  	result.add(i);
+  result
+))
+```

content/case.md

@@ -30,15 +30,15 @@ else:
   echo "Consonant"
 
 proc positiveOrNegative(num: int): string =
-  result = case num
-  of low(int)..-1:
-    "negative"
-  of 0:
-    "zero"
-  of 1..high(int):
-    "positive"
-  else:
-    "impossible"
+  result = case num:
+    of low(int)..-1:
+      "negative"
+    of 0:
+      "zero"
+    of 1..high(int):
+      "positive"
+    else:
+      "impossible"
 
 echo positiveOrNegative(-1)
 ```
@@ -63,4 +63,4 @@ of 10: echo "D"
 ``` console
 $ nimrod c -r ./case_stmts_1.nim
 C
-```
+```

content/hello_world.md

@@ -9,10 +9,10 @@ The code for a simple hello world program is as follows:
 echo "Hello World"
 ```
 
-To compile and execute the program, the following command should be run
+Save this text as `helloworld.nim`. To compile and execute the program, the following command should be run
 
 ``` console
-$ nimrod c -r --verbosity:0 ./helloworld.nim
+$ nimrod c -r --verbosity:0 helloworld.nim
 Hello World
 ```
 

content/if_else_while.md

@@ -4,7 +4,7 @@ title: If, Else, While
 
 # If, Else, While
 
-Nimrod many different control flow constructs, including the standard `if`s, `else`s, and `while`s. However, Nimrod does not use an `else if` construct like many languages, it uses a more condensed `elif`.
+Nimrod has many different control flow constructs, including the standard `if`s, `else`s, and `while`s. However, Nimrod does not use an `else if` construct like many languages, it uses a more condensed `elif`.
 
 When inside a loop, `continue` can be used to skip the rest of the loop body and to begin the next iteration; `break` can be used to immediately leave the loop body.
 
@@ -31,4 +31,4 @@ block busyloops:
   while true:
     while true:
       break busyloops
-```
+```

content/primitives.md

@@ -8,9 +8,9 @@ Nimrod has several primitive types:
 * signed integers: `int8`, `int16`, `int32`, `int64`, and `int`, where `int` is the same size as a pointer
 * unsigned integers are similar with `u` prepended to the type
 * floating points numbers: `float32`, `float64`, and `float`, where `float` is the processor's fastest type
-* characters: `char`, and basically an alias for uint8
+* characters: `char`, which is basically an alias for uint8
 
-To indicate the size of an integer literal, append `u` or `i` and the size you'd like to the end. However, this is not typically necessary.
+To indicate the size of an integer literal, append `u` or `i` and the size you'd like to the end. However, usually this is not necessary.
 
 Integers can also have `0[xX]`, `0o`, `0[Bb]` prepended to indicate a hex, octal, or binary literal, respectively. Underscores are also valid in literals, and can help with readability.
 
@@ -22,7 +22,7 @@ let
   c: uint8 = 256 # Compile time error
 ```
 
-Precedence rules are the same as most other languages, but instead of `^`, `&`, `|`, `>>`, `<<`, the `xor`, `and`, `or`, `shr`, `shl` operators are used, respectively.
+Precedence rules are the same as in most other languages, but instead of `^`, `&`, `|`, `>>`, `<<`, the `xor`, `and`, `or`, `shr`, `shl` operators are used, respectively.
 
 ``` nimrod
 let
@@ -34,4 +34,4 @@ echo 4/2
 $ nimrod c -r numbers2.nim
 2.0
 ```
-Another difference that may be surprising is that the `/` operator returns a floating point result, even when the operands are integers.  If integer division is needed, the `div` operator should be used.
+Another difference that may be surprising is that the `/` operator returns a floating point result, even when the operands are integers.  If integer division is needed, the `div` operator should be used.

content/variables.md

@@ -57,4 +57,4 @@ A `const` variable's value will be evaluated at compile-time, so if you inspect
 STRING_LITERAL(TMP129, "abcdefghijklmnopqrstuvwxyz", 26);
 ```
 
-The only limitation with const is that compile-time evaluation cannot interface with C because there is no compile-time foreign function interface at this time.
+The only limitation with const is that compile-time evaluation cannot interface with C because there is no compile-time foreign function interface at this time.

content/variables/result.md

@@ -12,7 +12,7 @@ proc `**`(number, power: int): int =
     result *= number
 ```
 
-A possible gotcha is declaring a variable called result and expecting it to have the same semantics.
+A possible gotcha is declaring a new variable called `result` and expecting it to have the same semantics.
 
 ``` nimrod
 proc unexpected(): int =