Std.Block
Basic block.
Basic block is piece of code, that has single entry and single exit. It can be seen as a container for instructions. Also, basic blocks are nodes of control flow graphs.
The following invariants must be preserved:
type t = block
val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t
Since block
contains a region of memory, that is not regular, the block itself is also non-regular. But it is, at least, printable.
include Regular.Std.Opaque.S with type t := t
include Core_kernel.Comparable.S with type t := t
val comparator : (t, comparator_witness) Base__.Comparator.comparator
module Replace_polymorphic_compare : sig ... end
module Map : sig ... end
module Set : sig ... end
include Core_kernel.Hashable.S with type t := t
val hash_fold_t :
Ppx_hash_lib.Std.Hash.state ->
t ->
Ppx_hash_lib.Std.Hash.state
val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
val hashable : t Core_kernel__.Hashtbl.Hashable.t
module Table : sig ... end
module Hash_set : sig ... end
module Hash_queue : sig ... end
all the printing stuff, including to_string
function
include Regular.Std.Printable.S with type t := t
val to_string : t -> string
to_string x
returns a human-readable representation of x
val str : unit -> t -> string
str () t
is formatted output function that matches "%a" conversion format specifier in functions, that prints to string, e.g., sprintf
, failwithf
, errorf
and, surprisingly all Lwt
printing function, including Lwt_io.printf
and logging (or any other function with type ('a,unit,string,...) formatN`. Example:
Or_error.errorf "type %a is not valid for %a"
Type.str ty Exp.str exp
val pps : unit -> t -> string
synonym for str
val ppo : Core_kernel.Out_channel.t -> t -> unit
will print to a standard output_channel
, useful for using in printf
, fprintf
, etc.
val pp_seq : Stdlib.Format.formatter -> t Core_kernel.Sequence.t -> unit
prints a sequence of values of type t
this will include pp
function from Core
that has type t printer
, and can be used in Format.printf
family of functions
include Core_kernel.Pretty_printer.S with type t := t
val pp : Base__.Formatter.t -> t -> unit