Function_definition.fold

--
-- Function definition
--


-- Just say hello.
function hello name =
  print "Hello, $name!"


-- Hello function with type declaration.
val hello :: String -> ()
fun hello name =
  print "Hello, $(name)!"


-- Hello function with type annotation.
function hello name :: String -> () =
  print "Hello, $(name)!"


-- Lambda greeting, functions are just lambda values.
val hello = name ->
  print "Hello, $name!"


-- Function with composed body.
fun hello name =
  let msg = "Hello, $name!" in
  print "What's up?."


-- Lambda greeting with a block body.
val hello =
  do name ->
    print "Hello, $name!";
    print "What's up?."
  end


-- Factorial and fibonacci with argument pattern matching.
function
  | factorial 0 = 1
  | factorial n = n * factorial (n - 1)



-- 1
def factorial 0 = 1
  | factorial n = n * factorial (n - 1)

-- 2
def factorial 0 => 1
  | factorial n => n * factorial (n - 1)



function
  | fibonacci 0 = 0
  | fibonacci 1 = 1
  | fibonacci n = fibonacci (n - 1) + fibonacci (n - 2)



-- Derivatives
val eps = 0.0001

fun derivative f =
  x -> (f (x + eps) - f x) / eps

fun square x = x * x

fun around delta, target =
  actual -> abs (actual - target) < delta

val () =
  let dsquare = derivative square in
  assert (dsquare 5  |> satisfies (around 0.1, 10));
  assert (dsquare 10 |> satisfies (around 0.1, 20))


-- Constructs a list with numbers from `start` to `stop`.
let range from: (start = 0) to: stop by: (step = 1) =
  if start >= stop then []
  else [start & range from: (start + 1) to: stop by: step]


range :: from: Int? -> to: Int -> by: Int? -> [Int]

-> range to: 100
:: [Int] = [1, 2, 3, 4, 5, ... 99, 100]

-> range from: 2, to: 10, by: 3
:: [Int] = [2, 5, 8]




let take_while p [] = []
  | take_while p [x & xs] =
    if p x then [x & take_while p xs] else []

let take_while p [] => []
  | take_while p [x & xs] =>
    if p x then [x & take_while p xs] else []


-- -- --

map file_list, read \file
map file_list (read \file)

-- In a simple curried def definition:
f x y z = ...

-- The second token, `f` is by default parsed as a parameter annotation.

-- Consider the following example:
div x y

-- Is parsed as:
-> div x (by y)
-- ^  ^  ^
-- |  |  |
-- |  |  `- annotated parameter name
-- |  `- simple parameter name
-- `- def name

-- With types:
(div x::Int) (y::Int)

-- defs with more than two parameters:
def range start stop step

-- Here is the version with types and default values.
def range (start::Int = 0) (stop::Int) (step::Int = 1)

-- The defcton can be called like this:

range 100           -- Only the `stop` argument passed.
range 0 100         -- First two arguments passed, the `step` is default.
range 0 100 2       -- Positional def application.
`

-- The last example's readability can be improved with parameter annotations.
range (from start = 0) (to stop::Int) (by step::Int = 1) =
    ...
'

range :: from: Int -> to: Int -> by: Int -> [Int]


range (from start = 0) (to stop) (by step = true) =

range (from start = 0) (to stop::Int) (by step::Int = 1)


case (fetch last_node: n1) of:
    | Node (3, 2 Tree (Node)) -> "This is what we need."
    | Node (8, 1 Node)        -> "This is different."
    | *                       -> "No, no"


if (x > 3) then:
    "Hello!"
eles: "Not good."

-- Equivalent because removing then still requires one arg after.

if (x > 3):
    print "Hello!" "World" sep: "\n";
eles:
    "Not good."


-> range to: 100
-> range from: 0 to: 100 by: 2

-- If the parameter annotation and the actual parameter name are the same:
def hello (name name::String)

hello name: "Robot"

-- Instead, just add a `~` in front of the parameter name as a shortcut:
def hello (~name::String)

hello name: "Robot"

-- If you have a variable in scope with the same name as a parameter annotation,
-- you can use `~` to directly apply it.

name = "Robot"
hello name: name
hello name
!@#$%^&*_+\'/.,><~`

-- Instead of:
name = %"Robot %(full_name # 1)"
hello ~name: name




def (view::View) did_update context::Context with_opitions::({String -> Int}?) = {
    ...
}


my_view did_update my_ctx with_opitions {...}

my_view did_update my_ctx!



map (_ + _) (range 100)

type units =
    | Metric   [@name "metric"]
    | Imperial [@name "imperial"]
    @(deriving yojson)

type Units =
    | Metric   @(name "metric")
    | Imperial @(name "imperial")
    deriving: Yojson



let%lwt x = 3

[%lwt let x = 3]

name = "ppx_string"
mood = "fine"
larrys_baby = "perl"

msg = [%str "hello $(name) are you $(mood)?\n"]
print msg

  print [%str {"
This also works with new string syntax
So you can do templates like in $(larrys_baby).

"}];

  print [%str "testing double dollar: $$(name)"];
  print_newline()

type Longident = [%import: Longident.t] deriving: Show

let () =
  print_endline (show_longident (Longident.parse "Foo.Bar.baz"))



-- If we allow keyword parameters to be also used positionally (perhaps we
-- should do this), we retain all of traditional positional usage and rules.
-- Using Evan's example:

f : from:Int -> String
g : to:Int -> String
h : Int with: Int -> String

f from: 2 -- fine, returns String
f 2 -- also fine, returns String
f to: 2 -- type error
h 2 -- fine, returns (with: Int -> String)
h with:2 -- fine, returns (Int -> String)
h 1 2 -- fine, returns Int

okay = map (\f -> f 10) [f,g] -- types OK
what = map (\f -> f (to:10)) [f,g] -- type error


move : String -> from: Int -> to: List{Int} -> Result
 move "a" from: 1 to: [2] -- Result
3 immediate and readable curried forms without need for "flips":
 move "a" -- from:Int -> to:List[Int] -> Result
 move from:1 -- String -> to:List[Int] -> Result
 move to:[2] -- String -> from:[Int] -> Result


move :: String -> from: Int -> to: [Int] -> Result

`(move:from:to)

sum : Int -> Int -> Int

Int -> div : Int -> Int

3 div 2


(+)
(if: then: else:)

if:then:else ::
if: Bool -> then: Lazy a -> else: Lazy a =


_+_ : ℕ → ℕ → ℕ
zero + m = m
(suc n) + m = suc (n + m)


(+) : ℕ → ℕ → ℕ
zero + m = m
(suc n) + m = suc (n + m)


--

sum x y = x + y

sum(x, y) = x + y

sum[x, y] = x + y

sum x, y = x + y

--

sum(2, 3)

sum[2, 3]

--

let visits_durations_by_device :: List Visits -> List (Device, List Time)
let visits_durations_by_device visits_by_device =
    let durations = map (x -> (last x) - (first x)) in
    map (dev visit -> (dev, durations visit)) visits_by_device



--

-- Space-based application
IO.write ((String.join (map show args) with: sep) + end) to: IO.stdout

if (detections_count < settings.min_count):
    log warning "Not enough detections."
else:
    log status "Captured `~detections_count` detections."


-- Space-based application with commas
IO.write (String.join (map show args), with: sep) + end, to: IO.stdout

if (detections_count < settings.min_count),
    log warning "Not enough detections."
else:
    log status "Captured `~detections_count` detections."

-- Parentheses as application operator
IO.write(String.join(map show args, with: sep) + end, file: IO.stdout)


get "/analytics/<metric_name::String>/<date::Date>":
    div: h1 {style = {font = Helvetica}}:
        request.metric_name
    end
end

"Returns a sequence of numbers from start (inclusive) to end (exclusive),
by step, where start defaults to 0, step to 1."
def range from: (start::Int = 0) to: (stop::Int) by (step::Int = 1) -> [Int] =
    if (start == stop)
        []
    else
        [start & range from: (start + 1) to: stop by: step]


def square n:
  n * n
end

square n = n * n

square = n -> n * n

def square n:
    log "Will calculate square..."
    n * n
end

square n = do
    log "Will calculate square..."
    n * n
end


square n = do
    x <- read_str
    return x
end

square = n -> do
    log "Will calculate square..."
    n * n
end



let assoc (v::PersistentVector a) (i::Int) (el::a) -> PersistentVector =
  check_bounds! v i;
  if i > (length v - length v.tail) then
     let newtail = v.tail # [1 .. length v.tail] in
     newtail # (mask i) := el;
     PersistentVector v.trie newtail v.length
  else
    let newnode = v.trie # i # [1..end] in
    newnode # (mask i) := el;
    PersistentVector (assoc v.trie i newnode) v.tail v.length


let visits_durations_by_device :: Dict Device (List Visit) -> Dict Device (List Time)
let visits_durations_by_device visits_by_device =
  let duration v = last v - first v in
  Dict.map (map duration) visits_by_device

val x = 1

fun sum ctx xs =
  let hourly_counts_by_access =
    xs |> group_by_access
       |> add_missing_accesses \accesses (Spaces.obtain_access_list ctx.space)
       |> add_missing_hours_by_access ctx.date
  let sum_by_access = map hourly_counts_by_access
  in
    (hourly_counts -> `Sum (fold (+) 0 (map #2 hourly_counts)))
  sum_by_access



---

type List a =
  | Cons (a, list a)
  | Nil


let length self =
  match self
  | Cons (_, tail) -> 1 + length tail
  | Nil -> 0
  end


let list_1 = Cons (11, Cons (22, Cons (33, Nil)))
assert (length test_list == 3)


def append l1 l2 = l1 . {
    Nil -> l2
    Cons (x, tail) -> Cons (x, append tail l2)
}

list_2 = append(test_list, Cons (44, Nil))
list_2 == Cons (11, Cons (22, Cons (33, Cons (44, Nil))))


-- -- --

type List T =
    | Cons (T, List T)
    | Nil

def length =
    | Cons (_, tail) -> 1 + length tail
    | Nil -> 0
end

list_1 = Cons (11, Cons (22, Cons (33, Nil)))
length test_list == 3

def append l1 l2 =
    case l1:
        Nil -> l2
        Cons (x, tail) -> Cons (x, append tail l2)
    end
end

list_2 = append test_list (Cons (44, Nil))
list_2 == Cons (11, Cons (22, Cons (33, Cons (44, Nil))))

-- -- --

(def hello [name]
    (print ("Hello" + name)))

(def hello
    [] -> (hello "World")
    [name] -> (print ("Hello" + name)))


-- -- --


def hello name
    print ("Hello" + name)
end

def
    hello
    [] -> (hello "World")
    [name] -> (print ("Hello" + name)))
end

def hello
    -> hello "World"
    name -> print ("Hello" + name)
end

-- -- --

retry callback timeout retries = ...

retry = callback timeout retries ->
    Log#info
    repeat retries (-> callback >>= wait for: 5.Time#seconds)

-- -- --

def run_seq_command :: [Int] -> A -> Bool -> Int -> Unit
def run_seq_command nslots ready n =
  | Done r -> do
    Log.info "Job %a finished" (slog (string_of_int << V.hash)) n
    results = M.append n r results
    running = M.remove n   running
    if not (M.is_empty running)
      print_status (M.cardinal results) running
    end
    new_ready = (Set (G.succ g n) ++ mutual_exclusion_set n)
                  |> filter (n -> all (n -> M.mem n results) (G.pred g n) &&
                                  empty? (mutual_exclusion_set n \\ map_keys running))
    loop (nslots + 1) results running (ready ++ new_ready)
  end
  | Run (cmd, cont) -> do
    log "Next task in job %a: %a" (slog (string_of_int @* V.hash)) n
      (slog OpamProcess.string_of_command) cmd;
    if OpamProcess.is_verbose_command cmd ||
       not (OpamGlobals.disp_status_line ()) then
      OpamMisc.Option.iter
        (OpamGlobals.msg "%s Command started\n")
        (OpamProcess.text_of_command cmd);
    let p =
      if dry_run then OpamProcess.dry_run_background cmd
      else OpamProcess.run_background cmd
    in
    let running =
      M.add n (p, cont, OpamProcess.text_of_command cmd) running
    in
    print_status (M.cardinal results) running;
    loop nslots results running ready
  end

-- -- --

[1, 2, 3, 4].map {|x| x > 2 }.first

[1, 2, 3, 4].map (x -> x > 2).first

[1, 2, 3, 4] >> map (x -> x > 2) >> first

[1, 2, 3, 4] -> map (x -> x > 2) -> first

[1, 2, 3, 4] -> map (x -> x > 2) -> first

[1, 2, 3, 4] |> map (x -> x > 2) |> first

[1, 2, 3, 4] | map { \x > 2 } | first

-> [1, 2, 3, 4]
   (where { \x > 2 })
   first

select first from: [1, 2, 3, 4] where: x -> x > 2



-- -- --

open Str

let read_line ch =
  Some (input_line ch)
  catch End_of_file -> None


let fold_channel f acc ch =
  match read_line ch
  | Some line -> fold_channel f (f line acc) ch
  | None -> acc
  end



def add_to totals values =
  case totals
    | [] -> values
    | _  -> if length totals == length values
              then: map (+) totals values
              else: fail "Inconsistent-length rows"
end


|| Sums all the values from channel.
def sum_channel ch
  values_of_line line = map (::Float) (split line on: ',')
  fold_channel folder [] ch where
    folder line acc = add_to acc (values_of_line line)
  end
end

|| Reads numbers from a CSV file located at <file_path> and sums all results.
|| The output is printed in a CSV format to standard output.
def sum_and_print_file file_path::String -> Unit
  with chan <- open file_path mode: Read_only
    result = sum_channel chan
    print : join (map (::String) result) with: "," ++ "\n"
  end
end

def main
  | [_app, file_path] -> sum_and_print_file file_path
  | _ -> fail "usage: sum_csv <file>"
end

main Sys#args

-- -- --

let access_counts_to_string access_counts =
  String.Map.fold access_counts ~init:""
    ~f:(def ~key:access ~data:hourly_counts access_str ->
      List.fold hourly_counts ~init:access_str ~f:(def hours_str (h, c) ->
          hours_str ^ (format "%s, %d, %d\n" access (Float.to_int (Time.to_float h)) c)))

def access_counts_to_string access_counts
  String.Map.fold access_counts
    init: "" f: \(key access) (data hourly_counts) access_str ->
        List.fold hourly_counts init: access_str f: \hours_str (h, c) ->
          hours_str ++ ("%s, %d, %d\n" % (access, Float.to_int (Time.to_float h), c))
end

-- -- --

def x y -> x + y end

fn: x y -> x + y

type Tree
  Leaf
  Node (Int, Left, Right)
end


type Tree: do
  Leaf
  Node (Int, Left, Right)
end


detections -> length
detections -> length
detections >> length
detections |> length

detections -> ([] -> [x | xs] -> 1 + length xs)
detections -> ([] -> [x | xs] -> 1 + length xs)
detections |> ([] -> [x | xs] -> 1 + length xs)
detections :- ([] -> [x | xs] -> 1 + length xs)
detections :> ([] -> [x | xs] -> 1 + length xs)

detections # ([] -> [x | xs] -> 1 + length xs)
detections . ([] -> [x | xs] -> 1 + length xs)
detections & ([] -> [x | xs] -> 1 + length xs)
detections | ([] -> [x | xs] -> 1 + length xs)
detections > ([] -> [x | xs] -> 1 + length xs)


-> name

-- -- --

|| Creates a new object given a message passing primitive.
|| This is very good def.
def mk_object n_vs
  msg ->
    def lookup locals
      case locals
        | Empty -> raise: "Message not found: " + msg
        | Link f r -> if (f.name == m): f.value else: lookup(r)
    end
    lookup n_vs
  end
end

lookup <A> :: Self >> Formula -> Bool -> Int -> A

def self >> lookup attrs recursive level
    ...
end

db -> lookup

db >> lookup ("city" == "London" and "age" > 25)
        : True : 2

db -> lookup ("city" == "London" and "age" > 25)
        $ True $ 2



def db -> lookup



|| Transforms the integer index in content object by selecting the adequate
|| content type of the provided index.
def <Content_type::Collection_type where Content_type.Index::Forward_indext_type>
    (integer_index_into_content content::Content_type content_index::Int)
        -> Content_type.Element
    ...
end


|| Transforms the integer index in content object by selecting the adequate
|| content type of the provided index.
def <Content_type::Collection_type where Content_type.Index::Forward_indext_type>
    integer_index_into_content content::Content_type content_index::Int
        -> Content_type.Element
    ...
end

-- -- --


def sum ctx xs
  hourly_counts_by_access =
    xs >> group_by_access
       >> xs -> add_missing_accesses xs (Spaces.obtain_access_list)
       >> add_missing_hours_by_access ctx.date
  sum_by_access = map hourly_counts_by_access
    (hourly_counts -> `Sum (fold (+) 0 (map #2 hourly_counts)))
  sum_by_access
end


["Susanovska", "Riszovsky"]
    >- tonhos -> escolher_um_tonho_a_sorte tonhos
    >- pedir_para_dizer_um_disparate >> rir_se_do_disparate disparate

plano = rir_se_do_disparate disparate << pedir_para_dizer_um_disparate

dizer_ola = nome -> print "Olá, " + nome


def sum ctx xs =
  let hourly_counts_by_access xs =
    xs |> group_by_access
       |> xs -> add_missing_accesses xs (Spaces.obtain_access_list)
       |> add_missing_hours_by_access ctx.date
  let sum_by_access =
    map (hourly_counts -> `Sum (fold (+) 0 (map #2 hourly_counts)))
        (hourly_counts_by_access xs)
  in
    sum_by_access




def sum ctx xs
  hourly_counts_by_access =
    xs -> group_by_access
       -> xs -> add_missing_accesses xs (Spaces.obtain_access_list)
       -> add_missing_hours_by_access ctx.date
  sum_by_access = map hourly_counts_by_access
    (hourly_counts -> `Sum (fold (+) 0 (map #2 hourly_counts)))
  sum_by_access
end


def sum ctx xs
  hourly_counts_by_access =
    xs >> group_by_access
       >> xs -> add_missing_accesses xs (Spaces.obtain_access_list)
       >> add_missing_hours_by_access ctx.date
  sum_by_access = map hourly_counts_by_access
    (hourly_counts -> `Sum (fold (+) 0 (map #2 hourly_counts)))
  sum_by_access
end


def sum ctx xs
  hourly_counts_by_access =
    xs -> group_by_access
       -> xs -> add_missing_accesses xs (Spaces.obtain_access_list)
       -> add_missing_hours_by_access ctx.date
  sum_by_access = map hourly_counts_by_access
    (hourly_counts -> `Sum (fold (+) 0 (map #2 hourly_counts)))
  sum_by_access
end


def calc_sum ctx xs
  hourly_counts_by_access =
    xs -> group_by_access
       -> xs -> add_missing_accesses xs (Spaces.obtain_access_list)
       -> add_missing_hours_by_access ctx.date
  sum_by_access = map hourly_counts_by_access
    (hourly_counts -> `Sum (fold (+) 0 (map (#2) hourly_counts)))
  sum_by_access
end


def self -> calc_sum xs
  xs -> group_by_access
     -> add_missing_accesses (Spaces.obtain_access_list!)
     -> add_missing_hours_by_access self.date
     -> map ((#2) >> (\case | [] | [x] -> `Sum 0
                            | counts   -> `Sum (fold (+) 0 counts))
end


def calc_sum ctx xs
  xs | group_by_access
     | add_missing_accesses (Spaces.obtain_access_list!)
     | add_missing_hours_by_access ctx.date
     | map ((#2) >> (counts -> `Sum (fold (+) 0 counts)))
end


def sum ctx xs :: App.Context -> List (Time, Int) =
  xs |> group_by_access
     |> add_missing_accesses (Spaces.obtain_access_list ())
     |> add_missing_hours_by_access ctx.date
     |> map (\item #2 >> fold (+) 0 >> `Sum))


def calc_sum ctx xs
  xs -> group_by_access
     -> add_missing_accesses (Spaces.obtain_access_list!)
     -> add_missing_hours_by_access ctx.date
     -> map ((#2) >> (counts -> `Sum (fold (+) 0 counts)))
end

def self -> calc_sum ctx
  self -> group_by_access
       -> add_missing_accesses (Spaces.obtain_access_list!)
       -> add_missing_hours_by_access ctx.date
       -> map ((#2) >> (counts -> `Sum (fold (+) 0 counts)))
end

def calc_sum ctx xs
  hourly_counts_by_access =
    xs -> group_by_access
       -> add_missing_accesses \xs (Spaces.obtain_access_list)
       -> add_missing_hours_by_access ctx.date
  sum_by_access = map hourly_counts_by_access
    (\hourly_counts -> `Sum (fold (+) 0 (map #2 hourly_counts)))
  sum_by_access
end


def sum ctx xs
  hourly_counts_by_access =
    xs >- group_by_access
       >- xs -> add_missing_accesses xs (Spaces.obtain_access_list)
       >- improve_the_format >> prepare_for_operation
       >- add_missing_hours_by_access ctx.date
  sum_by_access = map hourly_counts_by_access
    (hourly_counts -> `Sum (fold (+) 0 (map #2 hourly_counts)))
  sum_by_access
end


def sum ctx xs
  hourly_counts_by_access =
    xs | group_by_access
       | xs -> add_missing_accesses xs (Spaces.obtain_access_list)
       | add_missing_hours_by_access ctx.date
  sum_by_access = map hourly_counts_by_access
    (hourly_counts -> `Sum (fold (+) 0 (map #2 hourly_counts)))
  sum_by_access
end


def sum ctx xs
  hourly_counts_by_access =
    xs . group_by_access
       . xs -> add_missing_accesses xs (Spaces.obtain_access_list)
       . add_missing_hours_by_access ctx.date
  sum_by_access = map hourly_counts_by_access
    (hourly_counts -> `Sum (fold (+) 0 (map #2 hourly_counts)))
  sum_by_access
end


def sum ctx xs
  hourly_counts_by_access =
    xs # group_by_access
       # xs -> add_missing_accesses xs (Spaces.obtain_access_list)
       # add_missing_hours_by_access ctx.date
  sum_by_access = map hourly_counts_by_access
    (hourly_counts -> `Sum (fold (+) 0 (map #2 hourly_counts)))
  sum_by_access
end

process = >> add_missing_accesses >> add_missing_hours_by_access

<* <*> <+> <$> *** <|> !! ||
=== =-> <<< >>> <> +++ <- ->
-> >> << >>= =<< .. ... ::
-< >- -<< >>- ++ /= ==


class Monad m where
    return :: a -> m a
     (>>=) :: m a -> (a -> m b) -> m b

-- VIEW
view :: (Int, Int) -> Turtle -> Element
view (w,h) turtle =
  let turtle_pic =
        to_form (image 96 96 "/turtle.gif")
          ▷ rotate turtle.angle
          ▷ move (turtle.x,turtle.y)
  in
      layers
        [ collage w h [turtle_pic]
        , opacity 0.7 <| fitted_image w h "/water.gif"
        ]


-- VIEW
let view :: (Int, Int) -> Turtle -> Element
let view (w,h) turtle =
  let turtle_pic =
    to_form (image 96 96 "/turtle.gif")
      |> rotate turtle.angle >> not true
      |> move (turtle.x, turtle.y)
  in
    layers
      [collage w h [turtle_pic],
       opacity 0.7 : fitted_image w h "/water.gif"]


[1, 2, 3, 4, 5] |> length

-- -- --


type Space = Int

show : Space -> Str
show = space -> show (Int space)

instance Show Space
  show = show <Str>
end



let group_devices_by_store :: Space -> Map Store (Set Device)
let group_devices_by_store space =
  let store_distances_by_antenna = get_store_distances space
  let find_stores =
    find_stores_for_antenna store_distances_by_antenna
  in
    IO.stdin
    |> Text.lines
    |> List.fold init: Store_map.empty
      do device_set_by_store line ->
        let {antenna, device, rssi} = Row.parse line in
         fold (find_stores antenna rssi) init: device_set_by_store
            do device_set_by_store' store ->
              Store_map.change device_set_by_store' store
                (some << (do None -> {}
                           | Some device_set -> device @ device_set
                          end))
            end
      end


group_devices_by_store :: Space -> Map Store (Set Device)
group_devices_by_store -> fn space ->
  let store_distances_by_antenna = get_store_distances space,
      find_stores = find_stores_for_antenna store_distances_by_antenna
  in
    In_channel.stdin -> lines -> fold init: Store_map.empty
      do device_set_by_store line ->
        let {antenna, device, rssi} = Row.parse line
        in
          fold (find_stores antenna rssi) init: device_set_by_store
            \device_set_by_store' store ->
              Store_map.change device_set_by_store' store
                (some << (\case | None -> {}
                                | Some device_set -> device @ device_set))
        end
      end
  end
end

group_devices_by_store :: Space -> {Store: {Device}}
group_devices_by_store = def space
  let store_distances_by_antenna = get_store_distances space,
      find_stores = find_stores_for_antenna store_distances_by_antenna
  In_channel.stdin >- lines >- fold init: Store_map.empty
    def device_set_by_store line
      let {antenna, device, rssi} = Row.parse line
      fold (find_stores antenna rssi) init: device_set_by_store
        def device_set_by_store' store
          Store_map.change device_set_by_store' store
            (some << (\case | None -> {}
                            | Some device_set -> device @ device_set))
        end
    end
end



-- -- --

-- Bodol Programming Language

(ƒ factorial
  0 → 1
  n → (* n (factorial (- n 1))))

(ƒ fibonacci
  0 → 0
  1 → 1
  n → (+ (fibonacci (- n 1)) (fibonacci (- n 2))))

(ƒ map
   f () → ()
   f (head . tail) → (cons (f head) (map f tail)))

(= '(2 3 4) (map (λ a → (+ a 1)) '(1 2 3))))

(ƒ constantly
    a → (λ → a))

factorial = lambda
  0 -> 1
  n -> n * factorial (n - 1)
end

fibonacci = fn
  0 -> 0
  1 -> 1
  n -> fibonacci (n - 1) + fibonacci (n - 2)
end


(ƒ factorial
  0 -> 1
  n -> (* n (factorial (- n 1))))


def factorial
  | 0 -> 1
  | n -> n * factorial (n - 1)
end

-- Map def defintition

map :: (a -> b) -> [a] -> [b]
map f [] = []
map f (x:xs) = (f x) : (map f xs)

def map
   | f [] -> []
   | f [x & xs] -> [f x & map f xs]
end

fn map :: (a -> b) -> [a] -> [b]
   | f [] -> []
   | f [x & xs] -> [f x & map f xs]
end


def map
   | f [] -> []
   | f [x & xs] -> [f x & map f xs]
end

map = do
   f [] -> []
   f [x & xs] -> [f x & map f xs]
end

[2 3 4] == map (a -> a + 1) [1 2 3]


--
|| Saying hello...
--

say_hello = name ->
  print "Hello, " name "!"

say_hello :: String -> Void

def say_hello name
  print "Hello, {name}!"
end

say_hello name = do
  print "Hello, {name}!"
end

say_hello name ->
  print "Hello, " name "!"


range from: start = 0, to: stop, by: step = 1 ->
    start == stop
        ? []
        : [start, (range from: (start + 1) to: stop by: step)...]

let avg =
  durations_by_dev
    >- fold init: (0, 0) do (t, c) (key: dev) (data: dur) ->
         print "Counting durations for {dev}..."
         (t + dur, c + 1)
       end
    >- (total, count) -> total / count
in
  print "Average visiting time is {avg}"
end


-- From carcass by D. Buenzli
-- https://github.com/dbuenzli/carcass/blob/b2c7af8ba6dfe69ca59b8a0ba33afc296a1c53d9/src/carcass.ml#L212

let create :(nln = true) :src input =
  let nln = if nln then Some (`ASCII 0x000A {- LF -}) else None;
  let d = Uutf.decoder encoding: `UTF_8 :nln input;
  { src; d; buf = Buffer.create 1024;
    prev_line = 0; prev_col = 0;
    peek = `Start }


def create (nln = true) ~src input
  nln = if nln then Some (`ASCII 0x000A (* LF *)) else None
  d = Uutf.decoder ~encoding:`UTF_8 ?nln input
  { src, d, buf = Buffer.create 1024,
    prev_line = 0, prev_col = 0,
    peek = `Start }
end


def create ?(nln = true) ~src input:
  nln = if nln then Some (`ASCII 0x000A (* LF *)) else None
  d = Uutf.decoder ~encoding:`UTF_8 ?nln input
  { src; d; buf = Buffer.create 1024;
    prev_line = 0; prev_col = 0;
    peek = `Start }


-- * --

-- StandardML
let area (Circle (_, r)) = 3.14 * r * r
  | area (Square (_, s)) = s * s
  | area (Triangle (a, b, c)) = heron (a, b, c)



area = do
  (Circle (_, r)) -> 3.14 * r * r
  (Square (_, s)) -> s * s
  (Triangle (a, b, c)) -> heron (a, b, c)
end


-- * --

-- Ur/Web
def foldl [a] [b] (f : a -> b -> b) =
    let
        def foldl' acc ls =
            case ls of
                [] -> acc
              | x :: ls -> foldl' (f x acc) ls
    in
        foldl'
    end


foldl (f :: a -> b -> b) =
  let
    foldl' acc ls =
      case ls of
        | [] -> acc
        | x & ls -> foldl' (f x acc) ls
      end
  in
    foldl'
  end






--




val x :: Int = 2 + 2


def sum x y = x + y


def sum x y =
  let
    r = x + y,
    b = r - 1
  in
    r / b


val result = sum 2 2


type color =
  | Red
  | Green
  | Blue
  | RGB (int, int, int)

val c1 = Red                  -- color
val c2 = RGB (255, 100, 0)    -- color

type list =
  | Empty
  | List int list

-- [] :: list
val l1 = Empty

-- [1, 2, 3, 4]
-- 1 : 2 : 3: 4 : []
val l2 = List 1 (List 2 (List 3 (List 4 Empty)))

def len1 list =
  match list with
  | Empty -> 0
  | List x rest -> 1 + len1 rest

def len2 Empty = 0
  | len2 (List x rest) = 1 + len2 rest

val so_um_el = List 42 Empty

-- len1 <=> len2

type list2 =
  | []
  | (&) int list2

val x = 1


-- 1
def len4 list =
  match list
  | [] -> 0
  | x & rest -> 1 + len4 rest
  end

-- 2
def len4 list =
  match list {
  | [] -> 0
  | x & rest -> 1 + len4 rest
  }


def len4 list =
  match list with
  | [] => 0
  | x & rest => 1 + len4 rest

fn x => 1 + 1

def sum x y => x + y

f : N -> N
    x => x + 1

f(x) = x + 1

def sum x y = {
  print x;
  x + y
}

def sum x y => {
  print x;
  x + y
}




def len4 [] => 0
  | len4 (x & rest) => 1 + len4 rest

def len3 [] = 0
  | len3 (x & rest) = 1 + len3 rest


len3 [...]

match
  ...
end

match {
  ...
}


def get_cat_images url =
    let
      rep = HTTP.get url,
      img = Data.process reg
    in
      View.render img
  | get_cat_images "localhost" =
    let resolve_url url =
      match url {
      | "localhost" ->
        match url + ... {
        | "rstrst" -> OK
        | "..." -> No
        }
      | other -> DNS.resove url
      }
    in
      resolve_url "http://..."
  | get_cat_images "127.0.0.1" =
    let
      zip = File.open "/var/cats.zip",
      img = Zip.uncompress zip
    in
      View.render img


def get_cat_images url =>
    let
      rep = HTTP.get url,
      img = Data.process reg
    in
      View.render img
  | get_cat_images "localhost" =>
    let resolve_url url =>
      match url with
      | "localhost" => "OK"
      | other => DNS.resove url
    in
      resolve_url "http://..."
  | get_cat_images "127.0.0.1" =>
    let
      zip = File.open "/var/cats.zip",
      img = Zip.uncompress zip
    in
      View.render img