AVal updates

* implemented new builder methods as proposed in dotnet/fsharp#7756
* implemented `AVal.bind3`

Author: krauthaufen

src/FSharp.Data.Adaptive/AdaptiveValue/AdaptiveValue.fs

@@ -252,6 +252,43 @@ module AVal =
                 let res = mapping.Invoke (va, vb)
                 inner <- ValueSome (struct (va, vb, res))
                 res.GetValue token     
+    
+    /// Aval for binding three values in 'parallel'
+    type Bind3Val<'T1, 'T2, 'T3, 'T4>(mapping: 'T1 -> 'T2 -> 'T3 -> aval<'T4>, value1: aval<'T1>, value2: aval<'T2>, value3: aval<'T3>) =
+        inherit AbstractVal<'T4>()
+
+        let mapping = OptimizedClosures.FSharpFunc<'T1, 'T2, 'T3, aval<'T4>>.Adapt(mapping)
+        let mutable inner: ValueOption< struct ('T1 * 'T2 * 'T3 * aval<'T4>) > = ValueNone
+        let mutable inputDirty = 1
+
+        override x.InputChangedObject(_, o) =
+            if Object.ReferenceEquals(o, value1) || Object.ReferenceEquals(o, value2) || Object.ReferenceEquals(o, value3) then 
+                inputDirty <- 1
+
+        override x.Compute(token: AdaptiveToken) =
+            let va = value1.GetValue token
+            let vb = value2.GetValue token
+            let vc = value3.GetValue token
+            #if FABLE_COMPILER
+            let inputDirty = let v = inputDirty in inputDirty <- 0; v <> 0
+            #else
+            let inputDirty = System.Threading.Interlocked.Exchange(&inputDirty, 0) <> 0
+            #endif
+            
+            match inner with
+            | ValueNone ->
+                let res = mapping.Invoke (va, vb, vc)
+                inner <- ValueSome (struct (va, vb, vc, res))
+                res.GetValue token  
+
+            | ValueSome(struct (oa, ob, oc, res)) when not inputDirty || (cheapEqual oa va && cheapEqual ob vb && cheapEqual oc vc) ->
+                res.GetValue token
+
+            | ValueSome(struct (_, _, _, old)) ->
+                old.Outputs.Remove x |> ignore
+                let res = mapping.Invoke (va, vb, vc)
+                inner <- ValueSome (struct (va, vb, vc, res))
+                res.GetValue token     
 
     /// Aval for custom computations
     type CustomVal<'T>(compute: AdaptiveToken -> 'T) =
@@ -337,5 +374,23 @@ module AVal =
         else
             Bind2Val<'T1, 'T2, 'T3>(mapping, value1, value2) :> aval<_>       
 
+    let bind3 (mapping: 'T1 -> 'T2 -> 'T3 -> aval<'T4>) (value1: aval<'T1>) (value2: aval<'T2>) (value3: aval<'T3>) =
+        if value1.IsConstant && value2.IsConstant && value3.IsConstant then
+            mapping (force value1) (force value2) (force value3)
+
+        elif value1.IsConstant then
+            let a = force value1
+            bind2 (fun b c -> mapping a b c) value2 value3
+
+        elif value2.IsConstant then
+            let b = force value2
+            bind2 (fun a c -> mapping a b c) value1 value3
+            
+        elif value3.IsConstant then
+            let c = force value3
+            bind2 (fun a b -> mapping a b c) value1 value2
+        else
+            Bind3Val<'T1, 'T2, 'T3, 'T4>(mapping, value1, value2, value3) :> aval<_>       
+
     let custom (compute: AdaptiveToken -> 'T) =
         CustomVal compute :> aval<_>

src/FSharp.Data.Adaptive/AdaptiveValue/AdaptiveValue.fsi

@@ -76,6 +76,11 @@ module AVal =
     /// adaptively depends on the adaptive value returned by mapping.
     /// The resulting aval<'T3> will hold the latest value of the aval<_> returned by mapping.
     val bind2 : mapping : ('T1 -> 'T2 -> aval<'T3>) -> value1 : aval<'T1> -> value2 : aval<'T2> -> aval<'T3>
+    
+    /// Adaptively applies the mapping function to the given adaptive values and
+    /// adaptively depends on the adaptive value returned by mapping.
+    /// The resulting aval<'T4> will hold the latest value of the aval<_> returned by mapping.
+    val bind3 : mapping : ('T1 -> 'T2 -> 'T3 -> aval<'T4>) -> value1 : aval<'T1> -> value2 : aval<'T2> -> value2 : aval<'T3> -> aval<'T4>
 
     /// Creates a custom adaptive value using the given computation.
     /// Callers are responsible for removing inputs that are no longer needed.

src/FSharp.Data.Adaptive/ComputationExpressions.fs

@@ -7,10 +7,30 @@ module ComputationExpressions =
 
     /// ComputationExpression builder for aval.
     type AValBuilder() =
-        static let delayed = AVal.custom ignore
+        
+        member inline x.MergeSources(v1 : aval<'T1>, v2 : aval<'T2>) =
+            AVal.map2 (fun a b -> a,b) v1 v2
+            
+        member inline x.MergeSources3(v1 : aval<'T1>, v2 : aval<'T2>, v3 : aval<'T3>) =
+            AVal.map3 (fun a b c -> a,b,c) v1 v2 v3
+
+        member inline x.BindReturn(value : aval<'T1>, mapping: 'T1 -> 'T2) =
+            AVal.map mapping value
+            
+        member inline x.Bind2Return(v1 : aval<'T1>, v2 : aval<'T2>, mapping: 'T1 -> 'T2 -> 'T3) =
+            AVal.map2 mapping v1 v2
+
+        member inline x.Bind3Return(v1 : aval<'T1>, v2: aval<'T2>, v3: aval<'T3>, mapping: 'T1 -> 'T2 -> 'T3 -> 'T4) =
+            AVal.map3 mapping v1 v2 v3
 
         member inline x.Bind(value: aval<'T1>, mapping: 'T1 -> aval<'T2>) =
             AVal.bind mapping value
+            
+        member inline x.Bind2(v1: aval<'T1>, v2: aval<'T2>, mapping: 'T1 -> 'T2 -> aval<'T3>) =
+            AVal.bind2 mapping v1 v2
+            
+        member inline x.Bind3(v1: aval<'T1>, v2: aval<'T2>, v3: aval<'T3>, mapping: 'T1 -> 'T2 -> 'T3 -> aval<'T4>) =
+            AVal.bind3 mapping v1 v2 v3
 
         member inline x.Return(value: 'T) =
             AVal.constant value