package deriving

You can search for identifiers within the package.

in-package search v0.2.0

package deriving

deriving.runtime
- Deriving_Bounded
- Deriving_Default
  - Default
  - Default_array
    
    A
  - Default_bool
  - Default_char
  - Default_float
  - Default_int
  - Default_int64
  - Default_list
    
    A
  - Default_option
    
    A
  - Default_ref
    
    A
  - Default_string
  - Default_unit
  - Defaults
    
    D
- Deriving_Dump
  - Defaults
    
    P
  - Dump
  - Dump_alpha
    
    P
  - Dump_bool
  - Dump_char
  - Dump_float
  - Dump_int
  - Dump_int32
  - Dump_int64
  - Dump_list
    
    P
  - Dump_nativeint
  - Dump_option
    
    P
  - Dump_string
  - Dump_undumpable
    
    P
  - Dump_unit
  - Dump_via_marshal
    
    P
- Deriving_Enum
  - Defaults
    
    E
  - Defaults'
    
    B
    
    E
  - Enum
  - Enum_bool
  - Enum_char
  - Enum_int
  - Enum_unit
- Deriving_Eq
  - Eq
  - Eq_alpha
    
    S
  - Eq_array
    
    E
  - Eq_bool
  - Eq_char
  - Eq_float
  - Eq_immutable
    
    S
  - Eq_int
  - Eq_int32
  - Eq_int64
  - Eq_list
    
    E
  - Eq_map_s_t
    
    E
    
    M
  - Eq_mutable
    
    S
  - Eq_nativeint
  - Eq_option
    
    E
  - Eq_ref
    
    E
  - Eq_set_s_t
    
    S
  - Eq_string
  - Eq_unit
- Deriving_Functor
  - Functor
  - Functor_list
  - Functor_map
    
    O
  - Functor_option
  - MonadFunctor
    
    M
- Deriving_Pickle
  - Defaults
    
    Eq
    
    S
    
    Eq
    
    Typeable
    
    Typeable
  - Pickle
    
    Eq
    
    Typeable
  - Pickle_bool
    
    Eq
    
    Typeable
  - Pickle_char
    
    Eq
    
    Typeable
  - Pickle_float
    
    Eq
    
    Typeable
  - Pickle_from_dump
    
    E
    
    Eq
    
    P
    
    T
    
    Typeable
  - Pickle_int
    
    Eq
    
    Typeable
  - Pickle_int32
    
    Eq
    
    Typeable
  - Pickle_int64
    
    Eq
    
    Typeable
  - Pickle_list
    
    Eq
    
    Typeable
    
    V0
    
    Eq
    
    Typeable
  - Pickle_nativeint
    
    Eq
    
    Typeable
  - Pickle_option
    
    Eq
    
    Typeable
    
    V0
    
    Eq
    
    Typeable
  - Pickle_ref
    
    Eq
    
    S
    
    Eq
    
    Typeable
    
    Typeable
  - Pickle_string
    
    Eq
    
    Typeable
  - Pickle_unit
    
    Eq
    
    Typeable
  - Read
    
    Utils
    
    T
  - Repr
  - Write
    
    Utils
    
    E
    
    T
- Deriving_Show
  - Defaults
    
    S
  - Show
  - Show_array
    
    S
  - Show_bool
  - Show_char
  - Show_float
  - Show_int
  - Show_int32
  - Show_int64
  - Show_list
    
    S
  - Show_map
    
    K
    
    O
    
    V
  - Show_nativeint
  - Show_option
    
    S
  - Show_ref
    
    S
  - Show_set
    
    K
    
    O
  - Show_string
  - Show_unit
  - Show_unprintable
    
    S
- Deriving_Typeable
  - Defaults
    
    T
  - Primitive_typeable
    
    T
  - TypeRep
  - Typeable
  - Typeable_bool
  - Typeable_char
  - Typeable_float
  - Typeable_int
  - Typeable_int32
  - Typeable_int64
  - Typeable_list
    
    A
  - Typeable_nativeint
  - Typeable_option
    
    A
  - Typeable_ref
    
    A
  - Typeable_string
  - Typeable_unit
- Deriving_monad
  - IO
  - Monad
  - MonadDefault
    
    M
  - MonadPlus
  - MonadPlusUtils
    
    M
  - MonadPlusUtilsSig
  - MonadPlusUtils_list
  - MonadPlusUtils_option
  - MonadUtils
    
    M
  - MonadUtilsSig
  - Monad_IO
  - Monad_list
  - Monad_option
  - Monad_state
    
    S
  - Monad_state_type

Legend:
Library
Module
Module type
Parameter
Class
Class type

module Loc : sig ... end

module Action : Camlp4.Sig.Grammar.Action

module Token : sig ... end

type gram

type internal_entry

type tree

type token_pattern = (Token.t -> bool) * string

type token_info

type token_stream = (Token.t * token_info) Stream.t

val token_location : token_info -> Loc.t

type symbol =

| Smeta of string * symbol list * Action.t
| Snterm of internal_entry
| Snterml of internal_entry * string
| Slist0 of symbol
| Slist0sep of symbol * symbol
| Slist1 of symbol
| Slist1sep of symbol * symbol
| Sopt of symbol
| Stry of symbol
| Sself
| Snext
| Stoken of token_pattern
| Skeyword of string
| Stree of tree

type production_rule = symbol list * Action.t

type single_extend_statment =
  string option * Camlp4.Sig.Grammar.assoc option * production_rule list

type extend_statment =
  Camlp4.Sig.Grammar.position option * single_extend_statment list

type delete_statment = symbol list

type ('a, !'b, !'c) fold =
  internal_entry ->
  symbol list ->
  ('a Stream.t -> 'b) ->
  'a Stream.t ->
  'c

type ('a, !'b, !'c) foldsep =
  internal_entry ->
  symbol list ->
  ('a Stream.t -> 'b) ->
  ('a Stream.t -> unit) ->
  'a Stream.t ->
  'c

module Entry : sig ... end

val get_filter : unit -> Token.Filter.t

type 'a not_filtered

val extend : 'a Entry.t -> extend_statment -> unit

val delete_rule : 'a Entry.t -> delete_statment -> unit

val srules : 'a Entry.t -> (symbol list * Action.t) list -> symbol

val sfold0 : ('a -> 'b -> 'b) -> 'b -> ('c, 'a, 'b) fold

val sfold1 : ('a -> 'b -> 'b) -> 'b -> ('c, 'a, 'b) fold

val sfold0sep : ('a -> 'b -> 'b) -> 'b -> ('c, 'a, 'b) foldsep

val lex : Loc.t -> char Stream.t -> (Token.t * Loc.t) Stream.t not_filtered

val lex_string : Loc.t -> string -> (Token.t * Loc.t) Stream.t not_filtered

val filter : (Token.t * Loc.t) Stream.t not_filtered -> token_stream

val parse : 'a Entry.t -> Loc.t -> char Stream.t -> 'a

val parse_string : 'a Entry.t -> Loc.t -> string -> 'a

val parse_tokens_before_filter : 
  'a Entry.t ->
  (Token.t * Loc.t) Stream.t not_filtered ->
  'a

val parse_tokens_after_filter : 'a Entry.t -> token_stream -> 'a