package io

You can search for identifiers within the package.

in-package search v0.2.0

package io

io
- Elements
  - Base
  - Either
    
    Public
  - Exn
    
    Public
  - Fn
    
    Public
  - Functor
  - Id
    
    Make
    
    X
  - List
    
    Public
  - Log
  - Monad
  - Option
    
    Public
  - Result
    
    Public
  - Str
  - T2
  - Type
- IO
  - Seq
  - Test

Legend:
Library
Module
Module type
Parameter
Class
Class type

module Result : sig ... end

module type Type = sig ... end

module type Functor = sig ... end

module Id : sig ... end

module T2 : sig ... end

module type Monad = sig ... end

module Fn : sig ... end

module Option : sig ... end

module Exn : sig ... end

module List : sig ... end

module Str : sig ... end

module Either : sig ... end

module Base : sig ... end

include module type of struct include Base end

include module type of struct include Either.Public end

type ('a, 'b) either = ('a, 'b) Either.Public.either =

| Left of 'a
| Right of 'b

val either : ('a -> 'b) -> ('c -> 'd) -> ('e, 'f) either -> 'g

include module type of struct include Exn.Public end

val guard : ('a -> 'b) -> 'a -> ('b, exn) Result.result

val fail : string -> 'a

include module type of struct include Fn.Public end

val (@.) : ('a -> 'b) -> ('c -> 'a) -> 'c -> 'b

val (|>) : ('a -> 'b) -> ('b -> 'c) -> 'a -> 'c

val id : 'a -> 'a

val flip : ('a -> 'b -> 'c) -> 'b -> 'a -> 'c

include module type of struct include List.Public end

val cons : 'a -> 'b list -> 'b list

include module type of struct include Option.Public end

val some : 'a -> 'a option

val none : 'a option

val option : none:'a Lazy.t -> some:('b -> 'a) -> 'b option -> 'a

val (|?) : 'a option -> 'a -> 'a

val (?!) : 'a option -> 'a

include module type of struct include Result.Public end

type ('a, 'e) result = ('a, 'e) Result.Public.result =

| Ok of 'a
| Error of 'e

val ok : 'a -> ('b, 'c) result

val error : 'a -> ('b, 'c) result

val discard : 'a -> unit

val force : 'a Lazy.t -> 'a

val (!) : 'a Lazy.t -> 'a

val time : ('a -> 'b) -> 'c -> 'd

val print : string -> unit

val fmt : ('a, unit, string) format -> 'a

val even : int -> bool

val odd : int -> bool

type void = Base.void =

| Void

val closed : void -> 'a

val output_line : out_channel -> string -> unit

module Log : sig ... end