package monadlib

  1. Overview
  2. Docs

Create a stream monad from an arbitrary inner monad, which computes the values discovered in each generation. This is pretty abstract, since we're not requiring that the inner monad is a collection. There is a constraint here, since we're strictly supposed to disallow a monad collection where order of elements matters. I think we can characterise this abstractly by saying that the plus operation on the inner monad must be commutative, but don't take my word for it!

Parameters

module M : sig ... end

Signature

include Stream with type 'a t = 'a M.m LazyList.node_t and type 'a m = 'a M.m LazyList.t
type 'a t = 'a M.m LazyList.node_t
include LazyPlus with type 'a m = 'a t Lazy.t with type 'a m = 'a M.m LazyList.t
include BaseLazyPlus with type 'a m = 'a t Lazy.t with type 'a m = 'a M.m LazyList.t
include BatInterfaces.Monad with type 'a m = 'a t Lazy.t with type 'a m = 'a M.m LazyList.t
type 'a m = 'a M.m LazyList.t

The type of a monad producing values of type 'a.

val lplus : 'a m -> 'a m Lazy.t -> 'a m
include MonadPlus with type 'a m := 'a m
include BasePlus with type 'a m := 'a m
include BatInterfaces.Monad with type 'a m := 'a m
val zero : unit -> 'a m
val plus : 'a m -> 'a m -> 'a m
val null : 'a m -> bool

null x implies that x is zero. If you do not want to or cannot answer whether a given x is zero, then null x should be false. I have provided this so that streams can be implemented more efficiently.

include Monad with type 'a m := 'a m
include BatInterfaces.Monad with type 'a m := 'a m
include Applicative.Applicative with type 'a m := 'a m
include Applicative.Base with type 'a m := 'a m
val filter : ('a -> bool) -> 'a m -> 'a m
val of_list : 'a list -> 'a m
val sum : 'a list m -> 'a m
val msum : 'a m list -> 'a m
val guard : bool -> 'a m -> 'a m
val transpose : 'a list m -> 'a m list

Generalises matrix transposition. This will loop infinitely if BasePlus.null cannot answer true for zeroes.

val of_llist : 'a LazyList.t -> 'a m
val lsum : 'a LazyList.t m -> 'a m
val lmsum : 'a m LazyList.t -> 'a m
val ltranspose : 'a LazyList.t m -> 'a m LazyList.t

Generalises matrix transposition. You don't necessarily have to worry about correctly implementing BaseLazyPlus.null for this function, since the return value can happily be infinite.

val iterate : ('a m -> 'a m) -> 'a m -> 'a m

The sum of the stream [f x, f (f x), f (f (f x)),...]

val delay : 'a m -> 'a m

Delay a stream by one time step. This is needed when you write recursive streams and you have to avoid deadlock. The nice thing about Ocaml here is that it will generally detect deadlock for you, announcing to you that you're writing viciously circular lists!

val to_depth : int -> 'a m -> 'a m

Terminate discovery at some depth.

include Monad with type 'a m := 'a m
include BatInterfaces.Monad with type 'a m := 'a m
val bind : 'a m -> ('a -> 'b m) -> 'b m

Monadic binding.

bind m f executes first m then f, using the result of m.

include Applicative.Applicative with type 'a m := 'a m
include Applicative.Base with type 'a m := 'a m
val return : 'a -> 'a m
val (<*>) : ('a -> 'b) m -> 'a m -> 'b m
val lift1 : ('a -> 'b) -> 'a m -> 'b m
val lift2 : ('a -> 'b -> 'c) -> 'a m -> 'b m -> 'c m
val lift3 : ('a -> 'b -> 'c -> 'd) -> 'a m -> 'b m -> 'c m -> 'd m
val lift4 : ('a -> 'b -> 'c -> 'd -> 'e) -> 'a m -> 'b m -> 'c m -> 'd m -> 'e m
val (<$>) : ('a -> 'b) -> 'a m -> 'b m

Alias for lift1.

val sequence : 'a m list -> 'a list m
val map_a : ('a -> 'b m) -> 'a list -> 'b list m
val (<*) : 'a m -> 'b m -> 'a m
val (>*) : 'a m -> 'b m -> 'b m
val (>>=) : 'a m -> ('a -> 'b m) -> 'b m
val join : 'a m m -> 'a m
val filter_m : ('a -> bool m) -> 'a list -> 'a list m
val onlyif : bool -> unit m -> unit m
val unless : bool -> unit m -> unit m
val ignore : 'a m -> unit m