Модуль Either

module Either: sig .. end

Тип Either.

Either — это самый простой и универсальный тип-сумма/вариантный тип: значение ('a, 'b) Either.t — это либо Left (v : 'a), либо Right (v : 'b).

Это естественный выбор в API обобщённых функций, значения которых могут относиться к двум различным случаям, возможно, разных типов, без присвоения конкретного смысла каждому из случаев.

Например:

List.partition_map:
    ('a -> ('b, 'c) Either.t) -> 'a list -> 'b list * 'c list

Если вам нужен параметризованный тип, в котором одна альтернатива означает успех, а другая — неудачу, используйте более специализированный тип Result.t.

Начиная с версии 4.12

type ('a, 'b) t =

`\|`	`Left of 'a`
`\|`	`Right of 'b`

Значение ('a, 'b) Either.t содержит либо значение 'a, либо значение 'b

val left : 'a -> ('a, 'b) t

left v — Left v.

val right : 'b -> ('a, 'b) t

right v — Right v.

val is_left : ('a, 'b) t -> bool

is_left (Left v) — true, is_left (Right v) — false.

val is_right : ('a, 'b) t -> bool

is_right (Left v) — false, is_right (Right v) — true.

val get_left : ('a, 'b) t -> 'a

get_left e — v, если e — Left v, иначе вызывает исключение.

Начиная с версии 5.4
Вызывает исключение Invalid_argument, если e — Right _.

val get_right : ('a, 'b) t -> 'b

get_right e — v, если e — Right v, иначе вызывает исключение.

Начиная с версии 5.4
Вызывает исключение Invalid_argument, если e — Left _.

val find_left : ('a, 'b) t -> 'a option

find_left (Left v) — Some v, find_left (Right _) — None

val find_right : ('a, 'b) t -> 'b option

find_right (Right v) — Some v, find_right (Left _) — None

val map_left : ('a1 -> 'a2) -> ('a1, 'b) t -> ('a2, 'b) t

map_left f e — Left (f v), если e — Left v, и e — e, если Right _.

val map_right : ('b1 -> 'b2) -> ('a, 'b1) t -> ('a, 'b2) t

map_right f e — Right (f v), если e — Right v, и e — e, если Left _.

val map : left:('a1 -> 'a2) ->       right:('b1 -> 'b2) -> ('a1, 'b1) t -> ('a2, 'b2) t

map ~left ~right (Left v) — Left (left v), map ~left ~right (Right v) — Right (right v).

val fold : left:('a -> 'c) -> right:('b -> 'c) -> ('a, 'b) t -> 'c

fold ~left ~right (Left v) — left v, а fold ~left ~right (Right v) — right v.

val retract : ('a, 'a) t -> 'a

retract (Left v) — v, а retract (Right v) — v.

Начиная с версии 5.4

val iter : left:('a -> unit) -> right:('b -> unit) -> ('a, 'b) t -> unit

iter ~left ~right (Left v) — left v, а iter ~left ~right (Right v) — right v.

val for_all : left:('a -> bool) -> right:('b -> bool) -> ('a, 'b) t -> bool

for_all ~left ~right (Left v) — left v, а for_all ~left ~right (Right v) — right v.

val equal : left:('a -> 'a -> bool) ->       right:('b -> 'b -> bool) -> ('a, 'b) t -> ('a, 'b) t -> bool

equal ~left ~right e0 e1 проверяет равенство e0 и e1, используя left и right для сравнения соответственно значений, обёрнутых в Left _ и Right _.

val compare : left:('a -> 'a -> int) ->       right:('b -> 'b -> int) -> ('a, 'b) t -> ('a, 'b) t -> int

compare ~left ~right e0 e1 задаёт полный порядок для e0 и e1, используя left и right для сравнения соответственно значений, обёрнутых в Left _ и Right _. Значения Left _ меньше значений Right _.