Merge branch 'master' into v1.6

Author: wallymathieu

src/FSharpPlus/Data/DList.fs

@@ -1,19 +1,19 @@
 namespace FSharpPlus.Data
 
+open System
 open System.Collections.Generic
 open System.ComponentModel
+open FSharp.Core.CompilerServices
 open FSharpPlus
 
 // DList from FSharpx.Collections
 //This implementation adds an additional parameter to allow O(1) retrieval of the list length.
 
-
 type DListData<'T> =
     | Nil
     | Unit of 'T
     | Join of DListData<'T> * DListData<'T>
 
-
 /// DList is an ordered linear structure implementing the List signature (head, tail, cons), 
 /// end-insertion (add), and O(1) append. Ordering is by insertion history.
 /// DList is an implementation of [John Hughes' append list](http://dl.acm.org/citation.cfm?id=8475).
@@ -25,11 +25,11 @@ type DList<'T> (length: int, data: DListData<'T>) =
 
     static member ofSeq (s: seq<'T>) =
          DList (Seq.fold (fun (i, state) x ->
-            (i+1, 
+            (i + 1,
                 match state with
-                | Nil       -> Unit x
-                | Unit _    -> Join (state, Unit x)
-                | Join(_,_) -> Join (state, Unit x))) (0, Nil) s)
+                | Nil        -> Unit x
+                | Unit _     -> Join (state, Unit x)
+                | Join(_, _) -> Join (state, Unit x))) (0, Nil) s)
 
     override this.GetHashCode () =
         match hashCode with
@@ -42,34 +42,23 @@ type DList<'T> (length: int, data: DListData<'T>) =
         | Some hash -> hash
 
     override this.Equals other =
-        #if FABLE_COMPILER
-        let y = other :?> DList<'T>
-        if this.Length <> y.Length then false 
-        else
-            if hash this <> hash y then false
-            else Seq.forall2 Unchecked.equals this y
-        #else
         match other with
-        | :? DList<'T> as y -> 
-            if this.Length <> y.Length then false 
-            else
-                if this.GetHashCode () <> y.GetHashCode () then false
-                else Seq.forall2 Unchecked.equals this y
+        | :? DList<'T> as y -> (this :> IEquatable<DList<'T>>).Equals y
         | _ -> false
-        #endif
 
     /// O(1). Returns the count of elememts.
     member _.Length = length
 
-    // O(n). FoldBack walks the DList using constant stack space. Implementation is from Norman Ramsey.
+    // O(2n). FoldBack walks the DList using constant stack space. Implementation is from Norman Ramsey.
     // Called a "fold" in the article processes the linear representation from right to left
     // and so is more appropriately implemented under the foldBack signature
     // See http://stackoverflow.com/questions/5324623/functional-o1-append-and-on-iteration-from-first-element-list-data-structure/5334068#5334068
-    static member  foldBack (f: 'T -> 'State -> 'State) (l: DList<'T>)  (state: 'State) =
+    static member foldBack (f: 'T -> 'State -> 'State) (l: DList<'T>) (state: 'State) =
+        let f = OptimizedClosures.FSharpFunc<_, _, _>.Adapt f
         let rec walk lefts l xs =
             match l with
             | Nil         -> finish lefts xs
-            | Unit x      -> finish lefts <| f x xs
+            | Unit x      -> finish lefts <| f.Invoke (x, xs)
             | Join (x, y) -> walk (x::lefts) y xs
         and finish lefts xs =
             match lefts with
@@ -78,37 +67,35 @@ type DList<'T> (length: int, data: DListData<'T>) =
         walk [] l.dc state
 
     // making only a small adjustment to Ramsey's algorithm we get a left to right fold
-    static member  fold (f: 'State -> 'T -> 'State) (state: 'State) (l: DList<'T>)  =
-        let f = OptimizedClosures.FSharpFunc<_,_,_>.Adapt f
+    static member fold (f: 'State -> 'T -> 'State) (state: 'State) (l: DList<'T>) =
+        let f = OptimizedClosures.FSharpFunc<_, _, _>.Adapt f
         let rec walk rights l xs =
             match l with
-            | Nil       -> finish rights xs
-            | Unit x    -> finish rights <| f.Invoke (xs, x)
-            | Join(x,y) -> walk (y::rights) x xs
+            | Nil         -> finish rights xs
+            | Unit x      -> finish rights <| f.Invoke (xs, x)
+            | Join (x, y) -> walk (y::rights) x xs
         and finish rights xs =
             match rights with
             | []    -> xs
             | t::ts -> walk ts t xs
         walk [] l.dc state
 
-    static member private tryFindi (f: (int -> 'T -> bool)) (l: DList<'T>)  =
-        let f = OptimizedClosures.FSharpFunc<_,_,_>.Adapt f
+    static member private tryFindi (f: (int -> 'T -> bool)) (l: DList<'T>) =
+        let f = OptimizedClosures.FSharpFunc<_, _, _>.Adapt f
         let rec walk rights l i =
             match l with
-            | Nil       -> finish rights i
-            | Unit x    -> 
-                if f.Invoke (i, x) then
-                    Some x
-                else
-                    finish rights (i+1)
-            | Join(x,y) -> walk (y::rights) x i
+            | Nil         -> finish rights i
+            | Unit x      ->
+                if f.Invoke (i, x) then Some x
+                else finish rights (i + 1)
+            | Join (x, y) -> walk (y::rights) x i
         and finish rights xs =
             match rights with
             | []    -> None
             | t::ts -> walk ts t xs
         walk [] l.dc 0
     static member private findi (f: (int -> 'T -> bool)) (l: DList<'T>) =
-        match DList.tryFindi f l with | Some v ->v | None -> raise (System.Collections.Generic.KeyNotFoundException ()) 
+        match DList.tryFindi f l with Some v -> v | None -> raise (KeyNotFoundException ())
 
     static member append (left, right) =
         match left, right with
@@ -161,59 +148,59 @@ type DList<'T> (length: int, data: DListData<'T>) =
     member this.TryTail =
         let rec step (xs: DListData<'T>) (acc: DListData<'T>) =
             match xs with
-            | Nil -> acc | Unit _ -> acc
-            | Join (x, y)         -> step x (DList<'T>.append (y, acc))
+            | Nil | Unit _ -> acc
+            | Join (x, y)  -> step x (DList<'T>.append (y, acc))
         if this.IsEmpty then None
         else Some (DList (length - 1, step data Nil))
 
     /// O(log n). Returns the first element and tail.
-    member this.Uncons = (DList<'T>.head data, this.Tail)
+    member this.Uncons = DList<'T>.head data, this.Tail
 
     /// O(log n). Returns option first element and tail.
     member this.TryUncons =
         match DList<'T>.tryHead data with
         | Some x -> Some (x, this.Tail)
         | None   -> None
 
-    member s.Item with get (index: int) =
-                        let withIndex i _ = (i = index)
-                        if index < 0 || index >= s.Length then raise (System.IndexOutOfRangeException ())
-                        DList.findi withIndex s
+    member s.Item
+        with get (index: int) =
+            let withIndex i _ = (i = index)
+            if index < 0 || index >= s.Length then raise (IndexOutOfRangeException ())
+            DList.findi withIndex s
 
     member _.toSeq () =
         //adaptation of right-hand side of Norman Ramsey's "fold"
         let rec walk rights l = seq {
             match l with
             | Nil ->
                 match rights with
-                | []    -> () 
+                | []    -> ()
                 | t::ts -> yield! walk ts t
             | Unit x ->
                 yield x
                 match rights with
                 | []    -> ()
                 | t::ts -> yield! walk ts t
-            | Join (x, y) -> yield! walk (y::rights) x}
-               
+            | Join (x, y) -> yield! walk (y::rights) x }               
         (walk [] data).GetEnumerator ()
 
-    interface IEnumerable<'T> with
-        member s.GetEnumerator () = s.toSeq ()
-
-    interface IReadOnlyCollection<'T> with
-        member s.Count = s.Length
+    interface IEquatable<DList<'T>> with
+        member this.Equals(y: DList<'T>) =
+            if this.Length <> y.Length then false
+            elif this.GetHashCode () <> y.GetHashCode () then false
+            else Seq.forall2 Unchecked.equals this y
 
     interface IReadOnlyList<'T> with
         member s.Item with get index = s.Item index
-
-    interface System.Collections.IEnumerable with
-        override s.GetEnumerator () = (s.toSeq () :> System.Collections.IEnumerator)            
+        member s.Count = s.Length
+        member s.GetEnumerator () = s.toSeq ()
+        member s.GetEnumerator () = s.toSeq () :> System.Collections.IEnumerator
 
 
-[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
+[<RequireQualifiedAccess>]
 module DList =
     /// O(1). Returns a new DList of two lists.
-    let append left right = DList<'T>.appendLists(left, right)
+    let append left right = DList<'T>.appendLists (left, right)
 
     /// O(1). Returns a new DList with the element added to the beginning.
     let cons hd (l: DList<'T>) = 
@@ -225,8 +212,7 @@ module DList =
     [<GeneralizableValue>]
     let empty<'T> : DList<'T> = DList(0, Nil)
 
-    /// O(n). Fold walks the DList using constant stack space. Implementation is from Norman Ramsey.
-    /// See http://stackoverflow.com/questions/5324623/functional-o1-append-and-on-iteration-from-first-element-list-data-structure/5334068#5334068
+    /// Fold walks the DList using constant stack space.
     let foldBack (f: 'T -> 'State -> 'State) (l: DList<'T>) (state: 'State) = DList<'T>.foldBack f l state
 
     let fold (f: 'State -> 'T -> 'State) (state: 'State) (l: DList<'T>) = DList<'T>.fold f state l
@@ -261,18 +247,64 @@ module DList =
     /// O(log n). Returns option first element and tail.
     let inline tryUncons (l: DList<'T>) = l.TryUncons
 
-    /// O(n). Returns a DList of the seq.
+    /// Returns a DList of the seq.
     let ofSeq s = DList<'T>.ofSeq s
 
-    /// O(n). Returns a list of the DList elements.
-    let inline toList l = foldBack List.cons l []
-
-    /// O(n). Returns a seq of the DList elements.
+    /// Iterates over each element of the list.
+    let iter action (source: DList<'T>) =
+        let rec walk rights = function
+            | Nil ->
+                match rights with
+                | []    -> ()
+                | t::ts -> walk ts t
+            | Unit x ->
+                action x
+                match rights with
+                | []    -> ()
+                | t::ts -> walk ts t
+            | Join (x, y) -> walk (y::rights) x
+        walk [] source.dc    
+
+    /// Returns a list of the DList elements.
+    let toList (source: DList<'T>) =
+    #if FABLE_COMPILER
+        DList<'T>.foldBack List.cons source []
+    #else
+        let mutable coll = new ListCollector<_> ()
+        iter (fun x -> coll.Add x) source
+        coll.Close ()
+    #endif
+
+    /// Returns an array of the DList elements.
+    let toArray (source: DList<'T>) =
+    #if FABLE_COMPILER
+        source :> seq<'T> |> Seq.toArray
+    #else
+        let mutable coll = new ArrayCollector<_> ()
+        iter (fun x -> coll.Add x) source
+        coll.Close ()
+    #endif
+
+    /// Returns a seq of the DList elements.
     let inline toSeq (l: DList<'T>) = l :> seq<'T>
 
+    let pairwise (source: DList<'T>) =
+        let (|Cons|Nil|) (l: DList<'T>) = match l.TryUncons with Some (a, b) -> Cons (a, b) | None -> Nil
+        let rec pairWiseDListData cons lastvalue = function
+            | Nil            -> cons
+            | Cons (x, Nil)  -> Join (cons, Unit (lastvalue, x))
+            | Cons (x, rest) -> pairWiseDListData (Join (cons, Unit (lastvalue, x))) x rest
+        let dlistData =
+            match source with
+            | Nil | Cons (_, Nil)        -> Nil
+            | Cons (x, (Cons (y, rest))) -> pairWiseDListData (Unit (x, y)) y rest
+        match source.Length with
+        | 0 -> DList (0, Nil)
+        | _ -> DList (source.Length - 1, dlistData)
+
     // additions to fit F#+ :
     let inline map f (x: DList<_>) = DList.foldBack (cons << f ) x empty
-    let concat x = DList.fold append empty x 
+    let concat x = DList.fold append empty x
     let inline ap f x = concat <| map (fun y -> map ((|>) y) f) x
     let inline bind m k = DList.foldBack (append << k) empty m
 
@@ -283,13 +315,13 @@ type DList<'T> with
     static member (<|>) (x: DList<_>, y: DList<_>) = DList.append x y
 
     [<EditorBrowsable(EditorBrowsableState.Never)>]
-    static member ToSeq  x = DList.toSeq  x
+    static member ToSeq x = DList.toSeq x
 
     [<EditorBrowsable(EditorBrowsableState.Never)>]
     static member ToList x = DList.toList x
 
     [<EditorBrowsable(EditorBrowsableState.Never)>]
-    static member OfSeq  x = DList.ofSeq  x
+    static member OfSeq x = DList.ofSeq x
 
     [<EditorBrowsable(EditorBrowsableState.Never)>]
     static member Fold (x, f, z) = DList.fold f x z
@@ -301,4 +333,4 @@ type DList<'T> with
     static member Map (x, f) = DList.map f x
 
     static member (<*>) (f, x) = DList.ap f x
-    static member (>>=) (x, f) = DList.bind x f
+    static member (>>=) (x, f) = DList.bind x f

src/FSharpPlus/Extensions/Array.fs

@@ -55,7 +55,7 @@ module Array =
         let lenx, leny, lenz = Array.length list1, Array.length list2, Array.length list3
         let combinedFirstTwo = Array.init (lenx * leny) (fun i -> let (d, r) = Math.DivRem (i, leny) in (list1.[d], list2.[r]))
 
-        Array.init (lenx * leny * lenz) (fun i -> let (d, r) = Math.DivRem (i, leny) in combinedFirstTwo.[d], list3.[r])
+        Array.init (lenx * leny * lenz) (fun i -> let (d, r) = Math.DivRem (i, lenz) in combinedFirstTwo.[d], list3.[r])
         |> Array.map (fun x -> mapping (fst (fst x)) (snd (fst x)) (snd x))
 
     /// Concatenates all elements, using the specified separator between each element.

src/FSharpPlus/Extensions/List.fs

@@ -76,12 +76,12 @@ module List =
     /// <param name="x3">Third list.</param>
     ///
     /// <returns>List with values returned from mapping function.</returns>
-    let lift3 f x1 x2 x3 =
-    #if !FABLE_COMPILER || FABLE_COMPILER_3 || NET45 || FABLE_COMPILER_4
+    let lift3 (f: 'T1 -> 'T2 -> 'T3 -> 'U) (x1: list<'T1>) (x2: list<'T2>) (x3: list<'T3>) =
+    #if FABLE_COMPILER || NET45
         List.allPairs x2 x3
         |> List.allPairs x1
         |> List.map (fun x -> (fst (snd x), snd (snd x), fst x))
-        |> List.map (fun (x, y, z) -> f x y z)
+        |> List.map (fun (x, y, z) -> f z x y)
     #else
         let mutable coll = ListCollector<'U> ()
         x1 |> List.iter (fun x1 ->

src/FSharpPlus/Operators.fs

@@ -144,6 +144,19 @@ module Operators =
     /// <category index="1">Functor</category>
     let inline (|>>) (x: '``Functor<'T>``) (f: 'T->'U) : '``Functor<'U>`` = Map.Invoke f x
 
+    /// <summary>
+    /// Lifts a function into two Functors.
+    /// To be used in pipe-forward style expressions
+    /// </summary>
+    /// <category index="1">Functor</category>
+    let inline (|>>>) (x: '``Functor1<Functor2<'T>>``) (f: 'T -> 'U) : '``Functor1<Functor2<'U>>`` = (Map.Invoke >> Map.Invoke) f x
+
+    /// <summary>
+    /// Lifts a function into two Functors.
+    /// </summary>
+    /// <category index="1">Functor</category>
+    let inline (<<<|) (f: 'T -> 'U) (x: '``Functor1<Functor2<'T>>``) : '``Functor1<Functor2<'U>`` = (Map.Invoke >> Map.Invoke) f x
+
     /// <summary>
     /// Like map but ignoring the results.
     /// </summary>

tests/FSharpPlus.Tests/General.fs

@@ -396,6 +396,13 @@ module Functor =
         Assert.IsInstanceOf<Option<Async<int>>> (Some testVal10)
         areEqual 2 (testVal10 |> Async.RunSynchronously)
 
+    [<Test>]
+    let mapSquared () =
+        let x =
+            [Some 1; Some 2]
+            |>>> string
+        Assert.AreEqual ([Some "1"; Some "2"], x)    
+    
     [<Test>]
     let unzip () = 
         let testVal = unzip {Head = (1, 'a'); Tail = [(2, 'b');(3, 'b')]}