Merge pull request #1104 from kerams/task

Use task CE for task commands

Author: edgarfgp

src/Fabulous/Cmd.fs

@@ -172,21 +172,57 @@ module Cmd =
 
     module OfTask =
         /// Command to call a task and map the results
-        let inline either (task: 'a -> Task<_>) (arg: 'a) (ofSuccess: _ -> 'msg) (ofError: _ -> 'msg) : Cmd<'msg> =
-            OfAsync.either (task >> Async.AwaitTask) arg ofSuccess ofError
+        let inline either
+            ([<InlineIfLambda>] task: 'a -> Task<_>)
+            (arg: 'a)
+            ([<InlineIfLambda>] ofSuccess: _ -> 'msg)
+            ([<InlineIfLambda>] ofError: _ -> 'msg)
+            : Cmd<'msg> =
+            [ fun dispatch ->
+                  backgroundTask {
+                      try
+                          let! r = task arg
+                          ofSuccess r |> dispatch
+                      with e ->
+                          ofError e |> dispatch
+                  }
+                  |> ignore<Task<_>> ]
 
         /// Command to call a task and map the success
-        let inline perform (task: 'a -> Task<_>) (arg: 'a) (ofSuccess: _ -> 'msg) : Cmd<'msg> =
-            OfAsync.perform (task >> Async.AwaitTask) arg ofSuccess
+        let inline perform ([<InlineIfLambda>] task: 'a -> Task<_>) (arg: 'a) ([<InlineIfLambda>] ofSuccess: _ -> 'msg) : Cmd<'msg> =
+            [ fun dispatch ->
+                  backgroundTask {
+                      try
+                          let! r = task arg
+                          ofSuccess r |> dispatch
+                      with _ ->
+                          ()
+                  }
+                  |> ignore<Task<_>> ]
 
         /// Command to call a task and map the error
-        let inline attempt (task: 'a -> #Task) (arg: 'a) (ofError: _ -> 'msg) : Cmd<'msg> =
-            OfAsync.attempt (task >> Async.AwaitTask) arg ofError
+        let inline attempt ([<InlineIfLambda>] task: 'a -> #Task) (arg: 'a) ([<InlineIfLambda>] ofError: _ -> 'msg) : Cmd<'msg> =
+            [ fun dispatch ->
+                  backgroundTask {
+                      try
+                          do! task arg
+                      with e ->
+                          ofError e |> dispatch
+                  }
+                  |> ignore<Task<_>> ]
 
-        let inline msg (task: Task<'msg>) = OfAsync.msg(task |> Async.AwaitTask)
+        let inline msg (task: Task<'msg>) = perform (fun () -> task) () id
 
         let inline msgOption (task: Task<'msg option>) =
-            OfAsync.msgOption(task |> Async.AwaitTask)
+            [ fun dispatch ->
+                  backgroundTask {
+                      let! r = task
+
+                      match r with
+                      | Some x -> dispatch x
+                      | None -> ()
+                  }
+                  |> ignore<Task<_>> ]
 
     /// Command to issue a message if no other message has been issued within the specified timeout
     let debounce (timeout: int) (fn: 'value -> 'msg) : 'value -> Cmd<'msg> =