Up

Module Either = Core_kernel.Either

Signature

include Core_kernel.Either_intf.S
type ('f, 's) t =
| First of 'f
| Second of 's

This type represents values with two possibilities. Either can be seen as a generic sum type, the dual of Tuple. First is neither more important nor less important than Second.

val t_of_sexp : (Sexplib.Sexp.t -> 'f) -> (Sexplib.Sexp.t -> 's) -> Sexplib.Sexp.t -> ('f, 's) t
val sexp_of_t : ('f -> Sexplib.Sexp.t) -> ('s -> Sexplib.Sexp.t) -> ('f, 's) t -> Sexplib.Sexp.t
val compare : ('f -> 'f -> int) -> ('s -> 's -> int) -> ('f, 's) t -> ('f, 's) t -> int
val bin_read_t : 'f Bin_prot.Read.reader -> 's Bin_prot.Read.reader -> ('f, 's) t Bin_prot.Read.reader
val __bin_read_t__ : 'f Bin_prot.Read.reader -> 's Bin_prot.Read.reader -> (int -> ('f, 's) t) Bin_prot.Read.reader
val bin_size_t : 'f Bin_prot.Size.sizer -> 's Bin_prot.Size.sizer -> ('f, 's) t Bin_prot.Size.sizer
val bin_write_t : 'f Bin_prot.Write.writer -> 's Bin_prot.Write.writer -> ('f, 's) t Bin_prot.Write.writer
include Core_kernel.Invariant.S2 with type ('a, 'b) t := ('a, 'b) t
type ('a, 'b) t
val invariant : 'a Invariant_intf.inv -> 'b Invariant_intf.inv -> ('a, 'b) t Invariant_intf.inv
include Core_kernel.Quickcheckable.S2 with type ('a, 'b) t := ('a, 'b) t
type 'a gen
type 'a obs
type 'a shr
type ('a, 'b) t
val gen : 'a gen -> 'b gen -> ('a, 'b) t gen
val obs : 'a obs -> 'b obs -> ('a, 'b) t obs
val shrinker : 'a shr -> 'b shr -> ('a, 'b) t shr
val swap : ('f, 's) t -> ('s, 'f) t
val value : ('a, 'a) t -> 'a
val iter : ('a, 'b) t -> first:('a -> unit) -> second:('b -> unit) -> unit
val value_map : ('a, 'b) t -> first:('a -> 'c) -> second:('b -> 'c) -> 'c
val map : ('a, 'b) t -> first:('a -> 'c) -> second:('b -> 'd) -> ('c, 'd) t
val equal : ('f -> 'f -> bool) -> ('s -> 's -> bool) -> ('f, 's) t -> ('f, 's) t -> bool
module First : Either_intf.Focused with type ('a, 'b) t = ('a, 'b) t
module Second : Either_intf.Focused with type ('a, 'b) t = ('b, 'a) t
val is_first : (_, _) t -> bool
val is_second : (_, _) t -> bool
val first : 'f -> ('f, _) t

first and second are First.return and Second.return.

val second : 's -> (_, 's) t
module Export : sig .. end
module Stable : sig .. end