[<ReflectedDefinition>]
let add x y = cloud { return x + y }

cluster.Run <@ add 1 2 @>

let add x y = cloud { return x + y }

cluster.Run (add 1 2)

> double add(double x, double y) { return x + y; }

> cluster.Run(CloudBuilder.FromFunc(() => add(1,2)))

type IContext =
    abstract Resolve<'TResource> : unit -> 'TResource

type Cloud<'T> = IContext -> (IContext -> 'T -> unit) -> unit

type IScheduler =
    abstract Enqueue : (IContext -> unit) -> unit

type Cloud =
  static member Parallel(children:Cloud<'T>[]) : Cloud<'T[]> =
    fun ctx k ->
      let sched = ctx.Resolve<IScheduler>()
      let n, ts = ref 0, Array.zeroCreate<'T> children.Length
      let runChild i ch =
        sched.Enqueue(fun ctx ->
          ch ctx (fun _ t -> ts.[i] <- t)
          if Interlocked.Increment n = ts.Length then k ctx ts)

      children |> Array.iteri runChild

type IFileSystem =
    abstract FileExists : path:string -> bool
    (* ... *)

type CloudFile =
    static member Exists(path : string) : Cloud<bool> =
      fun ctx k ->
        let fileSystem = ctx.Resolve<IFileSystem>()
        k ctx (fileSystem.FileExists(path))

type Cloud with
    static member GetResource<'TResource>() : Cloud<'TResource> =
        fun ctx k -> k ctx (ctx.Resolve<'TResource> ())

type IScheduler =
    abstract Enqueue : (IContext -> unit) -> unit

type ThreadPoolContext() =
  interface IContext with
    member __.Resolve<'T>() = ThreadPoolScheduler() |> unbox<'T>

and ThreadPoolScheduler() =
  interface IScheduler with
    member __.Enqueue(job : IContext -> unit) =
      ThreadPool.QueueUserWorkItem(fun () -> job (ThreadPoolContext()))

type ThreadPool =
  static member Run(workflow : Cloud<'T>) : 'T =
    let tcs = new TaskCompletionSource<'T>()
    let sched = new ThreadPoolScheduler() :> IScheduler
    sched.Enqueue(fun ctx -> workflow ctx (fun _ t -> tcs.SetResult t))
    tcs.Task.Result

type AzureScheduler() =
   interface IScheduler with
     member __.Enqueue(job : IContext -> unit) = ``???``

let mkFunc () =
    let rand = System.Random().Next()
    fun x -> rand + x

[Serializable]
internal class mkFunc@5 : FSharpFunc<int, int>
{
  public int rand;

  internal mkFunc@5(int rand)
  {
    this.rand = rand;
  }

  public override int Invoke(int x)
  {
    return this.rand + x;
  }
}

let mkFunc () =
    let rand = System.Random().Next()
    fun x -> rand + x

FsPickler.PickleToJson<int -> int>(mkFunc())

{
  "subtype": {
    "Case": "NamedType",
    "Name": "FSI_0022+mkLambda@32-1",
    "Assembly": {
      "Name": "FSI-ASSEMBLY",
      "Version": "0.0.0.0",
      "Culture": "neutral",
      "PublicKeyToken": ""
    }
  },
  "instance": {
    "rand": 824280236
  }
}

let pickleCC () : Cloud<string> = 
  fun ctx cont -> 
    let serializer = FsPickler.CreateJsonSerializer(indent = true)
    let pickle = serializer.PickleToString cont
    cont ctx pickle

let rec dive n = cloud {
    if n = 0 then
        let! c = pickleCC ()
        return c
    else
        let! c = dive (n-1)
        return c
}

cluster.Run(dive 5)

val computeDependencies : graph:obj -> AssemblyPackage []
val loadDependency : AssemblyPackage -> System.Reflection.Assembly

type AzureScheduler() =
  interface IScheduler with
    member __.Enqueue(job:IContext -> unit) =
      let dependencies = Vagabond.computeDependencies(job)
      Blob.PersistAssemblies(dependencies)
      let json = FsPickler.PickleToJson(job)
      ServiceBus.EnqueueJob(json)