Finalizing the syntax decisions

Author: Rizo Isrof

Anonymous_functions.fold

@@ -2,59 +2,59 @@
 -- # Anonymous Functions
 --
 
-
+-- Simple lambda functions.
+x -> x
 x -> x + x
 
+-- Lambda function with a block.
 do x ->
-  x + x
+  a = x + x
+  a + 1
 end
 
+-- Apply a transformation using a lambda.
+map (x -> x * x) [1..10]
 
-map (x => x * x) [1..10]
-
-map { 2 => x * 4
-      x => x * x } [1..10]
-
-[1..10] . map { \1 * \2 }
+-- Lambdas can use pattern matching with the `|` alternative operator.
+-- The following lambda will replace 5 by 0.
+map (5 -> 0 | x -> x * x) [1..10]
 
+-- The same variable can be referenced multiple times.
+\x + \x
 
- tree . { Leaf => "x"
-          Node x => str x }
 
- tree =>
-  | Leaf -> "x"
-  | Node x -> str x
+-- * --
 
-=> \ x y => x + y
-=> \ 5
-=> (~ + ~)
+-> \ x y -> x + y
+-> \ 5
+-> (~ + ~)
 
 (-> system :fetcher :conf :credentials :username)
 
 -> system #fetcher #conf #credentials #username
 
--> map (data flag => process data verbose: (not flag)) [1, 2, 3, 4, 5]
-=> map (process _ verbose: (not _)) [1, 2, 3, 4, 5]
+-> map (data flag -> process data verbose: (not flag)) [1, 2, 3, 4, 5]
+-> map (process _ verbose: (not _)) [1, 2, 3, 4, 5]
 
-=> map { data flag => process data verbose: (not flag) } [1, 2, 3, 4, 5]
-=> map { process _ verbose: (not _) } [1, 2, 3, 4, 5]
+-> map { data flag -> process data verbose: (not flag) } [1, 2, 3, 4, 5]
+-> map { process _ verbose: (not _) } [1, 2, 3, 4, 5]
 
-=> map (data flag => process data verbose: (not flag)) [1, 2, 3, 4, 5]
-=> map {process _ verbose: (not _)} [1, 2, 3, 4, 5]
+-> map (data flag -> process data verbose: (not flag)) [1, 2, 3, 4, 5]
+-> map {process _ verbose: (not _)} [1, 2, 3, 4, 5]
 
-=> map (λ data flag ⇒ process data verbose: (not flag)) [1, 2, 3, 4, 5]
-=> map λ(process _ verbose: (not _)) [1, 2, 3, 4, 5]
+-> map (λ data flag -> process data verbose: (not flag)) [1, 2, 3, 4, 5]
+-> map λ(process _ verbose: (not _)) [1, 2, 3, 4, 5]
 
-=> map (data flag => process data verbose: (not flag)) [1, 2, 3, 4, 5]
-=> map {process _ verbose: (not _)} [1, 2, 3, 4, 5]
+-> map (data flag -> process data verbose: (not flag)) [1, 2, 3, 4, 5]
+-> map {process _ verbose: (not _)} [1, 2, 3, 4, 5]
 
-=> map (|data flag| => process data verbose: (not flag)) [1, 2, 3, 4, 5]
-=> map {process _ verbose: (not _)} [1, 2, 3, 4, 5]
+-> map (|data flag| -> process data verbose: (not flag)) [1, 2, 3, 4, 5]
+-> map {process _ verbose: (not _)} [1, 2, 3, 4, 5]
 
-=> map (|x| => x * x) [1 .. 5]
+-> map (|x| -> x * x) [1 .. 5]
  = [1, 4, 9, 16, 25]
 
-=> map \(_1 * _1) [1 .. 5]
+-> map \(_1 * _1) [1 .. 5]
  = [1, 4, 9, 16, 25]
 
 -> map \(_1 * _1) [1 .. 5]
@@ -65,23 +65,22 @@ map { 2 => x * 4
 -- Mathematica
 -- If[#1 == 1, 1, #1 * #0[#1-1]]&
 
-=> \(_1 == 1 ? 1 : _1 * (_0 (_1 - 1)))
-=> \(if (_1 == 1): 1 else: _1 * (_0 (_1 - 1)))
+-> \(_1 == 1 ? 1 : _1 * (_0 (_1 - 1)))
+-> \(if (_1 == 1): 1 else: _1 * (_0 (_1 - 1)))
 
-=> \(\1 == 1 ? 1 : @1 * (@0 (@1 - 1)))
+-> \(\1 == 1 ? 1 : @1 * (@0 (@1 - 1)))
 
 
-fix = \f => (\x a => f (x x) a) (\x a => f (x x) a)
+fix = \f -> (\x a -> f (x x) a) (\x a -> f (x x) a)
 
 fix = f -> (x a -> f (x x) a)
            (x a -> f (x x) a)
 
-
 -- // --
 
 -- Anonymous functions can be wrapped in blocks.
 
-[1..99] => fold init: {} do dict i ->
+[1..99] -> fold init: {} do dict i ->
   dict # i::String <- i + i
 end
 
@@ -90,7 +89,7 @@ end
 -- * Since blocks are used, at any time you can extend the block with new statements.
 -- * `do` is a named argument for the lambda argument for `fold`.
 
-squares = [1..9] -> map do n =>
+squares = [1..9] -> map do n ->
   n * n
 end
 
@@ -99,12 +98,12 @@ squares = [1..9] >- map do n ->
   n * n
 end
 
-squares = [1..9] -> map do n =>
+squares = [1..9] -> map do n ->
   n * n
 end
 
 
-squares = [1..9] -> map do n =>
+squares = [1..9] -> map do n ->
   n * n
 end
 

Blocks.fold

@@ -1,4 +1,5 @@
 
+
 -- https://programmers.stackexchange.com/questions/135544/why-are-several-popular-programming-languages-influenced-by-c
 
 -- in function application \n denotes :
@@ -10,6 +11,25 @@ do: expr
 do expr end
 
 
+if (x > 3)
+    print "Too big!"
+end
+
+if (x > 3) : print "Too big!"
+
+if (x > 3)
+    print "Too big!"
+else
+    print "Just fine."
+end
+
+if (x > 3) : print "Too big!" else: print "Just fine."
+
+print ((x > 3) ? "Too big!" : "Just fine.")
+
+
+-- // --
+
 fun dist ((x0, y0), (x1, y1)) = let
      val dx = x1 - x0
      val dy = y1 - y0
@@ -325,7 +345,7 @@ function (factorial (n::Int) -> Int)
 end
 
 
-function factorial (n::Int) -> Int
+function factorial n::Int -> Int
     Log.info "Will calculate factorial of {n}"
     (n == 0) ? 1 : n * factorial (n - 1)
 end
@@ -391,6 +411,15 @@ in:
 
 -- // --
 
+def greet name
+    print "Hello, " + name "!!!"
+end
+
+
+def greet name {
+    print "Hello, " + name "!!!"
+}
+
 
 function greet name do
     print "Hello, " + name "!!!"

Collections.fold

@@ -1,4 +1,96 @@
 
+---
+-- Flow
+---
+
+sum = do
+  await >>=
+    | None   -> 0
+    | Some a -> a + sum
+end
+
+fold :: (a -> b -> a) -> a -> Consumer b a
+fold f z = go z where
+  go = next >>= | Some a -> go (f acc a)
+                | None   -> return acc
+
+filter pred = do
+  a <- await
+  if | pred a -> yield a >> filter pred
+     | otherwise -> filter pred
+
+filter = find_all
+
+
+--
+-- Haskell prelude version
+--
+
+filter :: (a -> Bool) -> [a] -> [a]
+filter _pred []    = []
+filter pred (x:xs)
+  | pred x         = x : filter pred xs
+  | otherwise      = filter pred xs
+
+
+filter :: Foldable f => (a -> Bool) -> f a -> f a
+filter _pred []    = []
+filter pred (x:xs)
+  | pred x         = x : filter pred xs
+  | otherwise      = filter pred xs
+
+
+filter f []       = []
+filter f (x & xs) = if f x then x & filter f xs
+                           else     filter f xs
+
+filter =
+  | pred []       -> []
+  | pred (x & xs) -> f x ? x & filter f xs : filter f xs
+
+filter =
+  | pred []                 -> []
+  | pred (x & xs) if pred x -> x & filter f xs
+  | pred (_ & xs)           ->     filter f xs
+
+filter pred xs =
+  case xs
+    | []                 -> []
+    | (x & xs) if pred x -> x & filter f xs
+    | (_ & xs)           ->     filter f xs
+
+-- Using list builder syntax.
+filter pred xs = [ x : x <- xs, pred x ]
+
+
+--
+-- Flow's implementation with explicit constructors
+--
+
+let rec filter pred =
+  fun () -> Await (fun a ->
+      if pred a
+      then fun () -> Yield (a, filter pred)
+      else filter pred)
+
+-- Same as original, but with monadic syntax.
+filter pred =
+  await >>= a ->
+      if pred a
+      then yield a >> filter pred
+      else filter pred
+
+filter pred =
+  x <- await
+  if | pred x    -> yield x >> filter pred
+     | otherwise ->            filter pred
+
+filter pred = [ x : x <- await, pred x ]
+
+
+
+---
+
 matrix = [1, 2, 3;
           4, 5, 6]
 Iter.at(matrix, 1)               # => [4, 5, 6]
@@ -93,3 +185,22 @@ fibs = [1 & 1 & zip fibs (tail fibs) with: (+)]
 fibs = 1 & 1 & (zip fibs (tail fibs) with: (+))
 
 
+--
+-- Operations inspired by APL
+--
+-- https://godoc.org/robpike.io/ivy
+
+-- Find indices in `a` that exists in `b`.
+-> a = [10, 20, 30, 40, 50]
+-> b = [2, 5, 10, 30]
+-> filter ((a in? b) # \x) (^ (# a))
+:: [Int] = [0, 2]
+
+--       A ← 10 20 30 40 50
+--       B ← 2 5 10 30
+--       (A ∊ B) / ⍳⍴A
+-- 1 3
+
+
+
+

Comments.fold

@@ -0,0 +1,22 @@
+
+-- Single-line comments
+
+x = 42 -- the answer
+
+{{}}
+{{ }}
+{{xyz}}
+{{ xyz }}
+
+
+{{
+ }}
+
+{{
+next []      = return ()
+next (a & l) = yield a >> next l
+}}
+
+fold (*) 0 [1, 2, 3] = 6
+
+