`(>>=)` should be constrained with `Map`

Hello,Monad should be restricted with Map

Here

type Maybe<'a> =
   | Just of 'a
   | Nothing 

let maybeMap f m = match m with
  | Just x -> Just (f x)
  | Nothing -> Nothing

//type Maybe<'a> with
//  static member Map (x: Maybe<'a>, f: 'a -> 'b) = maybeMap f x

//let r2' = map (fun x -> x + 1.0) (Just 10.0)

let maybeBind f m = match m with
  | Just x -> f x
  | Nothing -> Nothing

type Maybe<'a> with
  static member (>>=) (x: Maybe<'a>, f: 'a -> Maybe<'b>) = maybeBind f x

let r2'' = Just 10 >>= fun x -> Just (x + 10)

Should throw error that, Maybe doesn’t have property Map, because Monad should be restricted with Map But probably should be Functor <= Applicative <= Monad

[xgrommx]

@cannorin I know haskell, purescript, etc

[cannorin]

Then you would need to accept that:

• F# is not a language that comes with a first-class support of type classes.
• FSharpPlus is not a language extension, and only provides an “emulated” version of type classes.
• Therefore, the user experience on FSharpPlus’s type classes may not be as good as that of Haskell of PureScript.

I’m closing this issue because I don’t think this leads to a constructive discussion. I repeat my last message: if having type classes as a first-class language feature (i.e. more strict instance checks, more natural error messages, etc) is your priority, I guess you should better use some other languages.