ako-lang · kefniark · May 5, 2021 · May 5, 2021 · May 5, 2021 · May 5, 2021
diff --git a/_sidebar.md b/_sidebar.md
@@ -1,6 +1,7 @@
 * [Home](/)
 * [Grammar](./docs/grammar_basic.md)
     * [Basic](./docs/grammar_basic.md)
+    * [Expression](./docs/grammar_expression.md)
     * [Loop](./docs/grammar_loop.md)
     * [Task](./docs/grammar_task.md)
 * [Interpreter](./docs/interpreter_basic.md)

diff --git a/docs/grammar_basic.md b/docs/grammar_basic.md
@@ -1,9 +1,9 @@
-# Basic
+# How AKO works?
 
-The key element of Ako language is to represent algorithm as a succession of separated Commands.
+The key element of **Ako** is to represent algorithm as a succession of separated Commands
 
 And there is only a really limited set of possible Commands. The more commons are:
-* Assign a variable with: `=`
+* Assign an expression result to a variable with: `=`
 * Conditional with: `If`
 * Loop with: `For`
 * Execute a task with: `@`
@@ -26,8 +26,7 @@ fibo15 = @fibo(15)
 @print("Fibo(15) = {fibo15}")
 ```
 
----
-## Basic
+# Basic Types
 
 ### Variable
 
@@ -75,14 +74,3 @@ list = [1, 2, 3, 4]
 // Create dictionary
 pos = { x = 1, y = 2, z = 3 }
 ```
-
-## Expression
-```js
-num = 2 + 1
-float = num * 1.5
-```
-
-### Expression using function
-```js
-num = Math.max(2 + 1, 2 * 2)
-```
diff --git a/docs/grammar_expression.md b/docs/grammar_expression.md
@@ -0,0 +1,59 @@
+# Expression
+
+Expression are a major part of **Ako**, the can be see as Excel formula.
+It can be:
+* scalar (string, boolean, number, array, ...)
+* variable
+* mathematic operation
+* function call
+
+but it can also be a mix of those and contain parentheses `Math.abs(-2+1) * 2`
+
+## Math Expression
+```js
+num = 2 + 1
+float = num * 1.5
+```
+
+List of mathematical support
+* `*` : Multiply
+* `/` : Divide
+* `+` : Add
+* `-` : Substract
+* `%` : Modulo
+
+## Expression using function
+```js
+num = Math.max(2 + 1, 2 * 2)
+```
+
+## Expression Pipe
+Expression can become quite long and hard to read, the Pipe operator is there to help chaining function call. It take the result of an expr and pass it to another one
+
+```js
+a = List.sort(List.map(List.filter([1,2,4,5,6], (val) => val < 5), (val) => 10 / val))
+
+// can be rewritten into
+a = [1,2,4,5,6]
+  |> List.filter($, (val) => val < 5)
+  |> List.map($, (val) => 10 / val)
+  |> List.sort($)
+```
+
+# Equality Expression
+```js
+a = true
+b = a * 2 >= 12
+```
+
+List of mathematical support
+* `==` : Equal
+* `!=` : Different
+* `<` : Less than
+* `<=` : Less or equal than
+* `>` : More than
+* `>=` : More or equal than
+
+And they can be combined logic operator
+* `and`
+* `or`
diff --git a/docs/grammar_task.md b/docs/grammar_task.md
@@ -7,6 +7,8 @@ A task is an operation that can take a certain amount of time to do things:
 * Playing animations
 * Waiting for user inputs
 
+In other language it's often known as `job` or `coroutine`.
+
 And in Ako scripts, they are called with a `@` in front
 
 ```js
@@ -80,4 +82,4 @@ task hello {
 }
 
 @hello("World")
-```
+```
diff --git a/src/ako_grammar.txt b/src/ako_grammar.txt
@@ -20,8 +20,11 @@ Ako {
   Arguments = ListOf<Expr, ",">
 
   // Expression
-  Expr =  LambdaInline | Fn | MathExpr | Term
-  Term =Var | Number | String | bool | Array | Dictionary | Last
+  Pipe = (Pipe | ExprItem) "|>" ExprItem
+  Expr =  Pipe | ExprItem
+  ExprItem = LambdaInline | Fn | MathExpr | Term
+
+  Term = Var | Number | String | bool | Array | Dictionary | Last
   Fn = (id ".")? id "(" Arguments ")"
   // Lambda = "(" ListOf<id, ","> ")" "=>" Block
   LambdaInline = "(" ListOf<id, ","> ")" "=>" Expr

diff --git a/src/elements/operator.ts b/src/elements/operator.ts
@@ -1,5 +1,16 @@
 import {precisionRound} from '../std/math'
 
+export const Pipe = {
+  create: (expr1, expr2) => {
+    return {type: 'Pipe', expr1, expr2}
+  },
+  evaluate: (ctx, entry) => {
+    const val1 = ctx.vm.evaluate(ctx, entry.expr1, true)
+    ctx.vm.setData(ctx, '$', val1)
+    return ctx.vm.evaluate(ctx, entry.expr2, true)
+  }
+}
+
 export const Operator = {
   create: (operator, expr1, expr2) => {
     return {type: 'Operator', operator, expr1, expr2}

diff --git a/src/semantic.ts b/src/semantic.ts
@@ -59,6 +59,7 @@ export function getGrammar(akoGrammar: string) {
     Fn: (a, b, c, d, e, f) => AkoElement.Function.create(a.toAST(), c.toAST(), e.toAST()),
     Arguments: (a) => a.asIteration().toAST(),
     ListOf: (a) => a.asIteration().toAST(),
+    Pipe: (a, b, c) => AkoElement.Pipe.create(a.toAST(), c.toAST()),
     Metadata: (a, b, c) => AkoElement.Metadata.create(b.toAST(), c.toAST()),
 
     // Assign

diff --git a/tests/function.test.ts b/tests/function.test.ts
@@ -45,3 +45,18 @@ c = Vec2.sub(Vec2.scale(a, 5), Vec2.create(5, 5))
     assert.deepStrictEqual((stack.data as any)['c'], [0, 0])
   })
 })
+
+describe('Pipe', function () {
+  it('Check Pipe Behavior', () => {
+    const {stack} = runCode(`
+b = List.sort(List.map(List.filter([1,2,4,5,6], (val) => val < 5), (val) => 10 / val))
+
+a = [1,2,4,5,6]
+|> List.filter($, (val) => val < 5)
+|> List.map($, (val) => 10 / val)
+|> List.sort($)
+    `)
+    assert.deepStrictEqual((stack.data as any)['b'], [10 / 4, 10 / 2, 10])
+    assert.deepStrictEqual((stack.data as any)['a'], [10 / 4, 10 / 2, 10])
+  })
+})