* improved ComputationExpressions for changeable types

* added `AMap.toASetValues : amap<'k, 'v> -> aset<'v>`

Author: krauthaufen

src/FSharp.Data.Adaptive/AdaptiveHashMap/AdaptiveHashMap.fs

@@ -891,6 +891,57 @@ module AdaptiveHashMapImplementation =
 
 
             deltas
+            
+    /// Reader for toASetValues.
+    type ToValueASetReader<'Key, 'Value>(input : amap<'Key, 'Value>) =
+        inherit AbstractReader<HashSetDelta<'Value>>(HashSetDelta.empty)
+
+        let reader = input.GetReader()
+
+        static member DeltaMapping =
+            fun (oldState : HashMap<'Key, 'Value>) (ops : HashMapDelta<'Key, 'Value>) ->
+                let mutable deltas = HashSetDelta.empty
+                for (k,op) in ops do
+                    match op with
+                    | Set v ->
+                        match HashMap.tryFind k oldState with
+                        | None -> ()
+                        | Some oldValue ->
+                            deltas <- HashSetDelta.add (Rem(oldValue)) deltas
+                        deltas <- HashSetDelta.add (Add(v)) deltas
+                
+                    | Remove ->
+                        // NOTE: As it is not clear at what point the toASet computation has been evaluated last, it is 
+                        //       a valid case that something is removed that is not present in the current local state.
+                        match HashMap.tryFind k oldState with
+                        | None -> ()
+                        | Some ov ->
+                            deltas <- HashSetDelta.add (Rem (ov)) deltas
+                
+                
+                deltas
+
+        override x.Compute(token) =
+            let oldState = reader.State
+            let ops = reader.GetChanges token
+            let mutable deltas = HashSetDelta.empty
+            for (k,op) in ops do
+                match op with
+                | Set v ->
+                    match HashMap.tryFind k oldState with
+                    | None -> ()
+                    | Some oldValue ->
+                        deltas <- HashSetDelta.add (Rem(oldValue)) deltas
+                    deltas <- HashSetDelta.add (Add(v)) deltas
+                
+                | Remove ->
+                    // NOTE: As it is not clear at what point the toASet computation has been evaluated last, it is 
+                    //       a valid case that something is removed that is not present in the current local state.
+                    match HashMap.tryFind k oldState with
+                    | None -> ()
+                    | Some ov ->
+                        deltas <- HashSetDelta.add (Rem (ov)) deltas
+            deltas
 
     /// Reader for mapSet.
     type MapSetReader<'Key, 'Value>(set : aset<'Key>, mapping : 'Key -> 'Value) =
@@ -1225,6 +1276,13 @@ module AMap =
         else
             ASet.ofReader (fun () -> ToASetReader(map))
 
+    /// Creates an aset holding all distinct values from the map.
+    let toASetValues (map : amap<'Key, 'Value>) = 
+        if map.IsConstant then
+            ASet.delay (fun () -> map |> force |> HashMap.toSeq |> Seq.map snd |> HashSet.ofSeq)
+        else
+            ASet.ofReader (fun () -> ToValueASetReader(map))
+
     /// Adaptively looks up the given key in the map.
     /// Note that this operation should not be used extensively since its resulting
     /// aval will be re-evaluated upon every change of the map.

src/FSharp.Data.Adaptive/AdaptiveHashMap/AdaptiveHashMap.fsi

@@ -115,6 +115,10 @@ module AMap =
 
     /// Creates an aset holding all key/value tuples from the map.
     val toASet : map:amap<'Key,'Value> -> aset<'Key * 'Value>
+    
+    /// Creates an aset holding all distinct values from the map.
+    val toASetValues : map:amap<'Key,'Value> -> aset<'Value>
+    
 
     /// Adaptively looks up the given key in the map.
     /// Note that this operation should not be used extensively since its resulting

src/FSharp.Data.Adaptive/CollectionExtensions.fs

@@ -172,10 +172,11 @@ module CollectionExtensions =
         /// Gets the keys of the given map as aset<_>.
         let keys (map: amap<'Key, 'Value>) =
             if map.IsConstant then
-                map.Content 
-                |> AVal.force
-                |> HashMap.keys
-                |> ASet.ofHashSet
+                ASet.delay (fun () ->
+                    map.Content 
+                    |> AVal.force
+                    |> HashMap.keys
+                )
             else
                 ASet.ofReader (fun () -> MapKeysReader(map))
 
@@ -220,6 +221,9 @@ module CollectionExtensions =
 
         /// Creates an aset holding all key/value tuples from the map.
         let ofAMap (map: amap<'Key, 'Value>) = AMap.toASet map
+        
+        /// Creates an aset holding all distinct values from the map.
+        let ofAMapValues (map: amap<'Key, 'Value>) = AMap.toASetValues map
 
         /// Creates an aset holding all elements of the given list.
         let ofAList (list: alist<'T>) =
@@ -396,6 +400,12 @@ module CollectionExtensions =
                     | None ->
                         true
 
+    module AVal =
+        let logicalAnd (l : #seq<aval<bool>>) =
+            Seq.toList l |> BooleanOperators.AdaptiveAnd :> aval<_>
+
+        let logicalOr (l : #seq<aval<bool>>) =
+            Seq.toList l |> BooleanOperators.AdaptiveOr :> aval<_>
 
     /// Adaptive operators for lists.
     module List =

src/FSharp.Data.Adaptive/ComputationExpressions.fs

@@ -42,11 +42,18 @@ module ComputationExpressions =
     type ASetBuilder() =
         member inline x.Yield(value: 'T) = ASet.single value
         member inline x.YieldFrom(values: aset<'T>) = values
+        member inline x.YieldFrom(values: cset<'T>) = values :> aset<_>
         member inline x.YieldFrom(values: seq<'T>) = ASet.ofSeq values
         member inline x.YieldFrom(values: list<'T>) = ASet.ofList values
         member inline x.YieldFrom(values: 'T[]) = ASet.ofArray values
         member inline x.YieldFrom(values: HashSet<'T>) = ASet.ofHashSet values
 
+        member inline x.YieldFrom(values : alist<'T>) =
+            ASet.ofAList values
+
+        member inline x.YieldFrom(values : amap<'K, 'V>) =
+            ASet.ofAMap values
+
         member inline x.YieldFrom(values: aval<HashSet<'T>>) = 
             ASet.ofAVal values
 
@@ -76,6 +83,15 @@ module ComputationExpressions =
         member inline x.For(elements: aset<'T1>, mapping: 'T1 -> aset<'T2>) =
             ASet.collect mapping elements
 
+        member inline x.For(elements: cset<'T1>, mapping: 'T1 -> aset<'T2>) =
+            ASet.collect mapping elements
+
+        member inline x.For(elements: alist<'T1>, mapping: 'T1 -> aset<'T2>) =
+            elements |> AList.map mapping |> ASet.ofAList |> ASet.unionMany
+            
+        member inline x.For(elements: amap<'K, 'V>, mapping: ('K * 'V) -> aset<'T>) =
+            elements |> AMap.map (fun k v -> mapping(k,v)) |> ASet.ofAMapValues |> ASet.unionMany
+
         member inline x.For(elements: seq<'T1>, mapping: 'T1 -> aset<'T2>) =
             elements |> Seq.map mapping |> ASet.ofSeq |> ASet.unionMany
 
@@ -96,11 +112,23 @@ module ComputationExpressions =
     type AListBuilder() =
         member inline x.Yield(value: 'T) = AList.single value
         member inline x.YieldFrom(values: alist<'T>) = values
+        member inline x.YieldFrom(values: clist<'T>) = values :> alist<_>
         member inline x.YieldFrom(values: seq<'T>) = AList.ofSeq values
         member inline x.YieldFrom(values: list<'T>) = AList.ofList values
         member inline x.YieldFrom(values: 'T[]) = AList.ofArray values
         member inline x.YieldFrom(values: IndexList<'T>) = AList.ofIndexList values
-
+        
+        member inline x.YieldFrom(values: aval<IndexList<'T>>) = 
+            AList.ofAVal values
+            
+        member inline x.YieldFrom(values: aval<seq<'T>>) = 
+            AList.ofAVal (AVal.map IndexList.ofSeq values)
+            
+        member inline x.YieldFrom(values: aval<list<'T>>) = 
+            AList.ofAVal (AVal.map IndexList.ofList values)
+            
+        member inline x.YieldFrom(values: aval<array<'T>>) = 
+            AList.ofAVal (AVal.map IndexList.ofArray values)
 
 
         member inline x.Bind(value: aval<'T1>, mapping: 'T1 -> alist<'T2>) =
@@ -109,6 +137,9 @@ module ComputationExpressions =
         member inline x.For(elements: alist<'T1>, mapping: 'T1 -> alist<'T2>) =
             AList.collect mapping elements
 
+        member inline x.For(elements: clist<'T1>, mapping: 'T1 -> alist<'T2>) =
+            AList.collect mapping elements
+            
         member inline x.For(elements: seq<'T1>, mapping: 'T1 -> alist<'T2>) =
             elements |> Seq.map mapping |> AList.concat
 
@@ -146,6 +177,7 @@ module ComputationExpressions =
 
         member inline x.YieldFrom(value: aval<HashMap<'Key, 'Value>>) = AMap.ofAVal value
         member inline x.YieldFrom(map: amap<'Key, 'Value>) = map
+        member inline x.YieldFrom(map: cmap<'Key, 'Value>) = map :> amap<_,_>
         member inline x.YieldFrom(map: HashMap<'Key, 'Value>) = AMap.ofHashMap map
         member inline x.YieldFrom(map: ('Key * 'Value) seq) = AMap.ofSeq map
         member inline x.YieldFrom(map: ('Key * 'Value) list) = AMap.ofList map
@@ -172,14 +204,21 @@ module ComputationExpressions =
     /// tests if some ComputationExpressions compile
     module private Test =
 
-        let set (e : aval<int>) (some : aval<list<string>>) (set : aset<int>) =
+        let set (e : aval<int>) (some : aval<list<int>>) (set : aset<int>) (c : cset<int>) (m : amap<int, string>) =
             aset {
                 yield 1337
+
+                yield! c
+                yield! AMap.keys m
 
+                yield! some
                 yield! (AVal.map Seq.singleton e)
                 yield! (AVal.map List.singleton e)
                 yield! (AVal.map Array.singleton e)
                 yield! (AVal.map HashSet.single e)
+                
+                for v in c do
+                    yield v
 
                 for v in set do
                     yield v
@@ -195,22 +234,31 @@ module ComputationExpressions =
                 ()
             }
 
-        let list (e : aval<int>) (some : aval<list<string>>) (list : alist<int>) =
+        let list (e : aval<int>) (some : aval<list<int>>) (list : alist<int>) (c : clist<int>) =
             alist {
                 yield 1
 
+                yield! c
+                yield! list
+                yield! some
+
+                for e in c do
+                    yield 2*e
+
                 for e in list do
                     yield! [2*e; 2*e+1]
 
                 let! v = e
                 ()
             }
 
-        let map (k : aval<int>) (v : aval<string>) =
+        let map (k : aval<int>) (v : aval<string>) (c : cmap<int, string>) =
             amap {
                 // yield constant key and value
                 yield (1, "one")
 
+                yield! c
+
                 // yield adaptive tuple
                 yield! (k |> AVal.map (fun v -> v, string v))