Skip to content

Building and testing with RFCs FS-1043 FS-1071 #261

Open

Description

@dsyme

I'm opening this issue to cover steps to build and test this library with the implementations of RFCs FS-1043 FS-1071 activated

dotnet/fsharp#6805

dotnet/fsharp#6810

We can also look at adjusting the library to make use ot the features

Activity

  1. dsyme commented on Jan 30, 2020

    @dsyme
    ContributorAuthor

    I'm currently testing by setting these

      <PropertyGroup>
        <FscToolPath>c:\GitHub\dsyme\fsharp2\artifacts\bin\fsc\Debug\net472</FscToolPath>
        <FscToolExe>fsc.exe</FscToolExe>
      </PropertyGroup>
    

    I will also test with

      <PropertyGroup>
        <OtherFlags>--langversion:preview</OtherFlags>
      </PropertyGroup>
    
  2. dsyme commented on Jan 30, 2020

    @dsyme
    ContributorAuthor

    Separately, I notice compilation is quite slow, I presume this is related to SRTP constraint processing (I'm also using the debug compiler). It would be wise to do a fulll compiler profiling run both before and after

  3. smoothdeveloper commented on Jan 30, 2020

    @smoothdeveloper
    Contributor

    @dsyme, just FYI, in current compiler, there is an unreported compiler bug that makes buiding the F#+ test project in DEBUG not possible, you need to build that test project in RELEASE.

  4. dsyme commented on Jan 30, 2020

    @dsyme
    ContributorAuthor

    @dsyme, just FYI, in current compiler, there is an unreported compiler bug that makes buiding the F#+ test project in DEBUG not possible, you need to build that test project in RELEASE.

    OK, I'm just using .\build

    Could we get that bug reported? Even if it'snot fixed that's the sort of corner case problem I'd really like to get pinned down with testing before we proceed with the RFCs

  5. dsyme commented on Jan 30, 2020

    @dsyme
    ContributorAuthor

    OK turning on /langversion:preview with RFC 6805 does indeed cause a compilation error. I'll look at it now

    
         2>C:\GitHub\dsyme\FSharpPlus\src\FSharpPlus\Data\Seq.fs(11,87): error FS0043: A unique overload for m
           ethod 'Sequence' could not be determined based on type information prior to this program point. A t
           ype annotation may be needed. Candidates: static member Async.Sequence : t:seq<Async<'a>> -> Async<
           seq<'a>>, static member Option.Sequence : t:seq<'T option> -> seq<'T> option [C:\GitHub\dsyme\FShar
           pPlus\src\FSharpPlus\FSharpPlus.fsproj]
    
         2>C:\GitHub\dsyme\FSharpPlus\src\FSharpPlus\Data\Seq.fs(15,67): error FS0043: A unique overload for m
           ethod 'Sequence' could not be determined based on type information prior to this program point. A t
           ype annotation may be needed. Candidates: static member Async.Sequence : t:seq<Async<'a>> -> Async<
           seq<'a>>, static member Option.Sequence : t:seq<'T option> -> seq<'T> option [C:\GitHub\dsyme\FShar
           pPlus\src\FSharpPlus\FSharpPlus.fsproj]
         2>CoreCompile:
    
         2>C:\GitHub\dsyme\FSharpPlus\src\FSharpPlus\Data\Seq.fs(11,87): error FS0043: A unique overload for m
           ethod 'Sequence' could not be determined based on type information prior to this program point. A t
           ype annotation may be needed. Candidates: static member Async.Sequence : t:seq<Async<'a>> -> Async<
           seq<'a>>, static member Option.Sequence : t:seq<'T option> -> seq<'T> option [C:\GitHub\dsyme\FShar
           pPlus\src\FSharpPlus\FSharpPlus.fsproj]
    
         2>C:\GitHub\dsyme\FSharpPlus\src\FSharpPlus\Data\Seq.fs(15,67): error FS0043: A unique overload for m
           ethod 'Sequence' could not be determined based on type information prior to this program point. A t
           ype annotation may be needed. Candidates: static member Async.Sequence : t:seq<Async<'a>> -> Async<
           seq<'a>>, static member Option.Sequence : t:seq<'T option> -> seq<'T> option [C:\GitHub\dsyme\FShar
           pPlus\src\FSharpPlus\FSharpPlus.fsproj]
    
  6. gusty commented on Jan 30, 2020

    @gusty
    Member

    It's actually a very long longstanding bug, I never managed to find the time to get mini-repro.
    That's why I never reported it in the FSharp compiler.

  7. gusty commented on Jan 30, 2020

    @gusty
    Member

    That error you're getting regarding Aync.Sequence might be because now that extension is built-in with a slightly different signature.

    So it's not related to your work.

  8. dsyme commented on Jan 30, 2020

    @dsyme
    ContributorAuthor

    So it's not related to your work.

    I tried changing the spelling of Sequence to Seqquence throughout FSHarpPlus and I still get this new error. And it only happens with /langversion:preview. So it's a real change in behaviour.

    Note there is definitely a difference in logic that could somehow explain this because the extension members like Option.Seqquence and Async.Seqquence are being taken into account where they wouldn't have been before. Interesting.

  9. dsyme commented on Feb 6, 2020

    @dsyme
    ContributorAuthor

    I managed to fix the bug found above, and FSHarpPlus now compiles with the preview of FS-1043

    However

    1. the tests failto compile
    2. the compilation seems slower (there's a possible reason for that, and I'm using the Debug compiler, but still it seems much slower)

    I will look at these tomorrow

    The test compilation failure is this:

      C:\GitHub\dsyme\FSharpPlus\src\FSharpPlus\Samples\Learn You a Haskell.fsx(36,13): error FS0073: internal error: Undefined or unsolved type variable:  ^_?319442�Stack Trace�FSharp.Compiler.ErrorLogger+InternalError: Undefined or unsolved type variable:  ^_?319442C:\GitHub\dsyme\FSharpPlus\src\FSharpPlus\Samples\Learn You a Haskell.fsx (36,12--36,50) IsSynthetic=false [C:\GitHub\dsyme\FSharpPlus\src\FSharpPlus.Samples\FSharpPlus.Samples.fsproj]
    
  10. gusty commented on Feb 6, 2020

    @gusty
    Member

    Just to clarify, that's not really from the tests. It comes from the samples folder which has a project.
    Though those samples don't have any test at all, we did a project to make sure they keep compiling.
    Thanks for looking at this.

  11. dsyme commented on Feb 7, 2020

    @dsyme
    ContributorAuthor
    1. I checked this with the release compiler and compilation is no slower without --langversion:preview activated

    2. We now get a new error for --langversion:preview. I must say that the contents of the error message make it look like a complete nightmare :)

    
    warning FS0075: The command-line option 'times' is for test purposes only
    
    C:\GitHub\dsyme\FSharpPlus\src\FSharpPlus\Data\Cont.fs(39,59): warning FS1125: The instantiation of the generic type 'Cont' is missing and can't be inferred from the arguments or return type of this member. Consider providing a type instantiation when accessing this type, e.g. 'Cont<_,_>'.
    
    C:\GitHub\dsyme\FSharpPlus\src\FSharpPlus\Data\ZipList.fs(42,65): error FS0043: No overloads match for method 'Map'. The available overloads are shown below.
    Possible overload: 'static member Map.Map : ( ^Profunctor<'B,'C> * ('C -> 'D)) * _mthd:Internals.Default5 -> 'Profunctor<'B,'D> when  ^Profunctor<'B,'C> : (static member Dimap :  ^Profunctor<'B,'C> * ('a1 -> 'a1) * ('C -> 'D) -> 'Profunctor<'B,'D>)'. Type constraint mismatch. The type �    'ZipList<'a> * ('g -> 'g -> 'g)'    �is not compatible with type�    ''b * ('d -> 'e)'    �.
    Possible overload: 'static member Map.Map : ( ^Bifunctor<'T,'V> * ('V -> 'W)) * _mthd:Internals.Default6 -> 'a4 when  ^Bifunctor<'T,'V> : (static member Bimap :  ^Bifunctor<'T,'V> * ('a1 -> 'a1) * ('V -> 'W) -> 'a4)'. Type constraint mismatch. The type �    'ZipList<'a> * ('g -> 'g -> 'g)'    �is not compatible with type�    ''b * ('d -> 'e)'    �.
    Possible overload: 'static member Map.Map : ( ^t * 'a1) * _mthd:Internals.Default1 -> unit when  ^t : null and  ^t : struct'. Type constraint mismatch. The type �    'ZipList<'a> * ('d -> 'd -> 'd)'    �is not compatible with type�    ''b * 'c'    �.
    Possible overload: 'static member Map.Map : ( ^Functor<'T> * ('T -> 'U)) * _mthd:Internals.Default1 -> 'Functor<'U> when  ^Functor<'T> : (static member Map :  ^Functor<'T> * ('T -> 'U) -> 'Functor<'U>)'. Type constraint mismatch. The type �    'ZipList<'a> * ('f -> 'f -> 'f)'    �is not compatible with type�    ''b * ('c -> 'd)'    �.
    Possible overload: 'static member Map.Map : (System.IObservable<'T> * ('T -> 'U)) * _mthd:Internals.Default2 -> System.IObservable<'U>'. Type constraint mismatch. The type �    'ZipList<'a> * ('d -> 'd -> 'd)'    �is not compatible with type�    'System.IObservable<'b> * ('b -> 'c)'    �.
    Possible overload: 'static member Map.Map : (System.Collections.Generic.IReadOnlyDictionary<'Key,'T> * ('T -> 'U)) * _mthd:Internals.Default2 -> System.Collections.Generic.IReadOnlyDictionary<'Key,'U> when 'Key : equality'. Type constraint mismatch. The type �    'ZipList<'a> * ('e -> 'e -> 'e)'    �is not compatible with type�    'System.Collections.Generic.IReadOnlyDictionary<'b,'c> * ('c -> 'd)'    �.
    Possible overload: 'static member Map.Map : (System.Collections.Generic.IDictionary<'Key,'T> * ('T -> 'U)) * _mthd:Internals.Default2 -> System.Collections.Generic.IDictionary<'Key,'U> when 'Key : equality'. Type constraint mismatch. The type �    'ZipList<'a> * ('e -> 'e -> 'e)'    �is not compatible with type�    'System.Collections.Generic.IDictionary<'b,'c> * ('c -> 'd)'    �.
    Possible overload: 'static member Map.Map : (System.Collections.Generic.IEnumerator<'T> * ('T -> 'U)) * _mthd:Internals.Default2 -> System.Collections.Generic.IEnumerator<'U>'. Type constraint mismatch. The type �    'ZipList<'a> * ('d -> 'd -> 'd)'    �is not compatible with type�    'System.Collections.Generic.IEnumerator<'b> * ('b -> 'c)'    �.
    Possible overload: 'static member Map.Map : (seq<'T> * ('T -> 'U)) * _mthd:Internals.Default2 -> seq<'U>'. Type constraint mismatch. The type �    'ZipList<'a> * ('d -> 'd -> 'd)'    �is not compatible with type�    'seq<'b> * ('b -> 'c)'    �.
    Possible overload: 'static member Map.Map : ( ^Applicative<'T> * ('T -> 'U)) * _mthd:Internals.Default3 ->  ^Applicative<'U> when  ^Applicative<'T> : (static member ( <*> ) :  ^Applicative<'T->'U> *  ^Applicative<'T> ->  ^Applicative<'U>) and ( ^Applicative<'T->'U> or  ^Applicative<'T> or  ^Applicative<'U>) : (static member ( <*> ) :  ^Applicative<'T->'U> *  ^Applicative<'T> ->  ^Applicative<'U>) and  ^Applicative<'T->'U> : (static member Return : ('T -> 'U) ->  ^Applicative<'T->'U>)'. Type constraint mismatch. The type �    'ZipList<'a> * ('g -> 'g -> 'g)'    �is not compatible with type�    ''b * ('d -> 'e)'    �.
    Possible overload: 'static member Map.Map : ( ^Monad<'T> * ('T -> 'U)) * _mthd:Internals.Default4 ->  ^Monad<'U> when  ^Monad<'T> : (static member ( >>= ) :  ^Monad<'T> * ('T ->  ^Monad<'U>) ->  ^Monad<'U>) and ( ^Monad<'T> or  ^Monad<'U>) : (static member ( >>= ) :  ^Monad<'T> * ('T ->  ^Monad<'U>) ->  ^Monad<'U>) and  ^Monad<'U> : (static member Return : 'U ->  ^Monad<'U>)'. Type constraint mismatch. The type �    'ZipList<'a> * ('f -> 'f -> 'f)'    �is not compatible with type�    ''b * ('c -> 'e)'    �.
    Possible overload: 'static member Map.Map : (Set2<'T> * ('T -> 'U)) * _mthd:Map -> Set2<'U> when 'T : comparison and 'U : comparison'. Type constraint mismatch. The type �    'ZipList<'a> * ('d -> 'd -> 'd)'    �is not compatible with type�    'Set2<'b> * ('b -> 'c)'    �.
    Possible overload: 'static member Map.Map : (Set<'a0> * ('a0 -> 'a1)) * _mthd:Map -> Set<'a1> when 'a0 : comparison and 'a1 : comparison'. Type constraint mismatch. The type �    'ZipList<'a> * ('d -> 'd -> 'd)'    �is not compatible with type�    'Set<'b> * ('b -> 'c)'    �.
    Possible overload: 'static member Map.Map : (StringBuilder * (char -> char)) * _mthd:Map -> StringBuilder'. Type constraint mismatch. The type �    'ZipList<'a> * ('b -> 'b -> 'b)'    �is not compatible with type�    'StringBuilder * (char -> char)'    �.
    Possible overload: 'static member Map.Map : (string * (char -> char)) * _mthd:Map -> string'. Type constraint mismatch. The type �    'ZipList<'a> * ('b -> 'b -> 'b)'    �is not compatible with type�    'string * (char -> char)'    �.
    Possible overload: 'static member Map.Map : (ResizeArray<'T> * ('T -> 'U)) * _mthd:Map -> ResizeArray<'U>'. Type constraint mismatch. The type �    'ZipList<'a> * ('d -> 'd -> 'd)'    �is not compatible with type�    'ResizeArray<'b> * ('b -> 'c)'    �.
    Possible overload: 'static member Map.Map : (Quotations.Expr<'T> * ('T -> 'U)) * _mthd:Map -> Quotations.Expr<'U>'. Type constraint mismatch. The type �    'ZipList<'a> * ('d -> 'd -> 'd)'    �is not compatible with type�    'Quotations.Expr<'b> * ('b -> 'c)'    �.
    Possible overload: 'static member Map.Map : (System.Collections.Generic.Dictionary<'Key,'T> * ('T -> 'U)) * _mthd:Map -> System.Collections.Generic.Dictionary<'Key,'U> when 'Key : equality'. Type constraint mismatch. The type �    'ZipList<'a> * ('e -> 'e -> 'e)'    �is not compatible with type�    'System.Collections.Generic.Dictionary<'b,'c> * ('c -> 'd)'    �.
    Possible overload: 'static member Map.Map : (Map<'Key,'T> * ('T -> 'U)) * _mthd:Map -> Map<'Key,'U> when 'Key : comparison'. Type constraint mismatch. The type �    'ZipList<'a> * ('e -> 'e -> 'e)'    �is not compatible with type�    'Map<'b,'c> * ('c -> 'd)'    �.
    Possible overload: 'static member Map.Map : (System.Collections.Generic.KeyValuePair<'a0,'T> * ('T -> 'U)) * _mthd:Map -> System.Collections.Generic.KeyValuePair<'a0,'U>'. Type constraint mismatch. The type �    'ZipList<'a> * ('e -> 'e -> 'e)'    �is not compatible with type�    'System.Collections.Generic.KeyValuePair<'b,'c> * ('c -> 'd)'    �.
    Possible overload: 'static member Map.Map : (Choice<'T,'E> * ('T -> 'U)) * _mthd:Map -> Choice<'U,'E>'. Type constraint mismatch. The type �    'ZipList<'a> * ('e -> 'e -> 'e)'    �is not compatible with type�    'Choice<'b,'c> * ('b -> 'd)'    �.
    Possible overload: 'static member Map.Map : (Result<'T,'E> * ('T -> 'U)) * _mthd:Map -> Result<'U,'E>'. Type constraint mismatch. The type �    'ZipList<'a> * ('e -> 'e -> 'e)'    �is not compatible with type�    'Result<'b,'c> * ('b -> 'd)'    �.
    Possible overload: 'static member Map.Map : (Async<'T> * ('T -> 'U)) * _mthd:Map -> Async<'U>'. Type constraint mismatch. The type �    'ZipList<'a> * ('d -> 'd -> 'd)'    �is not compatible with type�    'Async<'b> * ('b -> 'c)'    �.
    Possible overload: 'static member Map.Map : ('T [,,,] * ('T -> 'U)) * _mthd:Map -> 'U [,,,]'. Type constraint mismatch. The type �    'ZipList<'a> * ('d -> 'd -> 'd)'    �is not compatible with type�    ''b [,,,] * ('b -> 'c)'    �.
    Possible overload: 'static member Map.Map : ('T [,,] * ('T -> 'U)) * _mthd:Map -> 'U [,,]'. Type constraint mismatch. The type �    'ZipList<'a> * ('d -> 'd -> 'd)'    �is not compatible with type�    ''b [,,] * ('b -> 'c)'    �.
    Possible overload: 'static member Map.Map : ('T [,] * ('T -> 'U)) * _mthd:Map -> 'U [,]'. Type constraint mismatch. The type �    'ZipList<'a> * ('d -> 'd -> 'd)'    �is not compatible with type�    ''b [,] * ('b -> 'c)'    �.
    Possible overload: 'static member Map.Map : ('T [] * ('T -> 'U)) * _mthd:Map -> 'U []'. Type constraint mismatch. The type �    'ZipList<'a> * ('d -> 'd -> 'd)'    �is not compatible with type�    ''b [] * ('b -> 'c)'    �.
    Possible overload: 'static member Map.Map : (('Monoid * 'T) * ('T -> 'U)) * _mthd:Map -> 'Monoid * 'U'. Type constraint mismatch. The type �    'ZipList<'a> * ('e -> 'e -> 'e)'    �is not compatible with type�    '('b * 'c) * ('c -> 'd)'    �.
    Possible overload: 'static member Map.Map : (System.Func<'R,'T> * ('T -> 'U)) * _mthd:Map -> System.Func<'R,'U>'. Type constraint mismatch. The type �    'ZipList<'a> * ('e -> 'e -> 'e)'    �is not compatible with type�    'System.Func<'b,'c> * ('c -> 'd)'    �.
    Possible overload: 'static member Map.Map : (('R -> 'T) * ('T -> 'U)) * _mthd:Map -> ('R -> 'U)'. Type constraint mismatch. The type �    'ZipList<'a> * ('e -> 'e -> 'e)'    �is not compatible with type�    '('b -> 'c) * ('c -> 'd)'    �.
    Possible overload: 'static member Map.Map : ('T list * ('T -> 'U)) * _mthd:Map -> 'U list'. Type constraint mismatch. The type �    'ZipList<'a> * ('d -> 'd -> 'd)'    �is not compatible with type�    ''b list * ('b -> 'c)'    �.
    Possible overload: 'static member Map.Map : ('T option * ('T -> 'U)) * _mthd:Map -> 'U option'. Type constraint mismatch. The type �    'ZipList<'a> * ('d -> 'd -> 'd)'    �is not compatible with type�    ''b option * ('b -> 'c)'    �.
    Possible overload: 'static member Map.Map : (System.Threading.Tasks.Task<'T> * ('T -> 'U)) * _mthd:Map -> System.Threading.Tasks.Task<'U>'. Type constraint mismatch. The type �    'ZipList<'a> * ('d -> 'd -> 'd)'    �is not compatible with type�    'System.Threading.Tasks.Task<'b> * ('b -> 'c)'    �.
    Possible overload: 'static member Map.Map : (System.Lazy<'T> * ('T -> 'U)) * _mthd:Map -> System.Lazy<'U>'. Type constraint mismatch. The type �    'ZipList<'a> * ('d -> 'd -> 'd)'    �is not compatible with type�    'System.Lazy<'b> * ('b -> 'c)'    �.
    Possible overload: 'static member ZipList.Map : ZipList<'a> * f:('a -> 'b) -> ZipList<'b>'. Type constraint mismatch. The type �    'ZipList<'a> * ('c -> 'c -> 'c)'    �is not compatible with type�    'ZipList<'b>'    �.
    
  12. gusty commented on Feb 7, 2020

    @gusty
    Member

    It seems to me that it's trying to match the first trait-call for Map.Invoke which has tupled arguments (to avoid subsumption) with that Map member defined on ZipList.

    the one that should resolve is this one:

    Possible overload: 'static member Map.Map : ( ^Functor<'T> * ('T -> 'U)) * _mthd:Internals.Default1 -> 'Functor<'U> when  ^Functor<'T> : (static member Map :  ^Functor<'T> * ('T -> 'U) -> 'Functor<'U>)'. Type constraint mismatch. The type 
        'ZipList<'a> * ('f -> 'f -> 'f)'    
    is not compatible with type
        ''b * ('c -> 'd)'    �.
    

    which contains another trait-call to the members defined on external classes, without tupling.
    Now, why 'ZipList<'a> * ('f -> 'f -> 'f)' doesn't match with ''b * ('c -> 'd)' have no clue.

    Maybe this is a good case to test with @smoothdeveloper improvement on these error reports.

  13. dsyme commented on Feb 7, 2020

    @dsyme
    ContributorAuthor

    Yes. It's a bit confusing that some Map instances take the extra arguments and some don't

  14. gusty commented on Feb 7, 2020

    @gusty
    Member

    It is.

    Basically, all the overloads on the "Witnesses" type use dummy / tupled parameters while the ones defines in custom types have a clean signature.

  15. dsyme commented on Mar 23, 2020

    @dsyme
    ContributorAuthor

    I've verified that the latest commit of RFC FS-1043 (dotnet/fsharp#6805) builds and compiles the latest master of FSharpPlus, with the exception of these two lines:

    type ParallelArray<'t> with
         static member inline (+) (x: parray<'m>, y: parray<'m>) = lift2 plus x y : parray<'m>
    
    type ZipList<'s> with
        static member inline (+) (x: ZipList<'a>, y: ZipList<'a>) = lift2 plus x y : ZipList<'a>

    My conclusion from previous threads on this was that this can be considered an appropriate adjustment to the specification and a code change would be needed here. It is the only place where we've found a code change may be needed

  16. gusty commented on Mar 23, 2020

    @gusty
    Member

    Could you possibly try it with #302 ?

  17. dsyme commented on Mar 24, 2020

    @dsyme
    ContributorAuthor

    Could you possibly try it with #302 ?

    It's ok, I'm sure we can work it out once the feature lands. The case is under test both positively and negateively now in the RFC implementation.

  18. dsyme commented on Mar 24, 2020

    @dsyme
    ContributorAuthor

    To test this I put fsharp and FSharpPlus in parallel directories, built fsharp and added this to Directory.Build.props in FSharpPlus

      <PropertyGroup>
         <DisableAutoSetFscCompilerPath>true</DisableAutoSetFscCompilerPath>
        <FscToolPath>c:\GitHub\dsyme\fsharp2\artifacts\bin\fsc\Release\net472</FscToolPath>
        <FscToolExe>fsc.exe</FscToolExe>
        <OtherFlags>/langversion:preview $(OtherFlags)</OtherFlags>
      </PropertyGroup>
    
  19. deleted a comment from dsyme on Mar 24, 2020
  20. gusty commented on Jun 18, 2020

    @gusty
    Member

    @dsyme

    Testing with your feature/ext branch of the compiler I see lot of failures in the test projects.

    Here's a relative small repro:

    type Default3 = class  end
    type Default2 = class inherit Default3 end
    type Default1 = class inherit Default2 end
    
    type Bind =
        static member (>>=) (source, f: 'T -> _) = Option.bind   f source
        static member (>>=) (source, f: 'T -> _) = List.collect  f source
    
        static member inline Invoke (source: '``Monad<'T>``) (binder: 'T -> '``Monad<'U>``) : '``Monad<'U>`` =
            let inline call (_mthd: 'M, input: 'I, _output: 'R, f) = ((^M or ^I or ^R) : (static member (>>=) : _*_ -> _) input, f)
            call (Unchecked.defaultof<Bind>, source, Unchecked.defaultof<'``Monad<'U>``>, binder)
    
    
    type Return =
    
        static member inline Invoke (x: 'T) : '``Applicative<'T>`` =
            let inline call (mthd: ^M, output: ^R) = ((^M or ^R) : (static member Return : _*_ -> _) output, mthd)
            call (Unchecked.defaultof<Return>, Unchecked.defaultof<'``Applicative<'T>``>) x
        
        static member Return (_: option<'a> , _: Return  ) = fun x -> Some x
        static member Return (_: list<'a>       , _: Return  ) = fun x -> [ x ]
    
    
    type Delay =
        inherit Default1
        
        static member inline Delay (_mthd: Default3, x: unit-> ^``Monad<'T>`` , _: obj) = Bind.Invoke (Return.Invoke ()) x : ^``Monad<'T>``
        static member        Delay (_mthd: Default2, x: unit-> _  , _     ) = Seq.delay x
        static member        Delay (_mthd: Delay   , x: unit-> _    , _     ) = async.Delay x
    
        static member inline Invoke (source: unit -> 'R) : 'R =
            let inline call (mthd: ^M, input: unit -> ^I) = ((^M or ^I) : (static member Delay : _*_*_ -> _) mthd, input, Unchecked.defaultof<Delay>)
            call (Unchecked.defaultof<Delay>, source)
    
    
    let lst2: _ list = Delay.Invoke (fun () -> Return.Invoke 6) // fails
    

    I updated to the latest commit of the feature/ext branch but still fails.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Type

    No type

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions