1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

type Elem = int

type Tree =
    | E
    | T of Tree * Elem * Tree

let empty = E

let rec mem a t =
    async {
        match a, t with
        | x, E -> return false
        | x, T(a, y, b) when x < y ->
            let! contains = mem x a
            return contains
        | x, T(a, y, b) when y < x ->
            let! contains = mem x b
            return contains
        | _ -> return true
    }

let rec insert a t =
    match a, t with
    | x, E -> T(E, x, E)
    | x, T(a, y, b) when x < y -> T((insert x a), y, b)
    | x, T(a, y, b) when y < x -> T(a, y, (insert x b))
    | _, s -> s

1
2
3
4
5
6
7
8
9
10
11
12

#light

let matrix = [|1..100|] |> Array.map (fun x -> [|1..x|])

let sumrow (row:int array) = 
    let task = async { return row |> Array.sum }
    Async.Run(Async.Parallel[task])
    
let summatrix (matrix:int array array) =
    async { return matrix |> Array.map sumrow }
    
printfn "%A" (Async.Run(Async.Parallel[summatrix matrix]))