package ocaml-base-compiler

You can search for identifiers within the package.

in-package search v0.2.0

Package contains no libraries

Variables used in the backend, optionally equipped with "provenance" information, used for the emission of debugging information.

include module type of struct include Ident end

type t = Ident.t

include Identifiable.S with type t := t

module T = Ident.T

include Identifiable.Thing with type t := T.t

include Hashtbl.HashedType with type t := T.t

val equal : T.t -> T.t -> bool

The equality predicate used to compare keys.

val hash : T.t -> int

A hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include

((=), hash) for comparing objects by structure (provided objects do not contain floats)
((fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly
((==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).

include Map.OrderedType with type t := T.t

val output : out_channel -> T.t -> unit

val print : Format.formatter -> T.t -> unit

module Set = Ident.Set

module Map = Ident.Map

module Tbl = Ident.Tbl

val print_with_scope : Format.formatter -> t -> unit

Same as print except that it will also add a "n" suffix if the scope of the argument is n.

val create_scoped : scope:int -> string -> t

val create_local : string -> t

val create_persistent : string -> t

val create_predef : string -> t

val rename : t -> t

Creates an identifier with the same name as the input, a fresh stamp, and no scope.

raises [Fatal_error]
if called on a persistent / predef ident.

val name : t -> string

val unique_name : t -> string

val unique_toplevel_name : t -> string

val persistent : t -> bool

val same : t -> t -> bool

Compare identifiers by binding location. Two identifiers are the same either if they are both non-persistent and have been created by the same call to create_*, or if they are both persistent and have the same name.

val compare : t -> t -> int

val global : t -> bool

val is_predef : t -> bool

val scope : t -> int

val lowest_scope : int

val highest_scope : int

val reinit : unit -> unit

type 'a tbl = 'a Ident.tbl

val empty : 'a tbl

val add : t -> 'a -> 'a tbl -> 'a tbl

val find_same : t -> 'a tbl -> 'a

val find_name : string -> 'a tbl -> t * 'a

val find_all : string -> 'a tbl -> (t * 'a) list

val fold_name : (t -> 'a -> 'b -> 'b) -> 'a tbl -> 'b -> 'b

val fold_all : (t -> 'a -> 'b -> 'b) -> 'a tbl -> 'b -> 'b

val iter : (t -> 'a -> unit) -> 'a tbl -> unit

val remove : t -> 'a tbl -> 'a tbl

val make_key_generator : unit -> t -> t

type backend_var = t

module Provenance : sig ... end

module With_provenance : sig ... end