Hedgehog bind functions are backwards

[ghost]

Axiomatically, the bind function in F# has a different parameter order than the Bind method in a computation expression. This is well established, and Hedgehog does it wrong.

module Gen =
    val bind : Gen<'a> -> ('a -> Gen<'b>) -> Gen<'b>

module Property =
    val bind : Property<'a> -> ('a -> Property<'b>) -> Property<'b>

module Random =
    val bind : Random<'a> -> ('a -> Random<'b>) -> Random<'b>

module Tree =
    val bind : Tree<'a> -> ('a -> Tree<'b>) -> Tree<'b>

Other modules in F# are consistent on this.

module Option =
    val bind : ('a -> Option<'b>) -> Option<'a> -> Option<'b>

module Result =
    val bind : ('a -> Result<'b, 'error>) -> Result<'a, 'error> -> Result<'b, 'error>

module Seq =
    val collect : ('a -> seq<'b>) -> seq<'a> -> seq<'b>

module Array =
    val collect : ('a -> Array<'b>) -> Array<'a> -> Array<'b>

module List =
    val collect : ('a -> List<'b>) -> List<'a> -> List<'b>

It's done this way to allow simple chaining, which is how I noticed this.

[TysonMN]

I agree with @adam-becker.

The signature of the bind function named bind for a monad M<_> should be

let bind (f: 'a -> M<'b>) (ma: M<'a>) : M<'b> =

In contrast, the signature of the bind operator denoted by >>= (which doesn't exist in fsharp-hedgehog) should be

let (>>=) (ma: M<'a>) (f: 'a -> M<'b>) : M<'b> =

These are "the flip" of each other: i.e. flip bind = (>>=). Here is the reason for this. Consider

a >>= b

and

a |> bind b

The arguments to >>= are given in the order a then b. In contrast, the arguments to bind are given in the order b then a.

[moodmosaic]

Agreed, bind right now can add cognitive overhead to F# developers that aren't coming from Haskell. Good point. 👍

[TysonMN]

...the bind operator denoted by >>= (which doesn't exist in fsharp-hedgehog)...

Another idea (@adam-becker) is to add this operator.

[ghost]

@TysonMN I added the operator, though suggestions like this fit better on the PR :)