Made chain take world by capture now.

Author: bryanedds

Nu/Nu/World/WorldChain.fs

@@ -9,28 +9,28 @@ open Prime
 /// The Chain monad. Allows the user to define a chain of operations over the world that
 /// optionally spans across a bounded number of events.
 type [<ReferenceEquality>] Chain<'e, 'a> =
-    Chain of (World -> Either<'e -> Chain<'e, 'a>, 'a>)
+    Chain of (unit -> Either<'e -> Chain<'e, 'a>, 'a>)
 
 /// Implements the chain monad.
 type ChainBuilder () =
 
     /// Functor map for the chain monad.
     [<DebuggerHidden; DebuggerStepThrough>]
     member this.Map (f : 'a -> 'b) (a : Chain<'e, 'a>) : Chain<'e, 'b> =
-        Chain (fun world ->
+        Chain (fun () ->                
             let chainMapper eir =
                 match eir with
-                | Left c -> Left (fun world -> this.Map f (c world))
+                | Left c -> Left (fun a -> this.Map f (c a))
                 | Right a -> Right (f a)
-            let eir = match a with Chain b -> b world
+            let eir = match a with Chain b -> b ()
             chainMapper eir)
 
     /// Applicative apply for the chain monad.
     /// TODO: Implement!
     [<DebuggerHidden; DebuggerStepThrough>]
     member this.Apply (c : Chain<'e, 'a -> 'b>) (_ : Chain<'e, 'a>) : Chain<'e, 'b> =
-        Chain (fun world ->
-            match (match c with Chain f -> f world) with
+        Chain (fun () ->
+            match (match c with Chain f -> f ()) with
             //                             ^--- NOTE: unbounded recursion here
             | _ -> failwithnie ())
 
@@ -42,11 +42,11 @@ type ChainBuilder () =
     /// Monadic bind for the chain monad.
     [<DebuggerHidden; DebuggerStepThrough>]
     member this.Bind (c : Chain<'e, 'a>, cont : 'a -> Chain<'e, 'b>) : Chain<'e, 'b> =
-        Chain (fun world ->
-            match (match c with Chain f -> f world) with
+        Chain (fun () ->
+            match (match c with Chain f -> f ()) with
             //                             ^--- NOTE: unbounded recursion here
             | Left c -> Left (fun e -> this.Bind (c e, cont))
-            | Right v -> match cont v with Chain f -> f world)
+            | Right v -> match cont v with Chain f -> f ())
 
 /// ChainBuilder operators.
 [<AutoOpen>]
@@ -70,22 +70,6 @@ module Chain =
     /// Monadic bind for the chain monad.
     let [<DebuggerHidden; DebuggerStepThrough>] inline bind c a = chain.Bind (c, a)
 
-    /// Get the world.
-    let [<DebuggerHidden>] get : Chain<'e, World> =
-        Chain (fun world -> Right world)
-
-    /// Get the world as transformed via 'by'.
-    let [<DebuggerHidden; DebuggerStepThrough>] getBy by : Chain<'e, 'a> =
-        Chain (fun world -> Right (by world))
-
-    /// Update the world with an additional transformed world parameter.
-    let [<DebuggerHidden; DebuggerStepThrough>] updateBy by expr : Chain<'e, unit> =
-        Chain (fun world -> expr (by world) world; Right ())
-
-    /// Update the world.
-    let [<DebuggerHidden; DebuggerStepThrough>] update expr : Chain<'e, unit> =
-        Chain (fun world -> expr world; Right ())
-
     /// Get the next event.
     let [<DebuggerHidden>] next : Chain<'e, 'e> =
         Chain (fun _ -> Left returnM)
@@ -98,48 +82,44 @@ module Chain =
     let [<DebuggerHidden; DebuggerStepThrough>] reactData<'a, 's when 's :> Simulant> expr : Chain<Event<'a, 's>, unit> =
        chain {
            let! e = next
-           let! world = get
-           expr (e.Data) world
+           expr (e.Data) ()
            return () }
 
     /// React to the next event, using the event's value in the reaction.
     let [<DebuggerHidden; DebuggerStepThrough>] reactEvent expr : Chain<'e, unit> =
         chain {
             let! e = next
-            let! world = get
-            expr e world
+            expr e ()
             return () }
 
     /// React to the next event, discarding the event's value.
     let [<DebuggerHidden; DebuggerStepThrough>] react expr : Chain<'e, unit> =
         chain {
             do! pass
-            let! world = get
-            expr world
+            expr ()
             return () }
 
     /// Loop in a chain context while 'pred' evaluate to true considering only the loop data.
-    let rec [<DebuggerHidden; DebuggerStepThrough>] loop (i : 'i) (step : 'i -> 'i) (pred : 'i -> World -> bool) (c : 'i -> Chain<'e, unit>) =
+    let rec [<DebuggerHidden; DebuggerStepThrough>] loop (i : 'i) (step : 'i -> 'i) (pred : 'i -> bool) (c : 'i -> Chain<'e, unit>) =
         chain {
-            let! world = get
-            do! if pred i world then
+            do! if pred i then
                     chain {
                         do! c i
                         let i = step i
                         do! loop i step pred c }
                 else returnM () }
 
     /// Loop in a chain context while 'pred' evaluates to true considering only the world state.
-    let [<DebuggerHidden; DebuggerStepThrough>] during (pred : World -> bool) (c : Chain<'e, unit>) =
-        loop () id (fun _ -> pred) (fun _ -> c)
+    let [<DebuggerHidden; DebuggerStepThrough>] during (pred : unit -> bool) (c : Chain<'e, unit>) =
+        loop () id pred (fun _ -> c)
 
     /// Step once into a chain.
-    let [<DebuggerHidden; DebuggerStepThrough>] step (c : Chain<'e, 'a>) (world : World) : Either<'e -> Chain<'e, 'a>, 'a> =
-        match c with Chain f -> f world
+    let [<DebuggerHidden; DebuggerStepThrough>] step (c : Chain<'e, 'a>) : Either<'e -> Chain<'e, 'a>, 'a> =
+        match c with Chain f -> f ()
 
     /// Advance a chain value by one step, providing 'e'.
-    let [<DebuggerHidden; DebuggerStepThrough>] advance (c : 'e -> Chain<'e, 'a>) (e : 'e) (world : World) : Either<'e -> Chain<'e, 'a>, 'a> =
-        step (c e) world
+    let [<DebuggerHidden; DebuggerStepThrough>] advance (c : 'e -> Chain<'e, 'a>) (e : 'e) : Either<'e -> Chain<'e, 'a>, 'a> =
+        step (c e)
 
 /// Chain functions for the world.
 [<AutoOpen>]
@@ -149,15 +129,15 @@ module WorldChain =
 
         /// Run a chain to its end, providing 'e' for all its steps.
         [<DebuggerHidden; DebuggerStepThrough>] 
-        static member chainConstant (c : Chain<'e, 'a>) (e : 'e) (world : World) : 'a =
-            match Chain.step c world with
-            | Left chain -> World.chainConstant (chain e) e world
+        static member chainConstant (c : Chain<'e, 'a>) (e : 'e) : 'a =
+            match Chain.step c with
+            | Left chain -> World.chainConstant (chain e) e
             | Right v -> v
 
         /// Run a chain to its end, providing unit for all its steps.
         [<DebuggerHidden; DebuggerStepThrough>]
-        static member chainUnit (c : Chain<unit, 'a>) (world : World) : 'a =
-            World.chainConstant c () world
+        static member chainUnit (c : Chain<unit, 'a>) : 'a =
+            World.chainConstant c ()
 
         /// Execute a chain over the given stream.
         [<DebuggerHidden; DebuggerStepThrough>]
@@ -173,7 +153,7 @@ module WorldChain =
                 World.unsubscribe subscriptionId world
             let advance = fun evt world ->
                 let chain = World.getEventState stateId world : Event<'a, Simulant> -> Chain<Event<'a, Simulant>, unit>
-                let advanceResult = Chain.advance chain evt world
+                let advanceResult = Chain.advance chain evt
                 match advanceResult with
                 | Right () -> unsubscribe world
                 | Left chainNext -> World.addEventState stateId chainNext world