Module `Ocaml_typing.Ident`Source

Sourcetype t

include Ocaml_utils.Identifiable.S with type t := t

Sourcemodule T : Ocaml_utils.Identifiable.Thing with type t = t

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

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

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

The equality predicate used to compare keys.

Sourceval 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

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

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

Sourcemodule Set : sig ... end

Sourcemodule Map : sig ... end

Sourcemodule Tbl : sig ... end

Sourceval doc_print : t Merlin_utils.Format_doc.printer

Sourceval print_with_scope : t Merlin_utils.Format_doc.printer

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

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

Sourceval create_local : string -> t

Sourceval create_persistent : string -> t

Sourceval create_predef : string -> t

Sourceval 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.

Sourceval name : t -> string

Sourceval unique_name : t -> string

Sourceval unique_toplevel_name : t -> string

Sourceval persistent : t -> bool

Sourceval 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.

Sourceval compare_stamp : t -> t -> int

Compare only the internal stamps, 0 if absent

Sourceval compare : t -> t -> int

Compare identifiers structurally, including the name

Sourceval global : t -> bool

Sourceval is_predef : t -> bool

Sourceval scope : t -> int

Sourceval stamp : t -> int

Sourceval lowest_scope : int

Sourceval highest_scope : int

Sourceval reinit : unit -> unit

Sourcetype 'a tbl

'a tbl represents association tables from identifiers to values of type 'a.

'a tbl plays the role of map, but bindings can be looked up from either the full Ident using find_same, or just its user-visible name using find_name. In general the two lookups may not return the same result, as an identifier may have been shadowed in the environment by a distinct identifier with the same name.

find_all returns the bindings for all idents of a given name, most recently introduced first.

In other words, 'a tbl corresponds to (Ident.t * 'a) list Map.Make(String) and the implementation is very close to that representation.

Note in particular that searching among idents of the same name takes linear time, and that add simply extends the list without checking for duplicates. So it is not a good idea to implement union by repeated add calls, which may result in many duplicated identifiers and poor find_same performance. It is even possible to build overly large same-name lists such that non-recursive functions like find_all or fold_all blow the stack.

You should probably use Map.Make(Ident) instead, unless you really need to query bindings by user-visible name, not just by unique identifiers.

Sourceval empty : 'a tbl

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

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

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

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

Sourceval find_all_seq : string -> 'a tbl -> (t * 'a) Seq.t

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

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

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

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

Sourceval make_key_generator : unit -> t -> t

Sourceval rename_no_exn : t -> t

Like rename, but does not fail on persistent/predef idents.

Sourceval get_currentstamp : unit -> int

Get the value of the current stamp (the stamp of the last created identifier). Used to flush identifier-based caches when backtracking.

Install

Dune Dependency

Authors

Maintainers

Sources

doc/merlin-lib.ocaml_typing/Ocaml_typing/Ident/index.html

Module `Ocaml_typing.Ident`Source

package merlin-lib

Install

Dune Dependency

Authors

Maintainers

Sources

doc/merlin-lib.ocaml_typing/Ocaml_typing/Ident/index.html

Module Ocaml_typing.IdentSource

Module `Ocaml_typing.Ident`Source