ntreu14

let isEven num = num % 2 = 0
let square num = num * num
let printResults = List.iter <| printfn "%d"

// Filter then map
[1..5]
  |> List.filter isEven
  |> List.map square
  |> printResults

ntreu14

import java.util.function.BiFunction;
import java.util.List;
import java.util.Arrays;

public class FunctionsExample {

  public static void main(String[] args) {
    String[] strs = {"Example", "Strings", "To", "Join"};
    List<String> strsList = Arrays.asList(strs);
    

ntreu14

let rec fold f state list =
  match list with
    | [] -> state
    | head::rest -> fold f (f state head) rest

let reduce f list =
  match list with
    | [] -> invalidArg "list" "Cannot pass an empty list"
    | head::rest -> fold f head rest

ntreu14

namespace ConsList

module List =

  type 'a List =
    | Nil
    | Cons of ('a * 'a List)

  let private asCons v = Cons (v, Nil)

ntreu14

type 'a Node = Group of 'a Node list | Leaf of 'a

let tree = Group [ Group [Leaf 1; Leaf 2; Leaf 3]; Group [Leaf 6]; Leaf 9; Leaf 10 ]
let isEven n = n % 2 = 0

let flip f a b = f b a
let (>>=) = flip List.collect

let rec collectLeavesBy predicate = function
  | Group xs -> xs >>= (collectLeavesBy predicate)

ntreu14

open System
open System.Net
open System.Threading

[<EntryPoint>]
let main _ =
  let url = "http://www.google.com"

  let (>>=) (asyncBlock: Async<'a>) (f: 'a -> Async<'b>)  = 
    async {

ntreu14

type Peano = 
  | Zero 
  | Succ of Peano

// Comapre
let rec cmp x y =
  match x, y with
    | Zero, Zero -> 0
    | Zero, Succ _ -> -1
    | Succ _, Zero -> 1

ntreu14

type 'a Node =
  | Leaf of 'a
  | Group of ('a Node * 'a Node)

let findTreeHeight tree =
  let rec aux tree counter =
    match tree with
      | Leaf _ -> counter
      | Group (left, right) ->
         let leftTreeHeight = aux left (counter + 1)

ntreu14

module AoCDay8Part1 where
  
data Node = Node [Node] [Int]

solve :: [Int] -> ([Int], Node)
solve (nChild:nEntries:rest) =
  (remainingToBeParsed, Node children entries)
  where
    remainingToBeParsed      = drop nEntries restChildren
    entries                  = take nEntries restChildren

ntreu14

module AoCDay8Part2 where
  
data Node = Node [Node] [Int]

solve :: [Int] -> ([Int], Node)
solve (nChild:nEntries:rest) =
  (remainingToBeParsed, Node children entries)
  where
    remainingToBeParsed      = drop nEntries restChildren
    entries                  = take nEntries restChildren