Примеры программ

fun rec factorial n =
  if n <= 1 then 1
  else n * factorial (n - 1)

fun main _ =
  io {
    do! println (show (factorial 0))
    do! println (show (factorial 1))
    do! println (show (factorial 5))
    do! println (show (factorial 10))
  }

-- Наивная рекурсия: O(2^n)
fun rec fib n =
  match n with
  | 0 => 0
  | 1 => 1
  | n => fib (n - 1) + fib (n - 2)

-- Хвостовая рекурсия: O(n)
fun rec fibFast a b n =
  if n == 0 then a
  else fibFast b (a + b) (n - 1)

fun main _ =
  io {
    do! println "Naive fibonacci:"
    do! println (show (map fib [0..9]))
    do! println "Fast fibonacci:"
    do! println (show (map (fibFast 0 1) [0..9]))
  }

fun rec quicksort xs =
  match xs with
  | []       => []
  | p :: rest =>
      let smaller = filter (\x -> x < p) rest in
      let greater = filter (\x -> x >= p) rest in
      append (quicksort smaller) (p :: quicksort greater)

fun sumList xs = fold (\acc x -> acc + x) 0 xs

fun main _ =
  io {
    let nums = [5, 3, 8, 1, 9, 2, 7, 4, 6]
    do! println (show (quicksort nums))
    do! println (show (sumList [1..10]))
    do! println (show (map (\x -> x * x) [1..5]))
    do! println (show (filter (\x -> x mod 2 == 0) [1..10]))
    do! println (show (zip [1..5] ["a", "b", "c", "d", "e"]))
  }

fun rec quicksort cmp xs =
  match xs with
  | []       => []
  | p :: rest =>
      let smaller = filter (\x -> cmp x p) rest in
      let greater = filter (\x -> not (cmp x p) && x /= p) rest in
      let equal   = filter (\x -> x == p) rest in
      append (quicksort cmp smaller)
             (append (p :: equal) (quicksort cmp greater))

fun rec merge xs ys =
  match (xs, ys) with
  | ([], ys)            => ys
  | (xs, [])            => xs
  | (x :: xt, y :: yt) =>
      if x <= y then x :: merge xt ys
      else y :: merge xs yt

fun main _ =
  io {
    let nums = [64, 34, 25, 12, 22, 11, 90]
    do! println (show (quicksort (\a b -> a < b) nums))
    do! println (show (quicksort (\a b -> a > b) nums))
    let strs = ["banana", "apple", "cherry"]
    do! println (show (quicksort (\a b -> a < b) strs))
  }

-- Решето Эратосфена
fun rec sieve xs =
  match xs with
  | []       => []
  | p :: rest =>
      p :: lazy (sieve (lazyFilter (\x -> x mod p /= 0) (force rest)))

let primes = sieve (natsFrom 2)

-- Числа Фибоначчи как поток
fun rec fibs a b = a :: lazy (fibs b (a + b))
let fibStream = fibs 0 1

-- Степени числа
fun rec powersOf base n = n :: lazy (powersOf base (n * base))
let twoPowers = powersOf 2 1

fun main _ =
  io {
    do! println (show (take 10 primes))
    do! println (show (take 10 fibStream))
    do! println (show (take 10 twoPowers))
    do! println (show (take 5 (drop 100 nats)))
  }

fun safeDivide x y =
  if y == 0 then None
  else Some (x / y)

fun safeHead xs =
  match xs with
  | []      => None
  | x :: _ => Some x

fun safeSqrt x =
  if x < 0 then None
  else Some (sqrt (toFloat x))

-- Цепочка safe-операций через bindOption
fun pipeline x y =
  bindOption (safeDivide 100 x) (\q ->
  bindOption (safeSqrt q) (\r ->
  bindOption (safeDivide (toInt r) y) (\result ->
  Some result)))

fun main _ =
  io {
    do! println (show (pipeline 4 2))   -- Some 2
    do! println (show (pipeline 0 2))   -- None
  }

type Shape =
  | Circle    of radius
  | Rectangle of width height
  | Triangle  of a b c

fun area shape =
  match shape with
  | Circle r        => pi * r * r
  | Rectangle w h   => w * h
  | Triangle a b c  =>
      let s = (a + b + c) / 2.0 in
      sqrt (s * (s - a) * (s - b) * (s - c))

fun perimeter shape =
  match shape with
  | Circle r        => 2.0 * pi * r
  | Rectangle w h   => 2.0 * (w + h)
  | Triangle a b c  => a + b + c

fun main _ =
  io {
    let shapes = [Circle 5.0, Rectangle 4.0 6.0, Triangle 3.0 4.0 5.0]
    do! println (unlines (map describeShape shapes))
    let largest = fold (\acc s -> if area s > area acc then s else acc)
                       (head shapes) (tail shapes)
    do! println ("Largest: " ++ showShape largest)
  }

fun main _ =
  io {
    let path = "examples/tmp_output.txt"
    do! writeFile path "Hello from Goat!\nLine 2\nLine 3\n"
    let! content = readFile path
    do! println "File contents:"
    do! println content
    let lineCount = length (lines content)
    do! println ("Lines: " ++ show lineCount)
    let wordList = words content
    do! println ("Words: " ++ show (length wordList))
  }