Collections.fold

---
-- 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]
Iter.at(matrix, 1) |> Enum.at(2) # => 6

matrix # 1 # 2


--
-- List (Singly linked list)
--

-- Lists are polimorphic homogeneous containers.

-- An inductive type definition
type List a = [] | a & List a

-- Here's how a list of integers is created:
[1, 2, 3, 4, 5]

-- The previous syntax is desugared into an inductive chain.
1 & 2 & 3 & 4 & 5 & []

B = ^5

#B == 5

rev B == [5..1]

rev B # 5 == 1

Average ← {(+/ ω) ÷ ρ ω}

Average = A -> fold (+) A / #A

 -> ^4
 :: [Int] = [1, 2, 3, 4]

 -> ^5 ++ ^3
 :: [Int] = [1, 2, 3, 4, 5, 1, 2, 3]

 -> ^4 \\ 3
 :: [Int] = [1, 2, 4]

 -> ^5 \\ [1, 4]
 :: [Int] = [2, 3, 5]

 -> ^5 \\ [2..4]
 :: [Int] = [1, 5]

 -> 3 in ^5
 :: Bool = T

--
-- Dict (Persistent Hash Map)
--

D = {"a" => 2, "b" => 4, "c" => 8}

-> fold (dict, c -> dict # c <- 0), {}, ['a'..'z']
:: {Char => Int} = {
     'a' => 0
     'b' => 0
     'c' => 0
     ...
     'z' => 0
   }

['a'..'z']
  >> map (=> 0)
  >> into {}


(map #(hash-map % 0) (seq "abcdefgh"))

map ['a'..'z']


List.fold ["a".."z"]
    init: String.Map.empty
      fn: dict ch -> String.Map.add dict 0


--
-- Lists
--

-- Linked Lists

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