Module `Flambda2_bound_identifiers.Bound_pattern`

Things that a Let-expression binds. If a Let-expression binds more than one name, all of those names have the same kind.

type t = private

| Singleton of Bound_var.t
(*
The binding of a single variable, which is statically scoped. This case is not used for sets of closures.
*)
| Set_of_closures of Bound_var.t list
(*
The binding of one or more variables to the individual closures in a set of closures. The variables are statically scoped.
*)
| Static of Bound_static.t
(*
The binding of symbols and code IDs to statically-allocated constants and pieces of code. The scoping of the symbols and code IDs follows the dominator tree, not syntactic scope.
*)

val singleton : Bound_var.t -> t

val set_of_closures : Bound_var.t list -> t

val static : Bound_static.t -> t

val must_be_singleton : t -> Bound_var.t

val must_be_singleton_opt : t -> Bound_var.t option

val must_be_set_of_closures : t -> Bound_var.t list

val must_be_static : t -> Bound_static.t

val name_mode : t -> Flambda2_nominal.Name_mode.t

val with_name_mode : t -> Flambda2_nominal.Name_mode.t -> t

val exists_all_bound_vars : t -> f:(Bound_var.t -> bool) -> bool

val fold_all_bound_vars : t -> init:'a -> f:('a -> Bound_var.t -> 'a) -> 'a

val fold_all_bound_names : 
  t ->
  init:'a ->
  var:('a -> Bound_var.t -> 'a) ->
  symbol:('a -> Flambda2_identifiers.Symbol.t -> 'a) ->
  code_id:('a -> Flambda2_identifiers.Code_id.t -> 'a) ->
  'a

include Flambda2_nominal.Bindable.S with type t := t

include Flambda2_nominal.Contains_names.S with type t := t

val free_names : t -> Flambda2_nominal.Name_occurrences.t

Compute the free names of a term. Such computation covers all kinds of bindable names (variables, continuations, ...)

val apply_renaming : t -> Flambda2_nominal.Renaming.t -> t

Apply a renaming throughout a term.

include Flambda2_nominal.Contains_ids.S with type t := t

val ids_for_export : t -> Flambda2_nominal.Ids_for_export.t

Gather all table identifiers to export them.

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

val rename : t -> t

Freshen the given name.

val is_renamed_version_of : t -> t -> bool

Equivalence relation on renamed variables.

is_renamed_version_of x y is true if there exists a bindable z such that x and y are renamed versions of z.

Note: this function can return true in other cases (if there are some name collisions for instance), this is (at least currently) only used for a sanity check, so users should not rely too much on its expected semantics.

val renaming : t -> guaranteed_fresh:t -> Flambda2_nominal.Renaming.t

renaming stale ~guaranteed_fresh:fresh is to create a renaming that turns all occurrences of the name stale into fresh (in a capture-avoiding manner, but that is inherent in Renaming).

Module Flambda2_bound_identifiers.Bound_pattern

Module `Flambda2_bound_identifiers.Bound_pattern`