microsoft / angara.flow Goto Github PK

let ``Extend and continue work using computation expression``() =
    let w1 = work {
        let! x = makeValue 1 |> name "one"
        let! y = inc x
        let! z = inc x 
        let! w = add(x,y) |> name "sum"
        ()
    }
    let eng,names,annotations,_ = startFrom_x w1 (createDefaultSuffix)
    let wrk = Execution.EngineAPI.AwaitCompletion eng |> Async.RunSynchronously
    eng.Dispose()

    Trace.WriteLine("\n\n\nContinues...")
    let snapshot = wrk, names, annotations
    let w2 = work {
        let! y = snapshot |> take<int> "out one"
        let! w = snapshot |> take<int> "out sum"
        let! z = inc y
        return z
    }

    let (g,_,_) = build w2 
    Assert.AreEqual(4, g.Structure.Vertices.Count)

    match eval w2 |> Async.RunSynchronously with
    | EvaluationResult.Failed _ -> failwith "Work failed"
    | EvaluationResult.Success z -> 
        z =? 3

let ``Use resumable iterative method in a 'work' monad``() =
        let g = work {
            let! func    = makeValue (fun (x:float) -> x*x - 4.*x + 2.)
            let! settings= makeValue (3.0, 0.1, 0.001)
            let! root    = root (func, settings)
            return! incf root
        } 
        match eval(g) |> Async.RunSynchronously with
        | EvaluationResult.Failed  _ -> Assert.Fail("Failed to execute a work")
        | EvaluationResult.Success(v) -> Assert.AreEqual(1. + (2. + sqrt(2.)), v, 0.01, "Incorrect root")

let ``Adding two arrays of different length``() =
    let w = flow {
        let! a = makeValue [| 1; 2; 4 |]
        let! b = makeValue [| 3; 1 |]

        let! s = foreach2(a, b, fun (a,b) -> flow {
            let! sum = add a b
            return sum
        })
        return! sum s
    }

    let s = run w
    Assert.Fail("work succeeded")

let ``Building compound method with 2 outputs from work expression``() =
    let incsum (x: ArtefactExpression<int>) (y: ArtefactExpression<int>) : FlowExpression<ArtefactExpression<int>*ArtefactExpression<int>> =
        flow {
            let! a = inc x
            let! b = sum (collect[| a; y |])
            return a,b 
        }

    let makeIncsum = decl incsum "incsum values" |> carg "x" |>carg "y" |> cresult ["a";"b"]
    let contract = Angara.Contracts.getContract makeIncsum

    let w = work{
        let! a,b = makeIncsum (value 2) (value 5)
        return a,b
    }

    match eval2 w |> Async.RunSynchronously with
    | EvaluationResult.Success (a,b) -> 
        (3,8) =? (a,b)
    | EvaluationResult.Failed _ -> Assert.Fail("Work failed")