* added AList/IndexList.pairwise(Cyclic) with tests (#53)

* fixed bug in `MapExt.tryRemove(Min|Max)`

Author: krauthaufen

src/FSharp.Data.Adaptive/AdaptiveIndexList/AdaptiveIndexList.fs

@@ -1018,6 +1018,81 @@ module internal AdaptiveIndexListImplementation =
             let ops = IndexList.computeDelta last v
             last <- v
             ops
+    
+    /// Reader for pairwise operations
+    type PairwiseReader<'a>(input : alist<'a>, cyclic : bool) =
+        inherit AbstractReader<IndexList<'a * 'a>, IndexListDelta<'a * 'a>>(IndexList.trace)
+        
+        let reader = input.GetReader()
+
+        override x.Compute(token: AdaptiveToken) =
+            let o = reader.State
+            let ops = reader.GetChanges token
+            let s = reader.State
+
+            let inline neighbours (i : Index) =
+                let (l, _, r) = IndexList.neighbours i s
+
+                let r =
+                    match r with
+                    | None when cyclic -> s.Content.TryMin
+                    | _ -> r
+                    
+                let l =
+                    match l with
+                    | None when cyclic -> s.Content.TryMax
+                    | _ -> l
+
+                l, r
+
+            let mutable delta = IndexListDelta.empty
+            for i, op in IndexListDelta.toSeq ops do
+                match op with
+                | Remove ->
+                    match IndexList.tryGet i o with
+                    | Some _ov ->
+                        let (l, r) = neighbours i
+                        delta <- IndexListDelta.add i Remove delta
+                        match l with
+                        | Some (li, lv) ->
+                            match r with
+                            | Some (_ri, rv) ->
+                                delta <- IndexListDelta.add li (Set(lv, rv)) delta
+                            | None ->
+                                delta <- IndexListDelta.add li Remove delta
+                        | None ->
+                            ()
+                    | None ->
+                        ()
+                | Set v ->
+                    let (l, r) = neighbours i
+                    match IndexList.tryGet i o with
+                    | Some ov when CheapEquality.cheapEqual ov v ->
+                        ()
+                    | _ ->
+                        match r with
+                        | Some (_ri, rv) ->
+                            delta <- IndexListDelta.add i (Set(v, rv)) delta
+                        | None ->
+                            ()
+                    
+                        match l with
+                        | Some(li, lv) ->
+                            delta <- IndexListDelta.add li (Set(lv, v)) delta
+                        | None ->
+                            ()
+               
+            //let ref = 
+            //    if cyclic then IndexList.pairwiseCyclic s
+            //    else IndexList.pairwise s
+            //let t, _ = IndexList.applyDelta x.State delta
+
+            //if not (Unchecked.equals ref t) then
+            //    printfn "%A %A" ref t
+            
+            
+            delta
+
 
     /// Gets the current content of the alist as IndexList.
     let inline force (list : alist<'T>) = 
@@ -1334,6 +1409,22 @@ module AList =
         let inline cmp a b = compare b a
         sortWith cmp list
 
+    /// Returns a list containing all elements tupled with their successor.
+    let pairwise (list: alist<'T>) =
+        if list.IsConstant then
+            constant (fun () -> force list |> IndexList.pairwise)
+        else
+            ofReader (fun () -> PairwiseReader(list, false))
+        
+    /// Returns a list of each element tupled with its successor and the last element tupled with the first.
+    let pairwiseCyclic (list: alist<'T>) =
+        if list.IsConstant then
+            constant (fun () -> force list |> IndexList.pairwiseCyclic)
+        else
+            ofReader (fun () -> PairwiseReader(list, true))
+        
+
+
     /// Adaptively reverses the list
     let rev (list: alist<'T>) =
         // TODO: more efficient implementation possible?

src/FSharp.Data.Adaptive/AdaptiveIndexList/AdaptiveIndexList.fsi

@@ -184,6 +184,12 @@ module AList =
     val inline sortDescending : list: alist<'T> -> alist<'T>
         when 'T : comparison
 
+    /// Returns a list containing all elements tupled with their successor.
+    val pairwise : list: alist<'T> -> alist<'T * 'T>
+    
+    /// Returns a list of each element tupled with its successor and the last element tupled with the first.
+    val pairwiseCyclic : list: alist<'T> -> alist<'T * 'T>
+
     /// Tries to get the element associated to a specific Index from the list.
     /// Note that this operation should not be used extensively since its resulting
     /// aval will be re-evaluated upon every change of the list.

src/FSharp.Data.Adaptive/Datastructures/IndexList.fs

@@ -335,6 +335,53 @@ type IndexList< [<EqualityConditionalOn>] 'T> internal(l : Index, h : Index, con
         let (p,_,_) = MapExt.neighbours index content
         p
 
+    /// Returns a list of each element tupled with its successor. 
+    member x.Pairwise() =
+        match MapExt.tryRemoveMin content with
+        | Some (i0, v0, rest) ->
+            let mutable res = MapExt.empty
+            let mutable rest = rest
+            let mutable lastIndex = l
+            let mutable i0 = i0
+            let mutable v0 = v0
+            while not (MapExt.isEmpty rest) do
+                match MapExt.tryRemoveMin rest with
+                | Some (i1, v1, r) ->
+                    res <- MapExt.add i0 (v0, v1) res
+                    lastIndex <- i0
+                    i0 <- i1
+                    v0 <- v1
+                    rest <- r
+                | None ->
+                    ()
+
+            IndexList(l, lastIndex, res)
+        | None ->
+            IndexList.Empty
+            
+    /// Returns a list of each element tupled with its successor and the last element tupled with the first.
+    member x.PairwiseCyclic() =
+        match MapExt.tryRemoveMin content with
+        | Some (i0, initial, rest) ->
+            let mutable res = MapExt.empty
+            let mutable rest = rest
+            let mutable i0 = i0
+            let mutable v0 = initial
+            while not (MapExt.isEmpty rest) do
+                match MapExt.tryRemoveMin rest with
+                | Some (i1, v1, r) ->
+                    res <- MapExt.add i0 (v0, v1) res
+                    i0 <- i1
+                    v0 <- v1
+                    rest <- r
+                | None ->
+                    ()
+
+            res <- MapExt.add i0 (v0, initial) res
+            IndexList(l, i0, res)
+        | None ->
+            IndexList.Empty
+    
     override x.ToString() =
         let suffix =
             if x.Count > 5 then "; ..."
@@ -660,6 +707,15 @@ module IndexList =
     let tryPickBack (mapping : Index -> 'T1 -> option<'T2>) (list : IndexList<'T1>) = 
         list.Content |> MapExt.tryPickBack mapping
 
+    
+    /// Returns a list of each element tupled with its successor.
+    let inline pairwise (l : IndexList<'T>) =
+        l.Pairwise()
+
+    /// Returns a list of each element tupled with its successor and the last element tupled with the first.
+    let inline pairwiseCyclic (l : IndexList<'T>) =
+        l.PairwiseCyclic()
+
     /// concats the given lists.
     let append (l : IndexList<'T>) (r : IndexList<'T>) =
         if l.Count = 0 then r
@@ -712,6 +768,15 @@ module IndexList =
     /// all elements from the list with their respective Index.
     let toArrayIndexed (list: IndexList<'T>) = list.Content |> MapExt.toArray
 
+    /// all elements from the list with their respective Index in reveresed order.
+    let toSeqIndexedBack (list: IndexList<'T>) = list.Content |> MapExt.toSeqBack
+
+    /// all elements from the list with their respective Index in reveresed order.
+    let toListIndexedBack (list: IndexList<'T>) = list.Content |> MapExt.toSeqBack |> Seq.toList
+    
+    /// all elements from the list with their respective Index in reveresed order.
+    let toArrayIndexedBack (list: IndexList<'T>) = list.Content |> MapExt.toSeqBack |> Seq.toArray
+
     /// creates a new IndexList containing all the given elements at their respective Index.
     let ofSeqIndexed (elements: seq<Index * 'T>) = MapExt.ofSeq elements |> ofMap
 

src/FSharp.Data.Adaptive/Datastructures/MapExt.fs

@@ -225,7 +225,7 @@ module internal MapExtImplementation =
                         None
 
 
-        let rec tryRemoveMin m = 
+        let rec tryRemoveMin cmp m = 
             match m with 
             | MapEmpty -> 
                 None
@@ -234,15 +234,15 @@ module internal MapExtImplementation =
                 Some (k2, v, MapEmpty)
 
             | MapNode(k2,v2,l,r,_,_) -> 
-                match tryRemoveMin l with
+                match tryRemoveMin cmp l with
                 | Some (k,v,rest) ->
                     match rest with
-                    | MapEmpty -> Some (k,v,r)
-                    | _ -> Some (k,v, rebalance rest k2 v2 r)
+                    | MapEmpty -> Some (k, v, add cmp k2 v2 r)
+                    | _ -> Some (k, v, rebalance rest k2 v2 r)
                 | None ->
                     Some(k2, v2, r)
 
-        let rec tryRemoveMax m = 
+        let rec tryRemoveMax cmp m = 
             match m with 
             | MapEmpty -> 
                 None
@@ -251,11 +251,11 @@ module internal MapExtImplementation =
                 Some (k2, v, MapEmpty)
 
             | MapNode(k2,v2,l,r,_,_) -> 
-                match tryRemoveMax r with
+                match tryRemoveMax cmp r with
                 | Some (k,v,rest) ->
                     match rest with
-                    | MapEmpty -> Some (k,v,l)
-                    | _ -> Some (k,v, rebalance l k2 v2 rest)
+                    | MapEmpty -> Some (k, v, add cmp k2 v2 l)
+                    | _ -> Some (k, v, rebalance l k2 v2 rest)
                 | None ->
                     Some(k2, v2, l)
 
@@ -1583,12 +1583,12 @@ type internal MapExt<[<EqualityConditionalOn>]'Key,[<EqualityConditionalOn;Compa
             | _ -> None
 
     member x.TryRemoveMin() = 
-        match MapTree.tryRemoveMin tree with
+        match MapTree.tryRemoveMin comparer tree with
         | Some (k,v,t) -> Some(k,v, MapExt(comparer, t))
         | None -> None
 
     member x.TryRemoveMax() = 
-        match MapTree.tryRemoveMax tree with
+        match MapTree.tryRemoveMax comparer tree with
         | Some (k,v,t) -> Some(k,v, MapExt(comparer, t))
         | None -> None
 
@@ -1628,6 +1628,9 @@ type internal MapExt<[<EqualityConditionalOn>]'Key,[<EqualityConditionalOn;Compa
         new MapExt<'Key,'Value>(comparer,r1), new MapExt<'Key,'Value>(comparer,r2)
 
     member m.Count = MapTree.size tree
+    
+    member x.TryMin = MapTree.tryMin tree
+    member x.TryMax = MapTree.tryMax tree
 
     member x.TryMinKey = MapTree.tryMin tree |> Option.map fst
     member x.TryMaxKey = MapTree.tryMax tree |> Option.map fst

src/Test/FSharp.Data.Adaptive.Reference/AdaptiveIndexList.fs

@@ -122,3 +122,9 @@ module AList =
 
     let sortWith (compare: 'T -> 'T -> int) (list : alist<'T>) =
         list.Content |> AVal.map (IndexList.sortWith compare) |> ofRef
+
+    let pairwise (list : alist<'T>) =
+        list.Content |> AVal.map IndexList.pairwise |> ofRef
+
+    let pairwiseCyclic (list : alist<'T>) =
+        list.Content |> AVal.map IndexList.pairwiseCyclic |> ofRef

src/Test/FSharp.Data.Adaptive.Tests/Utilities/Generators.fs

@@ -1519,6 +1519,40 @@ module Generators =
                         getChanges
             }
 
+
+        let pairwise<'a>() =
+            gen {
+                let! list = Arb.generate<VList<'a>> |> Gen.scaleSize (fun v -> v - 1)
+                let fc, f = randomFunction2<'a, 'a, 'a>()
+
+                return 
+                    create 
+                        (Adaptive.AList.pairwise list.lreal |> Adaptive.AList.mapi (fun i (l,r) -> f l r))
+                        (Reference.AList.pairwise list.lref |> Reference.AList.mapi (fun i (l,r) -> f l r))
+                        (fun verbose ->
+                            let ma, a = list.lexpression verbose
+                            ma, sprintf "pairwise\r\n%s" (indent a)
+                        )
+                        list.lchanges
+            }
+            
+        let pairwiseCyclic<'a>() =
+            gen {
+                let! list = Arb.generate<VList<'a>> |> Gen.scaleSize (fun v -> v - 1)
+                let fc, f = randomFunction2<'a, 'a, 'a>()
+
+                return 
+                    create 
+                        (Adaptive.AList.pairwiseCyclic list.lreal |> Adaptive.AList.mapi (fun i (l,r) -> f l r))
+                        (Reference.AList.pairwiseCyclic list.lref |> Reference.AList.mapi (fun i (l,r) -> f l r))
+                        (fun verbose ->
+                            let ma, a = list.lexpression verbose
+                            ma, sprintf "pairwiseCyclic\r\n%s" (indent a)
+                        )
+                        list.lchanges
+            }
+
+
 [<Struct; CustomEquality; NoComparison>]
 type StupidHash(v : int) =
     member x.Value = v
@@ -1784,6 +1818,8 @@ type AdaptiveGenerators() =
                                     yield 3, Gen.constant "sortBy"
                                     yield 3, Gen.constant "sortWith"
                                     yield 3, Gen.constant "ofAVal"
+                                    yield 2, Gen.constant "pairwise"
+                                    yield 2, Gen.constant "pairwiseCyclic"
                                     if typeof<IComparable>.IsAssignableFrom typeof<'a> then
                                         yield 3, Gen.constant "setSortBy"
                                         yield 3, Gen.constant "setSortWith"
@@ -1799,6 +1835,10 @@ type AdaptiveGenerators() =
                             return! Generators.List.append<'a>()
                         | "ofAVal" ->
                             return! Generators.List.ofAVal<'a>()
+                        | "pairwise" ->
+                            return! Generators.List.pairwise<'a>()
+                        | "pairwiseCyclic" ->
+                            return! Generators.List.pairwiseCyclic<'a>()
                         | "sortBy" ->
                             return! Generators.List.sortBy<'a>()
                         | "sortWith" ->