Bump to Fable 3.1.15 (#434)

Author: wallymathieu

.config/dotnet-tools.json

@@ -15,7 +15,7 @@
       ]
     },
     "fable": {
-      "version": "3.0.4",
+      "version": "3.1.15",
       "commands": [
         "fable"
       ]

src/FSharpPlus/Control/Applicative.fs

@@ -22,9 +22,7 @@ type Apply =
     static member        ``<*>`` (f: Lazy<'T->'U>     , x: Lazy<'T>             , [<Optional>]_output: Lazy<'U>             , [<Optional>]_mthd: Apply) = Lazy.apply f x                               : Lazy<'U>
     static member        ``<*>`` (f: seq<_>           , x: seq<'T>              , [<Optional>]_output: seq<'U>              , [<Optional>]_mthd: Apply) = Seq.apply  f x                               : seq<'U>
     static member        ``<*>`` (f: NonEmptySeq<_>   , x: NonEmptySeq<'T>      , [<Optional>]_output: NonEmptySeq<'U>      , [<Optional>]_mthd: Apply) = NonEmptySeq.apply  f x                       : NonEmptySeq<'U>
-    #if !FABLE_COMPILER
     static member        ``<*>`` (f: IEnumerator<_>   , x: IEnumerator<'T>      , [<Optional>]_output: IEnumerator<'U>      , [<Optional>]_mthd: Apply) = Enumerator.map2 id f x : IEnumerator<'U>
-    #endif
     static member        ``<*>`` (f: list<_>          , x: list<'T>             , [<Optional>]_output: list<'U>             , [<Optional>]_mthd: Apply) = List.apply f x                               : list<'U>
     static member        ``<*>`` (f: _ []             , x: 'T []                , [<Optional>]_output: 'U []                , [<Optional>]_mthd: Apply) = Array.apply f x                              : 'U []
     static member        ``<*>`` (f: 'r -> _          , g: _ -> 'T              , [<Optional>]_output:  'r -> 'U            , [<Optional>]_mthd: Apply) = fun x -> let f' = f x in f' (g x)            : 'U
@@ -75,9 +73,7 @@ type Lift2 =
     static member        Lift2 (f, (x: Lazy<_>            , y: Lazy<_>            ), _mthd: Lift2) = Lazy.map2 f x y
     static member        Lift2 (f, (x: seq<_>             , y: seq<_>             ), _mthd: Lift2) = Seq.lift2 f x y
     static member        Lift2 (f, (x: NonEmptySeq<_>     , y: NonEmptySeq<_>     ), _mthd: Lift2) = NonEmptySeq.lift2 f x y
-    #if !FABLE_COMPILER
     static member        Lift2 (f, (x: IEnumerator<_>     , y: IEnumerator<_>     ), _mthd: Lift2) = Enumerator.map2 f x y
-    #endif
     static member        Lift2 (f, (x                     , y                     ), _mthd: Lift2) = List.lift2 f x y
     static member        Lift2 (f, (x                     , y                     ), _mthd: Lift2) = Array.lift2 f x y
     static member        Lift2 (f, (x: 'R -> 'T           , y: 'R -> 'U           ), _mthd: Lift2) = fun a -> f (x a) (y a)
@@ -116,9 +112,7 @@ type Lift3 =
     static member        Lift3 (f, (x: Lazy<_>            , y: Lazy<_>            , z: Lazy<_>             ), _mthd: Lift3) = Lazy.map3 f x y z
     static member        Lift3 (f, (x: seq<_>             , y: seq<_>             , z: seq<_>              ), _mthd: Lift3) = Seq.lift3 f x y z
     static member        Lift3 (f, (x: NonEmptySeq<_>     , y: NonEmptySeq<_>     , z: NonEmptySeq<_>      ), _mthd: Lift3) = NonEmptySeq.lift3 f x y z
-    #if !FABLE_COMPILER
     static member        Lift3 (f, (x: IEnumerator<_>     , y: IEnumerator<_>     , z: IEnumerator<_>      ), _mthd: Lift3) = Enumerator.map3 f x y z
-    #endif
     static member        Lift3 (f, (x                     , y                     , z                      ), _mthd: Lift3) = List.lift3 f x y z
     static member        Lift3 (f, (x                     , y                     , z                      ), _mthd: Lift3) = Array.lift3 f x y z
     static member        Lift3 (f, (x: 'R -> 'T           , y: 'R -> 'U           , z: 'R -> 'V            ), _mthd: Lift3) = fun a -> f (x a) (y a) (z a)

src/FSharpPlus/Control/Functor.fs

@@ -119,9 +119,7 @@ type Map with
 
     static member        Map ((x: seq<_>                  , f: 'T->'U), _mthd: Default2) = Seq.map f x              : seq<'U>
     static member        Map ((x: NonEmptySeq<_>          , f: 'T->'U), _mthd: Default2) = NonEmptySeq.map f x      : NonEmptySeq<'U>
-    #if !FABLE_COMPILER
     static member        Map ((x: IEnumerator<_>          , f: 'T->'U), _mthd: Default2) = Enumerator.map f x       : IEnumerator<'U>
-    #endif
     static member        Map ((x: IDictionary<_,_>        , f: 'T->'U), _mthd: Default2) = Dict.map f x             : IDictionary<'Key,'U>
     static member        Map ((x: IReadOnlyDictionary<_,_>, f: 'T->'U), _mthd: Default2) = IReadOnlyDictionary.map f x : IReadOnlyDictionary<'Key,_>
     static member        Map ((x: IObservable<'T>         , f: 'T->'U), _mthd: Default2) = Observable.map f x       : IObservable<'U>
@@ -175,9 +173,7 @@ type Unzip =
     static member        Unzip ((source: seq<'T * 'U>                      , _output: seq<'T> * seq<'U>                                    ) , _mthd: Unzip   ) = Map.Invoke fst source, Map.Invoke snd source
     static member        Unzip ((source: NonEmptySeq<'T * 'U>                      , _output: NonEmptySeq<'T> * NonEmptySeq<'U>            ) , _mthd: Unzip   ) = Map.Invoke fst source, Map.Invoke snd source
 
-    #if !FABLE_COMPILER
     static member        Unzip ((source: IEnumerator<'T * 'U>              , _output: IEnumerator<'T> * ResizeArray<'U>                    ) , _mthd: Unzip   ) = Map.Invoke fst source, Map.Invoke snd source
-    #endif    
     static member        Unzip ((source: IDictionary<'Key, 'T * 'U>        , _output: IDictionary<_,'T> * IDictionary<_,'U>                ) , _mthd: Unzip   ) = Dict.unzip source
     static member        Unzip ((source: IReadOnlyDictionary<'Key,'T * 'U> , _output: IReadOnlyDictionary<_,'T> * IReadOnlyDictionary<_,'U>) , _mthd: Unzip   ) = IReadOnlyDictionary.unzip source
     static member        Unzip ((source: IObservable<'T * 'U>              , _output: IObservable<'T> * ResizeArray<'U>                    ) , _mthd: Unzip   ) = Map.Invoke fst source, Map.Invoke snd source
@@ -194,9 +190,7 @@ type Unzip =
 
 type Zip =
     inherit Default1
-    #if !FABLE_COMPILER
     static member Zip ((x: IEnumerator<'T>            , y: IEnumerator<'U>           , _output: IEnumerator<'T*'U>           ), _mthd: Zip) = Enumerator.zip          x y
-    #endif
     static member Zip ((x: seq<'T>                    , y: seq<'U>                   , _output: seq<'T*'U>                   ), _mthd: Zip) = Seq.zip                 x y
     static member Zip ((x: NonEmptySeq<'T>            , y: NonEmptySeq<'U>           , _output: NonEmptySeq<'T*'U>           ), _mthd: Zip) = NonEmptySeq.zip         x y
     static member Zip ((x: IDictionary<'K, 'T>        , y: IDictionary<'K,'U>        , _output: IDictionary<'K,'T*'U>        ), _mthd: Zip) = Dict.zip                x y

src/FSharpPlus/Control/Monad.fs

@@ -122,9 +122,7 @@ type Return =
 
     static member        Return (_: seq<'a>        , _: Default2) = fun  x      -> Seq.singleton x : seq<'a>
     static member        Return (_: NonEmptySeq<'a>, _: Default2) = fun  x      -> NonEmptySeq.singleton x : NonEmptySeq<'a>
-    #if !FABLE_COMPILER
     static member        Return (_: IEnumerator<'a>, _: Default2) = fun  x      -> Enumerator.upto None (fun _ -> x) : IEnumerator<'a>
-    #endif
     static member inline Return (_: 'R             , _: Default1) = fun (x: 'T) -> Return.InvokeOnInstance x         : 'R
     static member        Return (_: Lazy<'a>       , _: Return  ) = fun x -> Lazy<_>.CreateFromValue x : Lazy<'a>
     #if !FABLE_COMPILER

src/FSharpPlus/Control/Numeric.fs

@@ -132,9 +132,7 @@ open FSharpPlus.Internals.Prelude
 type Zero =
     inherit Default1
 
-    #if !FABLE_COMPILER
     static member        Zero (_: System.TimeSpan                , _: Zero    ) = System.TimeSpan ()
-    #endif
     static member        Zero (_: DmStruct                       , _: Zero    ) = Unchecked.defaultof<DmStruct>
     static member        Zero (_: list<'a>                       , _: Zero    ) = []   :   list<'a>
     static member        Zero (_: option<'a>                     , _: Zero    ) = None : option<'a>
@@ -146,11 +144,12 @@ type Zero =
     static member        Zero (_: Set<'a>                        , _: Zero    ) = Set.empty : Set<'a>
     static member        Zero (_: Map<'a,'b>                     , _: Zero    ) = Map.empty : Map<'a,'b>
 
-    static member inline Invoke () = 
+    static member inline Invoke () =
         let inline call_2 (a: ^a, b: ^b) = ((^a or ^b) : (static member Zero : _*_ -> _) b, a)
         let inline call (a: 'a) = call_2 (a, Unchecked.defaultof<'r>) : 'r
         call Unchecked.defaultof<Zero>
 
+#if !FABLE_COMPILER
 type Zero with
     static member inline Zero (t: 't, _:Zero) : 't =
         let _f _ = Constraints.whenNestedTuple t : ('t1*'t2*'t3*'t4*'t5*'t6*'t7*'tr)
@@ -163,6 +162,7 @@ type Zero with
         let (t2: 't2) = Zero.Invoke ()
         let (t1: 't1) = Zero.Invoke ()
         Tuple<_,_,_,_,_,_,_,_> (t1, t2, t3, t4, t5, t6, t7, tr) |> retype : 't
+#endif
 
 type Zero with
     static member inline Zero (_: Tuple<'a>, _: Zero) = Tuple<_> (Zero.Invoke ()) : Tuple<'a>
@@ -185,7 +185,9 @@ type Zero with
     #endif
     static member inline Zero (_: 'T->'Monoid               , _: Zero) = (fun _ -> Zero.Invoke ()) : 'T->'Monoid
     static member inline Zero (_: Async<'a>                 , _: Zero) = let (v: 'a) = Zero.Invoke () in async.Return v
+    #if !FABLE_COMPILER
     static member inline Zero (_: Expr<'a>                  , _: Zero) = let (v: 'a) = Zero.Invoke () in Expr.Cast<'a>(Expr.Value (v))
+    #endif
     static member inline Zero (_: Lazy<'a>                  , _: Zero) = let (v: 'a) = Zero.Invoke () in lazy v
     static member        Zero (_: Dictionary<'a,'b>         , _: Zero) = Dictionary<'a,'b> ()
     static member        Zero (_: ResizeArray<'a>           , _: Zero) = ResizeArray () : ResizeArray<'a>
@@ -196,13 +198,9 @@ type Zero with
     static member inline Zero (_: ^R                             , _: Default5) = Implicit.Invoke 0   : ^R
 
     static member        Zero (_: seq<'a>                        , _: Default4) = Seq.empty      : seq<'a>
-    #if !FABLE_COMPILER
     static member        Zero (_: IEnumerator<'a>                , _: Default4) = FSharpPlus.Enumerator.Empty () : IEnumerator<'a>
-    #endif
     static member        Zero (_: IDictionary<'a,'b>             , _: Default4) = Dictionary<'a,'b> () :> IDictionary<'a,'b>
-    #if !FABLE_COMPILER
     static member        Zero (_: IReadOnlyDictionary<'a,'b>     , _: Default4) = Dictionary<'a,'b> () :> IReadOnlyDictionary<'a,'b>
-    #endif
     static member inline Zero (_: 't                             , _: Default3) = (^t : (static member Empty: ^t) ()) : 't
 
     static member inline Zero (_: 't                             , _: Default2) = FromInt32.InvokeOnInstance 0        : 't

src/FSharpPlus/Extensions/Enumerator.fs

@@ -1,6 +1,6 @@
 namespace FSharpPlus
 
-#if !FABLE_COMPILER
+#if !FABLE_COMPILER || FABLE_COMPILER_3
 
 /// Additional operations on IEnumerator
 [<RequireQualifiedAccess>]

src/FSharpPlus/Lens.fs

@@ -47,17 +47,18 @@ module Lens =
     /// <param name="optic">The prism.</param>
     /// <param name="source">The object.</param>
     /// <returns>The value (if any) the prism is targeting.</returns>
-    let preview (optic: ('a -> Const<_,'b>) -> _ -> Const<_,'t>) (source: 's) : 'a option = source |> optic (fun x -> Const (FSharpPlus.Data.First (Some x))) |> Const.run |> First.run
+    let preview (optic: ('a -> Const<_,'b>) -> _ -> Const<_,'t>) (source: 's) : 'a option = source |> optic (fun x -> Const (First (Some x))) |> Const.run |> First.run
 
     /// <summary>Build a 'Lens' from a getter and a setter.</summary>
     /// <remarks>The lens should be assigned as an inline function of the free parameter, not a value, otherwise compiler will fail with a type constraint mismatch.</remarks>
     /// <param name="getter">The getter function.</param>
     /// <param name="setter">The setter function, having as first parameter the object and second the value to set.</param>
     /// <param name="f">The free parameter.</param>
+    /// <param name="s"></param>
     /// <returns>The lens.</returns>
     let inline lens (getter: 's -> 'a) (setter: 's -> 'b -> 't) (f: 'a -> '``F<'b>``) = fun s -> setter s </Map.InvokeOnInstance/> f (getter s) : '``F<'t>``
 
-    #if !FABLE_COMPILER
+#if !FABLE_COMPILER // there are issues on Fable with Return.InvokeOnInstance
     /// <summary>Build a 'Prism' from a constructor and a getter.</summary>
     /// <remarks>The prism should be assigned as an inline function of the free parameter, not a value, otherwise compiler will fail with a type constraint mismatch.</remarks>
     /// <remarks>Using Result instead of Option to permit the types of 's and 't to differ.</remarks>
@@ -75,7 +76,7 @@ module Lens =
     /// <param name="f">The free parameter.</param>
     /// <returns>The prism.</returns>
     let inline prism' (constructor: 'b -> 's) (getter: 's -> Option<'a>) (f: 'a -> '``F<'b>``) = prism constructor (fun s -> option Ok (Error s) (getter s)) f : 's -> '``F<'t>``
-    #endif
+#endif
 
     /// <summary>Build an 'Iso' from a pair of inverse functions.</summary>
     /// <param name="func">The transform function.</param>
@@ -155,8 +156,8 @@ module Lens =
     /// Lens for the value inside an Option or the given default value if the Option is None.  Works well when combined with Map._item
     let inline non def f ma = Map.InvokeOnInstance (fun a' -> if a' = def then None else Some(a')) (f (Option.defaultValue def ma))
 
-    #if !FABLE_COMPILER
     // Prism
+#if !FABLE_COMPILER // there are issues on Fable with Return.InvokeOnInstance for prism 'Const First'
 
     /// Prism providing a Traversal for targeting the 'Ok' part of a Result<'T,'Error>
     let inline _Ok    x = (prism Ok    <| either Ok (Error << Error)) x
@@ -169,7 +170,7 @@ module Lens =
 
     /// Prism providing a Traversal for targeting the 'None' part of an Option<'T>
     let inline _None x = (prism' (konst None) <| option (konst None) (Some ())) x
-    #endif
+#endif
 
     // Traversal
     let inline _all ref f s =
@@ -239,13 +240,11 @@ module Lens =
     /// <returns>The new object with the value modified.</returns>
     let (%->) lens updater = over lens updater : 's -> 't
 
-    #if !FABLE_COMPILER
     /// <summary>Retrieve the first value targeted by a Prism, Fold or Traversal (or Some result from a Getter or Lens). Same as ``preview`` but with the arguments flipped.</summary>
     /// <param name="prism">The prism.</param>
     /// <param name="source">The object.</param>
     /// <returns>The value (if any) the prism is targeting.</returns>
     let (^?) (source: 's) (prism: ('a -> Const<_,'b>) -> _ -> Const<_,'t>) = preview prism source
-    #endif
 
     /// Extract a list of the targets of a Fold. Same as ``toListOf`` but with the arguments flipped.
     let (^..) s l = toListOf l s

tests/FSharpPlusFable.Tests/FSharpPlusFable.Tests.fsproj

@@ -23,16 +23,17 @@
     <Compile Include="FSharpTests/General/Indexable.fs" />
     <Compile Include="FSharpTests/General/Parsing.fs" />
     <Compile Include="FSharpTests/General/Traversable.fs" />
-    <Compile Include="FSharpTests\General\Lensing.fs" />
+    <Compile Include="FSharpTests/General/Lensing.fs" />
+    <Compile Include="FSharpTests/General/Numeric.fs" />
     <Compile Include="FSharpTests/General.fs" />
     <Compile Include="FSharpTests/Extensions.fs" />
     <Compile Include="Tests.fs" />
   </ItemGroup>
 
 
   <ItemGroup>
-    <PackageReference Include="Fable.Core" Version="3.1.6" />
-    <PackageReference Include="Fable.Promise" Version="2.1.0" />
+    <PackageReference Include="Fable.Core" Version="3.2.5" />
+    <PackageReference Include="Fable.Promise" Version="2.2.0" />
     <PackageReference Include="Fable.Fetch" Version="2.2.0" />
     <PackageReference Include="Fuchu" Version="1.2.0-beta-1" />
  </ItemGroup>
@@ -41,6 +42,6 @@
     <ProjectReference Include="..\..\src\FSharpPlus\FSharpPlus.fsproj">
       <Private>True</Private>
     </ProjectReference>
-    <PackageReference Update="FSharp.Core" Version="4.6.2" />
+    <PackageReference Update="FSharp.Core" Version="5.0.1" />
   </ItemGroup>
 </Project>

tests/FSharpPlusFable.Tests/FSharpTests/Extensions.fs

@@ -79,7 +79,7 @@ let ExtensionsTest =
       #if FABLE_COMPILER && !FABLE_COMPILER_FAKE
       testCase "eq on DList 5" (fun () -> equal true  ((dlistA :> obj) = (dlistD :> obj))) // this behavior differs from (non-fable) F# but same way it would be with normal lists.
       #endif
-      #if !FABLE_COMPILER || FABLE_COMPILER_3
+      #if !FABLE_COMPILER
       testCase "semigroups 1"
         (fun () ->
             let lzy1 = plus (lazy [1]) (lazy [2;3])

tests/FSharpPlusFable.Tests/FSharpTests/General.fs

@@ -66,7 +66,7 @@ let idiomBrackets = testList "IdiomBrackets" [
         Assert.AreEqual ("outerinner", string output)
         Assert.AreEqual (4, v4))
     #endif
-]
+    ]
 
 type RErrors = | NegativeValue
 
@@ -156,7 +156,7 @@ let monadTransformers = testList "MonadTransformers" [
         equal (Error NegativeValue) y)
     #endif
     #endif
-]
+    ]
 
 #if !FABLE_COMPILER || FABLE_COMPILER_3
 module ProfunctorDefaults =
@@ -203,7 +203,7 @@ let invariant = testList "Invariant" [
         Assert.AreEqual (Result<int, string>.Ok 1, oneParsed)
         Assert.AreEqual ("10", tenEncoded))
 #endif
-]
+    ]
 
 type Sum<'a> = Sum of 'a with
     static member inline get_Zero () = Sum 0
@@ -252,7 +252,7 @@ let splits = testList "Splits" [
         // Assert.IsTrue((c = Sum 13))
         Assert.IsTrue((d = Sum 13)))
 #endif
-]
+    ]
 
 let bitConverter = testList "BitConverter" [
 #if !FABLE_COMPILER
@@ -277,7 +277,7 @@ let bitConverter = testList "BitConverter" [
         Assert.IsTrue ((h0 = (h0 |> toBytes |> ofBytes)))
         Assert.IsTrue ((i0 = (i0 |> toBytes |> ofBytes))))
 #endif
-]
+    ]
 
 
 let curry = testList "Curry" [
@@ -330,7 +330,7 @@ let curry = testList "Curry" [
 
         ())
 #endif
-]
+    ]
 
 
 let memoization = testList "Memoization" [
@@ -379,7 +379,7 @@ let memoization = testList "Memoization" [
         let _ = mf null null  // should not throw
         ())
 #endif
-]
+    ]
 
 open General.Alternative
 open General.Applicative
@@ -392,6 +392,7 @@ open General.Monoid
 open General.Parsing
 open General.Traversable
 open General.Lensing
+open General.Numeric
 
 let generalTests = testList "General" [
     idiomBrackets
@@ -411,4 +412,5 @@ let generalTests = testList "General" [
     parsing
     traversable
     lensing
+    numeric
 ]