* added several slicing combinators and some tests for them

Author: krauthaufen

RELEASE_NOTES.md

@@ -1,3 +1,7 @@
+### 1.2.7
+* several AList bugfixes
+* added AList slicing utilities
+
 ### 1.2.6
 * added `AMap.choose2(V)` and derived combinators (`intersectWith`, `intersect(V)`)
 

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

@@ -1271,6 +1271,68 @@ module internal AdaptiveIndexListImplementation =
                         |> IndexListDelta
 
 
+    [<Sealed>]
+    type SkipReader<'a>(input : alist<'a>, offset : aval<int>) =
+        inherit AbstractReader<IndexListDelta<'a>>(IndexListDelta.empty)
+
+        let reader = input.GetReader()
+        let mutable state = MapExt.empty
+        let mutable minIndex = Index.zero
+
+        override x.Compute(token : AdaptiveToken) = 
+            let ops = reader.GetChanges token
+            let offset = offset.GetValue token
+
+            if MapExt.isEmpty state then
+                let part = reader.State.Content.SliceAt(offset, reader.State.Count - 1)
+                state <- part
+                if not (MapExt.isEmpty state) then
+                    minIndex <- MapExt.minKey state
+                part |> MapExt.map (fun _ v -> Set v) |> IndexListDelta
+                
+            else
+                let part = reader.State.Content.SliceAt(offset, reader.State.Count - 1)
+                if MapExt.isEmpty part then
+                    let delta = 
+                        state 
+                        |> MapExt.map (fun _ _ -> Remove)
+                        |> IndexListDelta
+                    state <- MapExt.empty
+                    minIndex <- Index.zero
+                    delta
+                else
+                    let newMin = MapExt.minKey part
+                    let newMax = MapExt.maxKey part
+
+                    if newMax < minIndex then
+                        let ops = 
+                            MapExt.union
+                                (state |> MapExt.map (fun _ _ -> Remove))
+                                (part |> MapExt.map (fun _ v -> Set v))
+                        state <- part
+                        minIndex <- newMin
+                        IndexListDelta ops
+                    else
+
+                        let mutable delta = ops.Content.[newMin .. newMax]
+
+
+                        let lDelta =
+                            if minIndex < newMin then 
+                                reader.State.Content.WithMin(minIndex).WithMaxExclusive(newMin)
+                                |> MapExt.map (fun _ _ -> Remove)
+                            elif newMin < minIndex then
+                                reader.State.Content.WithMin(newMin).WithMaxExclusive(minIndex)
+                                |> MapExt.map (fun _ v -> Set v)
+                            else
+                                MapExt.empty
+
+                        minIndex <- newMin
+                        state <- part
+                        MapExt.union lDelta delta
+                        |> IndexListDelta
+
+
 
 
 
@@ -1615,6 +1677,22 @@ module AList =
     let sub (offset: int) (count: int) (list: alist<'T>) =
         subA (AVal.constant offset) (AVal.constant count) list
 
+    let take (count: int) (list: alist<'T>) =
+        sub 0 count list
+        
+    let takeA (count: aval<int>) (list: alist<'T>) =
+        subA (AVal.constant 0) count list
+        
+    let skipA (count: aval<int>) (list: alist<'T>) =
+        if count.IsConstant && list.IsConstant then
+            constant (fun () -> IndexList.skip (AVal.force count) (force list))
+        else
+            ofReader (fun () -> SkipReader(list, count))
+
+    let skip (count: int) (list: alist<'T>) =
+        skipA (AVal.constant count) list
+        
+
 
     /// Adaptively reverses the list
     let rev (list: alist<'T>) =
@@ -1808,3 +1886,4 @@ module AList =
     /// Adaptively computes the product of all entries in the list.
     let inline product (s : alist<'a>) = 
         reduce (AdaptiveReduction.product()) s
+

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

@@ -190,8 +190,23 @@ module AList =
     /// 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>
 
+    /// adaptively skips `offset` elements and takes `count`
     val subA : offset : aval<int> -> count : aval<int> -> alist<'T> -> alist<'T>
+    
+    /// adaptively skips `offset` elements and takes `count`
     val sub : offset : int -> count : int -> alist<'T> -> alist<'T>
+    
+    /// adaptively takes `count` elements
+    val take : count : int -> alist<'T> -> alist<'T>
+
+    /// adaptively takes `count` elements
+    val takeA : count : aval<int> -> alist<'T> -> alist<'T>
+    
+    /// adaptively skips `count` elements
+    val skip : count : int -> alist<'T> -> alist<'T>
+    
+    /// adaptively skips `count` elements
+    val skipA : count : aval<int> -> alist<'T> -> alist<'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

src/FSharp.Data.Adaptive/CollectionExtensions.fs

@@ -6,6 +6,33 @@ open FSharp.Data.Traceable
 [<AutoOpen>]
 module CollectionExtensions =
 
+    type IAdaptiveIndexList<'T> with
+        member x.GetSlice(min : option<int>, max : option<int>) =
+            match min with
+            | Some min ->
+                match max with
+                | Some max -> AList.sub min (1 + max - min) x
+                | None -> AList.skip min x
+            | None ->
+                match max with
+                | Some max -> AList.take (1 + max) x
+                | None -> x
+
+        member x.GetSlice(min : option<aval<int>>, max : option<aval<int>>) =
+            match min with
+            | Some min ->
+                match max with
+                | Some max -> 
+                    let cnt = (min, max) ||> AVal.map2 (fun min max -> 1 + max - min)
+                    AList.subA min cnt x
+                | None -> AList.skipA min x
+            | None ->
+                match max with
+                | Some max -> 
+                    let cnt = max |> AVal.map (fun max -> 1 + max)
+                    AList.takeA cnt x
+                | None -> x
+
     [<AutoOpen>]
     module internal Readers =
         /// Reader for ASet.sortBy

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

@@ -130,6 +130,8 @@ type IndexList< [<EqualityConditionalOn>] 'T> internal(l : Index, h : Index, con
                 if c.IsEmpty then IndexList.Empty
                 else IndexList(MapExt.minKey c, MapExt.maxKey c, c)
 
+
+
     /// Appends the given element to the list.
     member x.Add(element : 'T) =
         if content.Count = 0 then
@@ -883,6 +885,7 @@ module IndexList =
         | struct(ValueSome lmax, ValueSome rmin) ->
             IndexList<'T>(list.MinIndex, lmax, l), s, IndexList<'T>(rmin, list.MaxIndex, r)
 
+
     /// updates or creates the element at the given index.
     /// note that out-of-bounds-indices will be ineffective.
     let inline setAt (index : int) (v : 'T) (list : IndexList<'T>) = 
@@ -959,22 +962,39 @@ module IndexList =
         elif index >= list.Count then
             list, None, empty
         else
-            let struct(index,_) = list.Content.GetItemV(index)
-            split index list
+            let (l, s, r) = list.Content.SplitAt(index)
+            ofMap l, Option.map snd s, ofMap r
+
+    /// splits the list at the given index and returns both (possibly empty) halves and (optional) splitting element.
+    let splitAti (index : int) (list : IndexList<'T>) =
+        if index < 0 then
+            empty, None, list
+        elif index >= list.Count then
+            list, None, empty
+        else
+            let (l, s, r) = list.Content.SplitAt(index)
+            ofMap l, s, ofMap r
+
 
-      
-        
     /// gets the optional min-index used by the list.
-    let tryFirstIndex (list : IndexList<'T>) = list.Content.TryMinKey()
+    let tryFirstIndex (list : IndexList<'T>) = 
+        if list.IsEmpty then None
+        else Some list.MinIndex
 
     /// gets the optional max-index used by the list.
-    let tryLastIndex (list : IndexList<'T>) = list.Content.TryMaxKey()
+    let tryLastIndex (list : IndexList<'T>) =
+        if list.IsEmpty then None
+        else Some list.MaxIndex
 
     /// gets the min-index used by the list or fails if empty.
-    let firstIndex (list : IndexList<'T>) = MapExt.minKey list.Content
+    let firstIndex (list : IndexList<'T>) =     
+        if list.IsEmpty then failwith "empty list"
+        else list.MinIndex
 
     /// gets the max-index used by the list or fails if empty.
-    let lastIndex (list : IndexList<'T>) = MapExt.maxKey list.Content
+    let lastIndex (list : IndexList<'T>) = 
+        if list.IsEmpty then failwith "empty list"
+        else list.MaxIndex
 
     /// gets the optional first element from the list.
     let tryFirst (list : IndexList<'T>) = list.Content.TryMinValue()
@@ -1115,6 +1135,14 @@ module IndexList =
             let c = list.Content.Skip n
             IndexList<'T>(MapExt.minKey c, list.MaxIndex, c)
 
+    /// skips `offset` elements and takes `count`
+    let sub (offset : int) (count : int) (list : IndexList<'T>) =
+        if count <= 0 then empty
+        elif offset >= list.Count then empty
+        else
+            list.Content.SliceAt(offset, offset + count - 1)
+            |> ofMap
+
     /// creates a list containing a single element.
     let single (v : 'T) =
         let t = Index.after Index.zero

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

@@ -1251,6 +1251,32 @@ module internal MapExtImplementation =
         let hasValue = traverse node
         struct(hasValue, left, self, right)
 
+
+    let rec splitAt
+        (index : int)
+        (node : Node<'Key, 'Value>) =
+        if index < 0 then
+            struct(null, None, node)
+        elif isNull node then
+            struct(null, None, null)
+        elif node.Height = 1uy then
+            if index < 0 then struct(null, None, node)
+            elif index > 0 then struct(node, None, null)
+            else struct(null, Some(node.Key, node.Value), null)
+        else
+            let node = node :?> Inner<'Key, 'Value>
+
+            let lc = count node.Left
+            if index = lc then
+                struct(node.Left, Some(node.Key, node.Value), node.Right)
+            elif index > lc then
+                let struct(r0, s, r1) = splitAt (index - lc - 1) node.Right
+                struct(binary node.Left node.Key node.Value r0, s, r1)
+            else
+                let struct(l0, s, l1) = splitAt index node.Left
+                struct(l0, s, binary l1 node.Key node.Value node.Right)
+
+
     let rec private changeWithLeft
         (cmp : IComparer<'Key>)
         (key : 'Key)
@@ -1640,6 +1666,58 @@ module internal MapExtImplementation =
             else (* cMax < 0 *)
                 // max smaller than split-key
                 slice cmp minKey maxKey node.Left
+                
+    let rec sliceEx (cmp : IComparer<'Key>) (minKey : 'Key) (minInclusive : bool) (maxKey : 'Key) (maxInclusive : bool) (node : Node<'Key, 'Value>) =
+        if isNull node then
+            node
+        elif node.Height = 1uy then
+            let cMin = cmp.Compare(minKey, node.Key)
+            if cMin < 0 then
+                let cMax = cmp.Compare(maxKey, node.Key)
+                if cMax > 0 then node
+                elif cMax < 0 then null
+                elif maxInclusive then node
+                else null
+            elif cMin > 0 then null
+            elif minInclusive then node
+            else null
+        else
+            let node = node :?> Inner<'Key, 'Value>
+            let cMin = cmp.Compare(minKey, node.Key)
+            let cMax = cmp.Compare(maxKey, node.Key)
+
+            if cMin < 0 && cMax > 0 then
+                // split-key contained
+                let left =
+                    if minInclusive then withMin cmp minKey node.Left
+                    else let (n,_,_) = withMinExclusiveN cmp minKey node.Left in n
+
+                let right =
+                    if maxInclusive then withMax cmp maxKey node.Right
+                    else let (n,_,_) = withMaxExclusiveN cmp maxKey node.Right in n
+                        
+                binary left node.Key node.Value right
+
+            elif cMin = 0 then
+                let right =
+                    if maxInclusive then withMax cmp maxKey node.Right
+                    else let (n,_,_) = withMaxExclusiveN cmp maxKey node.Right in n
+                if minInclusive then unsafeAddMinimum node.Key node.Value right
+                else right
+
+            elif cMax = 0 then
+                let left =
+                    if minInclusive then withMin cmp minKey node.Left
+                    else let (n,_,_) = withMinExclusiveN cmp minKey node.Left in n
+                if maxInclusive then unsafeAddMaximum node.Key node.Value left
+                else left
+
+            elif cMin > 0 then  
+                // min larger than split-key
+                sliceEx cmp minKey minInclusive maxKey maxInclusive node.Right
+            else (* cMax < 0 *)
+                // max smaller than split-key
+                sliceEx cmp minKey minInclusive maxKey maxInclusive node.Left
 
     let rec take (n : int) (node : Node<'Key, 'Value>) =
         if n <= 0 || isNull node then
@@ -3286,9 +3364,15 @@ type internal MapExt<'Key, 'Value when 'Key : comparison>(comparer : IComparer<'
         let n, _, _ = MapExtImplementation.withMaxExclusiveN comparer min root
         MapExt(comparer, n)
 
-    member x.Slice(min : 'Key, max : 'Key) = MapExt(comparer, MapExtImplementation.slice comparer min max root)
-    member x.SliceAt(min : int, max : int) = MapExt(comparer, MapExtImplementation.sliceAt min max root)
+    member x.Slice(min : 'Key, max : 'Key) = 
+        MapExt(comparer, MapExtImplementation.slice comparer min max root)
+
+    member x.SliceAt(min : int, max : int) = 
+        MapExt(comparer, MapExtImplementation.sliceAt min max root)
 
+    member x.Slice(min : 'Key, minInclusive : bool, max : 'Key, maxInclusive : bool) = 
+        MapExt(comparer, MapExtImplementation.sliceEx comparer min minInclusive max maxInclusive root)
+
 
     member x.Take(n : int) =
         MapExt(comparer, MapExtImplementation.take n root)
@@ -3310,6 +3394,17 @@ type internal MapExt<'Key, 'Value when 'Key : comparison>(comparer : IComparer<'
         else
             struct(MapExt(comparer, l), ValueNone, MapExt(comparer, r))
 
+
+    member x.SplitAt(index : int) =
+        if index < 0 then 
+            empty, None, x
+        elif index >= MapExtImplementation.count root then
+            x, None, empty
+        else
+            let struct(l, s, r) = MapExtImplementation.splitAt index root
+            (MapExt(comparer, l), s, MapExt(comparer, r))
+
+
 
 
     member x.ReplaceRangeV(min : 'Key, max : 'Key, replace : voption<struct('Key * 'Value)> -> voption<struct('Key * 'Value)> -> struct(voption<'Value> * voption<'Value>)) =