Anonymous_functions.fold

--
-- # Anonymous Functions
--

-- Simple lambda functions.
x -> x
x -> x + x

-- Lambda function with a block.
x ->
  let a = x + x in
  a + 1

f x y ==> (f x) y
f(x, y)

-- Apply a transformation using a lambda.
List.map (should_print_output value db_handler -> x * x) [1..10]

List.map (fn should_print_output value db_handler -> x * x) [1..10]
List.map (lambda should_print_output value db_handler -> x * x) [1..10]

def prod x = x * x

List.map prod [1..10]

--
List.map {
  | 0 -> 0
  | n if n / 2 == 0 ->
    let x = n * n * n
    in
      x - 1
  | n ->
    let x = n * n * n
    in
      x - 1
  }
  [-1..100]

List.map {
    0 -> 0,
    n if n / 2 == 0 ->
      let x = n * n * n
      in
        x - 1,
    n ->
      let x = n * n * n
      in
        x - 1
  }
  [-1..100]

-- 1
List.map {
  | 0 -> 0
  | n if n / 2 == 0 -> n
  | n -> n * n
  }
  [-1..100]

-- 2
List.map
  do 0 -> 0
   | n if n / 2 == 0 -> n
   | n -> n * n
  end
  [-1..100]

-- 3
List.map
  (fn 0 -> 0
    | n if n / 2 == 0 -> n
    | n -> n * n)
  [-1..100]



List.map
  (λ 0 -> 0
   | n if n / 2 == 0 -> n
   | n -> n * n)
  [-1..100]

List.map
  (\ 0 -> 0
   | n -> n * n)
  [-1..100]





-- Lambdas can use pattern matching with the `|` alternative operator.
-- The following lambda will replace 5 by 0.
map (do 5 -> 0 | x -> x * x end) [1..10]

[1..10 |> map match \x
              | 5 -> 0
              | x -> x * x
              end

[1..10 |> map match \x
              | 5 -> 0
              | x -> x * x
              end


[1..10 |> map do | 5 -> 0
                 | x -> x * x

[1..10 |> map fun | 5 -> 0
                  | x -> x * x
              end

[1..10 |> map fun
              | 5 -> 0
              | x -> x * x
              end

[1..10 |> map do
              | 5 -> 0
              | x -> x * x
              end


let read_until file =
  File.fold_while
    (function
     | Left r a -> Continue [a & r]
     | Right r -> List.rev r)
    []
    file

let read_until file =
  File.fold_while
    (fun Left r a -> Continue [a & r]
       | Right r -> List.rev r)
    []
    file

def read_until file =
  File.fold_while
    (fn Left r a -> Continue (a & r)
      | Right r -> List.rev r)
    []
    file

let read_until file =
  File.fold_while file [] {
  | Left r a -> Continue [a & r]
  | Right r -> List.rev r
  }

def read_until file =
  File.fold_while {
      Left r a =>
        Continue [a & r]
      Right r | List.rev r
    }
    []
    file

def read_until file =
  File.fold_while
    fun Left r a -> Continue [a & r]
      | Right r -> List.rev r
    end
    []
    file

def read_until file =
  file
  |> File.fold_while {
       | Left r a -> Continue [a & r]
       | Right r -> List.rev r
       }
       []

-- Length --

-- 1.0) SML style inline patterns
def length [_ & rest] = 1 + length rest
  | length [] = 0

-- 2.0) Explicit match, ocaml style
def length list =
  match list with
  | [_ & rest] -> 1 + length rest
  | [] -> 0
  end

-- 2.1) Explicit match, ocaml style
def length list =
  match list {
  | [_ & rest] ->
    1 + length rest

  | [] ->
    0
  }

-- 3.0 Explicit match, rust style
def length list =
  match list {
    [_ & rest] -> 1 + length rest
    [] -> 0
  }

-- 3.1 Explicit match, rust style
def length list =
  match list {
    [_ & rest] ->
      1 + length rest

    [] ->
      0
  }


-- The same variable can be referenced multiple times.
\x + \x


-- * --

-> \ x y => x + y
-> \ 5
-> (~ + ~)

(-> system :fetcher :conf :credentials :username)

-> system #fetcher #conf #credentials #username

map (fn x flag -> process x verbose: (not flag)) [1, 2, 3, 4, 5]
map { process \x 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 {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]
 = [1, 4, 9, 16, 25]

-> map \(_1 * _1) [1 .. 5]
 = [1, 4, 9, 16, 25]

-> map \(_1 * _1) [1 .. 5]
 = [1, 4, 9, 16, 25] : [Int]

-- Consider using _0 as a reference to the anonymous function, allowing this way recursion.

-- 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)))


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 ->
  dict # i::String <- i + i
end


[1..99]
  |> fold (fn acc i -> acc!i <- i + i) (dict [])

-- This approach has some advantages over a simple lambda expression:
--
-- * 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 ->
  n * n
end


squares = [1..9] >- map do n ->
  n * n
end

squares = [1..9] -> map do n ->
  n * n
end


squares = [1..9] -> map do n ->
  n * n
end

for i <- [1..9]
  print "hey there number {i}"
end

[print "hey there number {i}" | i <- [1..9]]



-- Lambda symbols

x y -> x + y

|x y| -> x + y

\x y -> x + y

fn x y -> x + y

do
  x y -> x + y
end

fun x y -> x + y

lambda x y -> x + y

{ x y -> x + y }

{ x y -> x + y }


-- Patterns

def n + n =
  Int.add n n

def (+) n n =
  Int.add n n

def (+) = fn n -> fn n -> Int.add n n


(= (+ n n )
   (Int.add n n))


pattern = expression

-- not a pattern
f x y = ?