package io

You can search for identifiers within the package.

in-package search v0.2.0

package io

io
- Library io
  - Elements
    
    Result
    
    Public
    
    Type
    
    Functor
    
    Id
    
    Make
    
    T2
    
    Monad
    
    Fn
    
    Public
    
    Option
    
    Public
    
    Exn
    
    Public
    
    List
    
    Public
    
    Str
    
    Either
    
    Public
    
    Base
    
    Log
  - IO
    
    Seq
    
    Test
- Sources
  - io
    
    IO.ml
    
    elements.ml

Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Module `Elements`Source

Sourcemodule Result : sig ... end

Sourcemodule type Type = sig ... end

Sourcemodule type Functor = sig ... end

Sourcemodule Id : sig ... end

Sourcemodule T2 : sig ... end

Sourcemodule type Monad = sig ... end

Sourcemodule Fn : sig ... end

Sourcemodule Option : sig ... end

Sourcemodule Exn : sig ... end

Sourcemodule List : sig ... end

Sourcemodule Str : sig ... end

Sourcemodule Either : sig ... end

Sourcemodule Base : sig ... end

include module type of struct include Base end

include module type of struct include Either.Public end

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

| Left of 'a
| Right of 'b

Sourceval either : ('a -> 'b) -> ('c -> 'b) -> ('a, 'c) either -> 'b

include module type of struct include Exn.Public end

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

Sourceval fail : string -> 'a

include module type of struct include Fn.Public end

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

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

Sourceval id : 'a -> 'a

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

include module type of struct include List.Public end

Sourceval cons : 'a -> 'a list -> 'a list

include module type of struct include Option.Public end

Sourceval some : 'a -> 'a option

Sourceval none : 'a option

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

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

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

include module type of struct include Result.Public end

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

| Ok of 'a
| Error of 'e

Sourceval ok : 'a -> ('a, 'b) result

Sourceval error : 'a -> ('b, 'a) result

Sourceval discard : 'a -> unit

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

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

Sourceval time : ('a -> 'b) -> 'a -> 'b

Sourceval print : string -> unit

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

Sourceval even : int -> bool

Sourceval odd : int -> bool

Sourcetype void = Base.void =

| Void

Sourceval closed : void -> 'a

Sourceval output_line : out_channel -> string -> unit

Sourcemodule Log : sig ... end

package io

Module ElementsSource

Module `Elements`Source