+if/else statement

+// comments

docs/tutorial.md

@@ -0,0 +1,159 @@
+# Ling tutorial
+
+Ling is a very simple language, where we take only most important and popular features from
+other scripts and languages. In particular, we adopt _principle of minimal confusion_[^1].
+In other word, the code usually works as expected when you see it. So, nothing unusual.
+
+# Expressions and blocks.
+
+Everything is an expression in Ling. Even an empty block:
+
+    {
+        // empty block
+    }
+    >>> void
+
+Block returns it last expression as "return value":
+
+    {
+        2 + 2
+        3 + 3
+    }
+    >>> 6
+
+Same is without block:
+
+    3 + 3
+    >>> 6
+
+If you don't want block to return anything, use `void`:
+
+    {
+        3 + 4
+        void
+    }
+    >>> void
+
+Every construction is an expression that returns something (or `void`):
+
+    val limited = if( x > 100 ) 100 else x
+
+You can use blocks in if statement, as expected:
+
+    val limited = if( x > 100 ) {
+        100 + x * 0.1    
+    }
+    else 
+        x
+
+So the principles are:
+
+- everything is an expression returning its last calculated value or `void`
+- expression could be a `{ block }`
+
+## Expression details
+
+It is rather simple, like everywhere else:
+
+    sin(x * π/4) / 2.0
+
+See [math](math.md) for more on it.
+
+# Defining functions
+
+    fun check(amount) {
+        if( amount > 100 )
+            "anough"
+        else
+            "more"
+    }
+
+You can use both `fn` and `fun`. Note that function declaration _is an expression returning callable_.
+
+There are default parameters in Ling:
+
+    fn check(amount, prefix = "answer: ") {
+        prefix + if( amount > 100 )
+            "anough"
+        else
+            "more" 
+    }
+
+## Closures
+
+Each __block has an isolated context that can be accessed from closures__. For example:
+
+    var counter = 1
+    
+    // this is ok: coumter is incremented
+    def increment(amount=1) {
+        // use counter from a closure:
+        counter = counter + amount
+    }
+
+    val taskAlias = def someTask() {
+        // this obscures global outer var with a local one
+        var counter = 0
+        // ...
+        counter = 1
+        // ...
+        counter
+    }
+
+As was told, `def` statement return callable for the function, it could be used as a parameter, or elsewhere
+to call it:
+
+    // call the callable stored in the var
+    taskAlias()
+    // or directly:
+    someTask()
+    
+If you need to create _unnamed_ function, use alternative syntax (TBD, like { -> } ?)
+
+# Integral data types
+
+| type   | description                     | literal samples     |
+|--------|---------------------------------|---------------------|
+| Int    | 64 bit signed                   | `1` `-22` `0x1FF`   |
+| Real   | 64 bit double                   | `1.0`, `2e-11`      |
+| Bool   | boolean                         | `true` `false`      |
+| String | unicode string, no limits       | "hello" (see below) |
+| Void   | no value could exist, singleton | void                |
+| Null   | missing value, singleton        | null                |
+| Fn     | callable type                   |                     |
+
+## String details
+
+### String operations
+
+Concatenation is a `+`: `"hello " + name` works as expected. No confusion.
+
+### Literals
+
+String literal could be multiline:
+
+    "
+        Hello,
+        World!
+    "
+    >>> "Hello
+    World"
+
+In that case compiler removes left margin and first/last empty lines. Note that it won't remove margin:
+
+    "Hello,
+     World
+    "
+    >>> "Hello,
+        World
+       "
+
+because the first line has no margin in the literal.
+
+# Comments
+
+    // single line comment
+    var result = null // here we will store the result
+
+
+