Attach operator >=> directly to monad types

Author: gusty

src/FSharpPlus/Data/Cont.fs

@@ -75,6 +75,12 @@ type Cont<'r,'t> with
     static member (<*  ) (x: Cont<'R, 'U>, y: Cont<'R, 'T>) : Cont<'R, 'U> = ((fun (k: 'U) (_: 'T) -> k ) </Cont.map/> x : Cont<'R, 'T->'U>) </Cont.apply/> y
 
     static member (>>=) (x, f: 'T->_)       = Cont.bind f x   : Cont<'R,'U>
+    
+    /// <summary>
+    /// Composes left-to-right two Cont functions (Kleisli composition).
+    /// </summary>
+    /// <category index="2">Monad</category>
+    static member (>=>) (f, (g: 'U -> _)) : 'T -> Cont<'R, 'V> = fun x -> Cont.bind g (f x)
 
     static member Delay f = Cont (fun k -> Cont.run (f ()) k) : Cont<'R,'T>
     static member TryWith    (Cont c, h) = Cont (fun k -> try (c k) with e -> Cont.run (h e) k) : Cont<'R,'T>

src/FSharpPlus/Data/Error.fs

@@ -71,6 +71,12 @@ type ResultT<'``monad<Result<'t,'e>>``> with
 
     static member inline (<*>) (f: ResultT<'``Monad<Result<('T -> 'U),'E>>``>, x: ResultT<'``Monad<Result<'T,'E>>``>) = ResultT.apply f x : ResultT<'``Monad<Result<'U,'E>>``>    
     static member inline (>>=) (x: ResultT<'``Monad<Result<'T,'E>>``>, f: 'T->ResultT<'``Monad<Result<'U,'E>>``>)     = ResultT.bind  f x
+    
+    /// <summary>
+    /// Composes left-to-right two Result functions (Kleisli composition).
+    /// </summary>
+    /// <category index="2">Monad</category>
+    static member inline (>=>) (f: 'T -> ResultT<'``Monad<Result<'U, 'E>``>, g: 'U -> ResultT<'``Monad<Result<'V, 'E>``>) : 'T -> ResultT<'``Monad<Result<'V, 'E>``> = fun x -> ResultT.bind g (f x)
 
     static member inline get_Zero () : ResultT<'``MonadPlus<Result<'U,'E>>``> = ResultT <| result (Error zero)
     static member inline (+) (ResultT x, ResultT y) : ResultT<'``MonadPlus<Result<'U,'E>>``> =
@@ -154,6 +160,12 @@ type ChoiceT<'``monad<Choice<'t,'e>>``> with
 
     static member inline (<*>) (f: ChoiceT<'``Monad<Choice<('T -> 'U),'E>>``>, x: ChoiceT<'``Monad<Choice<'T,'E>>``>) = ChoiceT.apply f x : ChoiceT<'``Monad<Choice<'U,'E>>``>
     static member inline (>>=) (x: ChoiceT<'``Monad<Choice<'T,'E>>``>, f: 'T->ChoiceT<'``Monad<Choice<'U,'E>>``>)     = ChoiceT.bind f x
+    
+    /// <summary>
+    /// Composes left-to-right two Choice functions (Kleisli composition).
+    /// </summary>
+    /// <category index="2">Monad</category>
+    static member inline (>=>) (f: 'T -> ChoiceT<'``Monad<Choice<'U, 'E>``>, g: 'U -> ChoiceT<'``Monad<Choice<'V, 'E>``>) : 'T -> ChoiceT<'``Monad<Choice<'V, 'E>``> = fun x -> ChoiceT.bind g (f x)
 
     static member inline get_Zero () : ChoiceT<'``MonadPlus<Choice<'U,'E>>``> = ChoiceT <| result (Choice2Of2 zero)
     static member inline (+) (ChoiceT x, ChoiceT y) : ChoiceT<'``MonadPlus<Choice<'U,'E>>``> =

src/FSharpPlus/Data/Identity.fs

@@ -10,16 +10,30 @@
 ///           Any monad transformer applied to the Identity monad yields a non-transformer version of that monad.
 ///           Its applicative instance plays a fundamental role in Lens. </summary> 
 [<Struct>]
-type Identity<'t> = Identity of 't with
+type Identity<'t> = Identity of 't
+
+/// Basic operations on Identity
+[<RequireQualifiedAccess>]
+module Identity = 
+    let run (Identity x) = x  : 'T
+    let apply (Identity (f : 'T -> 'U)) (Identity (x: 'T)) : Identity<'U> = Identity (f x)
+    let bind  (f: 'T -> Identity<'U>) (Identity x) : Identity<'U> = f x
+
+type Identity<'t> with
+    
     static member Return x = Identity x                                             : Identity<'T>
-    static member (>>=) (Identity x, f :'T -> Identity<'U>) = f x                   : Identity<'U>
-    static member (<*>) (Identity (f : 'T->'U), Identity (x : 'T)) = Identity (f x) : Identity<'U>
+    
     static member Lift2 (f, Identity (x: 'T), Identity (y: 'U)) = Identity (f x y)  : Identity<'V>
-    static member Lift3 (f, Identity (x: 'T), Identity (y: 'U), Identity (z: 'V)) = Identity (f x y z) : Identity<'W>
+    static member Lift3 (f, Identity (x: 'T), Identity (y: 'U), Identity (z: 'V))   : Identity<'W> = Identity (f x y z)
     static member Map   (Identity x, f : 'T->'U) = Identity (f x)                   : Identity<'U>
     static member Zip   (Identity x, Identity y) = Identity (x, y)                  : Identity<'T * 'U>
 
-/// Basic operations on Identity
-[<RequireQualifiedAccess>]
-module Identity = 
-    let run (Identity x) = x  : 'T
+    static member (<*>) (Identity (f: 'T -> 'U), Identity (x: 'T)) : Identity<'U> = Identity (f x)
+    
+    static member (>>=) (Identity x, f: 'T -> Identity<'U>) : Identity<'U> = f x
+
+    /// <summary>
+    /// Composes left-to-right two Id functions (Kleisli composition).
+    /// </summary>
+    /// <category index="2">Monad</category>
+    static member (>=>) (f, (g: 'U -> _)) : 'T -> Identity<'V> = fun x -> Identity.bind g (f x)

src/FSharpPlus/Data/Option.fs

@@ -52,6 +52,12 @@ type OptionT<'``monad<option<'t>>``> with
     static member inline (<*>) (f: OptionT<'``Monad<option<('T -> 'U)>``>, x: OptionT<'``Monad<option<'T>``>) = OptionT.apply f x : OptionT<'``Monad<option<'U>``>
     static member inline (>>=) (x: OptionT<'``Monad<option<'T>``>, f: 'T -> OptionT<'``Monad<option<'U>``>)   = OptionT.bind  f x
 
+    /// <summary>
+    /// Composes left-to-right two Option functions (Kleisli composition).
+    /// </summary>
+    /// <category index="2">Monad</category>
+    static member inline (>=>) (f: 'T -> OptionT<'``Monad<option<'U>``>, g: 'U -> OptionT<'``Monad<option<'V>``>) : 'T -> OptionT<'``Monad<option<'V>``> = fun x -> OptionT.bind g (f x)
+
     static member inline get_Zero () : OptionT<'``MonadPlus<option<'T>``> = OptionT <| result None
     static member inline (+) (OptionT x, OptionT y) : OptionT<'``MonadPlus<option<'T>``> =
         OptionT <| (x >>= function

src/FSharpPlus/Data/Reader.fs

@@ -161,6 +161,12 @@ type ReaderT<'r,'``monad<'t>``> with
     /// <category index="2">Monad</category>
     static member inline (>>=) (x: ReaderT<_,'``Monad<'T>``>, f: 'T->ReaderT<'R,'``Monad<'U>``>)  = ReaderT.bind  f x : ReaderT<'R, '``Monad<'U>``>
 
+    /// <summary>
+    /// Composes left-to-right two Reader functions (Kleisli composition).
+    /// </summary>
+    /// <category index="2">Monad</category>
+    static member (>=>) (f, (g: 'U -> _)) : 'T -> Reader<'R, 'V> = fun x -> Reader.bind g (f x)
+
     /// <summary>
     /// Composes left-to-right two Reader functions (Kleisli composition).
     /// </summary>

src/FSharpPlus/Data/State.fs

@@ -68,7 +68,14 @@ type State<'s,'t> with
 
     static member Return a = State (fun s -> (a, s))           : State<'S,'T>
     static member (>>=) (x, f: 'T->_) = State.bind f x         : State<'S,'U>
-    static member (<*>) (f, x: State<'S,'T>) = State.apply f x : State<'S,'U>
+
+    /// <summary>
+    /// Composes left-to-right two State functions (Kleisli composition).
+    /// </summary>
+    /// <category index="2">Monad</category>
+    static member (>=>) (f, (g: 'U -> _)) : 'T -> State<'S, 'V> = fun x -> State.bind g (f x)
+
+    static member (<*>) (f, x: State<'S,'T>) = State.apply f x : State<'S,'U>    
 
     /// <summary>
     /// Sequences two States left-to-right, discarding the value of the first argument.
@@ -172,6 +179,12 @@ type StateT<'s,'``monad<'t * 's>``> with
 
     static member inline (>>=)  (x: StateT<'S,'``Monad<'T * 'S>``>, f: 'T->StateT<'S,'``Monad<'U * 'S>``>) = StateT.bind  f x
 
+    /// <summary>
+    /// Composes left-to-right two State functions (Kleisli composition).
+    /// </summary>
+    /// <category index="2">Monad</category>
+    static member inline (>=>) (f: 'T -> StateT<'S, '``Monad<'U * 'S>``>, g: 'U -> StateT<'S, '``Monad<'V * 'S>``>) : 'T -> StateT<'S, '``Monad<'V * 'S>``> = fun x -> StateT.bind g (f x)
+
     static member inline get_Empty () = StateT (fun _ -> getEmpty ()) : StateT<'S,'``MonadPlus<'T * 'S>``>
     static member inline (<|>) (StateT m, StateT n) = StateT (fun s -> m s <|> n s) : StateT<'S,'``MonadPlus<'T * 'S>``>
 

src/FSharpPlus/Data/ValueOption.fs

@@ -52,6 +52,13 @@ type ValueOptionT<'``monad<voption<'t>>``> with
     static member inline (<*>) (f: ValueOptionT<'``Monad<voption<('T -> 'U)>``>, x: ValueOptionT<'``Monad<voption<'T>``>) = ValueOptionT.apply f x : ValueOptionT<'``Monad<voption<'U>``>
     static member inline (>>=) (x: ValueOptionT<'``Monad<voption<'T>``>, f: 'T -> ValueOptionT<'``Monad<voption<'U>``>)   = ValueOptionT.bind  f x
 
+    /// <summary>
+    /// Composes left-to-right two option functions (Kleisli composition).
+    /// </summary>
+    /// <category index="2">Monad</category>
+    static member inline (>=>) (f: 'T -> ValueOptionT<'``Monad<voption<'U>``>, g: 'U -> ValueOptionT<'``Monad<voption<'V>``>) : 'T -> ValueOptionT<'``Monad<voption<'V>``> = fun x -> ValueOptionT.bind g (f x)
+
+
     static member inline get_Zero () : ValueOptionT<'``MonadPlus<voption<'T>``> = ValueOptionT <| result ValueNone
     static member inline (+) (ValueOptionT x, ValueOptionT y) : ValueOptionT<'``MonadPlus<voption<'T>``> =
         ValueOptionT <| (x >>= function

src/FSharpPlus/Data/Writer.fs

@@ -78,6 +78,13 @@ type Writer<'monoid,'t> with
     #endif
 
     static member inline (>>=) (x, f: 'T->_) = Writer.bind f x          : Writer<'Monoid,'U>
+
+    /// <summary>
+    /// Composes left-to-right two Writer functions (Kleisli composition).
+    /// </summary>
+    /// <category index="2">Monad</category>
+    static member inline (>=>) (f, (g: 'U -> _)) : 'T -> Writer<'Monoid, 'V> = fun x -> Writer.bind g (f x)
+
     static member inline (<*>) (f, x: Writer<_,'T>) = Writer.apply f x  : Writer<'Monoid,'U>
 
     /// <summary>
@@ -169,6 +176,12 @@ type WriterT<'``monad<'t * 'monoid>``> with
 
     static member inline (>>=) (x: WriterT<'``Monad<'T * 'Monoid>``>, f: 'T -> _)                                    = WriterT.bind  f x : WriterT<'``Monad<'U * 'Monoid>``>
 
+    /// <summary>
+    /// Composes left-to-right two Writer functions (Kleisli composition).
+    /// </summary>
+    /// <category index="2">Monad</category>
+    static member inline (>=>) (f: 'T -> WriterT<'``Monad<'U * 'Monoid>``>, g: 'U -> WriterT<'``Monad<'V * 'Monoid>``>) : 'T -> WriterT<'``Monad<'V * 'Monoid>``> = fun x -> WriterT.bind g (f x)
+
     static member inline get_Empty () = WriterT (getEmpty ()) : WriterT<'``MonadPlus<'T * 'Monoid>``>
     static member inline (<|>) (WriterT m, WriterT n) = WriterT (m <|> n) : WriterT<'``MonadPlus<'T * 'Monoid>``>