Records, Blocks.

Author: rizo

Anonymous_functions.fold

@@ -9,27 +9,29 @@
 
 (-> system :fetcher :conf :credentials :username)
 
-=> system #fetcher #conf #credentials #username
+-> system #fetcher #conf #credentials #username
 
--> map (data flag => process data verbose: (not flag)) [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 (\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 (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 (|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]
  = [1, 4, 9, 16, 25]
 
 -> map \(~1 * ~1) [1 .. 5]
  = [1, 4, 9, 16, 25]
 
-
 -- Consider using ~0 as a reference to the anonymous function, allowing this way recursion.
 
 -- Mathematica

Blocks.fold

@@ -226,23 +226,25 @@ end
 -- // --
 
 
-(function factorial [n]
+(def factorial [n]
     (log/info "Will calculate factorial of {n}")
     (if (= n 0)
         1
         (* n (factorial (- n 1)))))
 
-function factorial n do
+
+
+def factorial n do
     Log.info "Will calculate factorial of {n}"
     (n == 0) ? 1 : n * factorial (n - 1)
 end
 
-let factorial n =
+def factorial n =
     Log.info "Will calculate factorial of {n}"
     (n == 0) ? 1 : n * factorial (n - 1)
 end
 
-function factorial n:
+def factorial n:
     Log.info "Will calculate factorial of {n}"
     (n == 0) ? 1 : n * factorial (n - 1)
 end
@@ -252,7 +254,7 @@ factorial n = do
     (n == 0) ? 1 : n * factorial (n - 1)
 end
 
-function factorial n {
+def factorial n = {
     Log.info "Will calculate factorial of {n}"
     (n == 0) ? 1 : n * factorial (n - 1)
 }

Modules.fold

@@ -102,3 +102,49 @@ module User =
     compare x y =
 
 
+
+-- // --
+
+
+
+module JSONCodec n do
+    Log.info "Will calculate factorial of {n}"
+    (n == 0) ? 1 : n * factorial (n - 1)
+end
+
+interface Codec a =
+    encode :: a -> Result Data
+    decode :: Data -> Result a
+end
+
+module Codec Json =
+    encode = String x => "\"{x}\""
+           | Object x => surround x with ('{', '}')
+           | List xs  => surround (join (map encode xs) with: ',')
+                             with: '"'
+end
+
+module JSONCodec n =
+    Log.info "Will calculate factorial of {n}"
+    (n == 0) ? 1 : n * factorial (n - 1)
+end
+
+module JSONCodec n:
+    Log.info "Will calculate factorial of {n}"
+    (n == 0) ? 1 : n * factorial (n - 1)
+end
+
+JSONCodec n = module
+    Log.info "Will calculate factorial of {n}"
+    (n == 0) ? 1 : n * factorial (n - 1)
+end
+
+module JSONCodec n = {
+    Log.info "Will calculate factorial of {n}"
+    (n == 0) ? 1 : n * factorial (n - 1)
+}
+
+JSONCodec n = module {
+    Log.info "Will calculate factorial of {n}"
+    (n == 0) ? 1 : n * factorial (n - 1)
+}

Records.fold

@@ -0,0 +1,17 @@
+
+type Pair a = { first::a, second::a }
+
+Pair :: first: a -> second: a -> Pair a
+
+
+type Person = MkPerson String Int
+
+showPerson : Person -> String
+showPerson p = let MkPerson name age = p in
+                      name ++ " is " ++ show age ++ " years
+                         old"
+
+
+alan = { name: "Alan Turing", age: 32 }
+
+alan = { name: "Alan Turing" age: 32 }

Records_examples.fold

@@ -0,0 +1,37 @@
+
+type Pair a = { first:  a,
+                second: a }
+
+-- A generic function
+function swap (pair::Pair a) -> Pair a = {
+    Pair { first, second } = pair
+    Pair { first: second, second: first }
+
+    Pair first: pair.second, second: pair.first
+}
+
+fn swap<T>(pair: Pair<T>) -> Pair<T> {
+    let Pair { first, second } = pair;
+
+    Pair { first: second, second: first }
+}
+
+// Reimplementing a 2-element tuple as a tuple struct
+struct Tuple2<T, U>(T, U);
+
+fn main() {
+    // Explicitly specialize `Pair`
+    let pair_of_chars: Pair<char> = Pair { first: 'a', second: 'b' };
+
+    // Implicitly specialize `Pair`
+    let pair_of_ints = Pair { first: 1i32, second: 2 };
+
+    // Explicitly specialize `Tuple2`
+    let _tuple: Tuple2<char, i32> = Tuple2('R', 2);
+
+    // Explicitly specialize `swap`
+    let _swapped_pair_of_chars = swap::<char>(pair_of_chars);
+
+    // Implicitly specialize `swap`
+    let _swapped_pair_of_ints = swap(pair_of_ints);
+}

Types.fold

@@ -0,0 +1,5 @@
+
+type Result a b = Ok a | Error b
+
+
+type