Use task CE for task commands

Author: kerams

src/Fabulous/Cmd.fs

@@ -172,21 +172,60 @@ 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 msg (task: Task<'msg>) = OfAsync.msg(task |> Async.AwaitTask)
+        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>) = 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> =