Module Enum.Make_binary

Constructs a hardcaml interface which represents hardware for the given Enum as an abstract Interface, using a Binary internal representation.

Parameters

module Cases : Cases

Signature

include Interface.S
type 'a t
include Ppx_compare_lib.Equal.S1 with type 'a t := 'a t
include Ppx_compare_lib.Equal.S1__local with type 'a t := 'a t
include Ppx_compare_lib.Comparable.S1 with type 'a t := 'a t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
include Ppx_compare_lib.Comparable.S1__local with type 'a t := 'a t
val sexp_of_t : ('a -> Sexplib0.Sexp.t) -> 'a t -> Sexplib0.Sexp.t
val iter : 'a t -> f:('a -> unit) @ local -> unit
val iter2 : 'a t -> 'b t -> f:('a -> ('b -> unit) @ local) @ local -> unit
val map : 'a t -> f:('a -> 'b) @ local -> 'b t
val map2 : 'a t -> 'b t -> f:('a -> ('b -> 'c) @ local) @ local -> 'c t
val to_list : 'a t -> 'a list
val port_names_and_widths : (string * int) t
include Base.Equal.S1__local with type 'a t := 'a t
val equal : 'a Base.Equal.equal -> 'a t Base.Equal.equal
val port_names : string t

RTL names specified in the interface definition - commonly also the OCaml field name.

val port_widths : int t

Bit widths specified in the interface definition.

val const : 'a -> 'a t

const x sets each port to x

type tag
val equal_tag : tag -> tag -> bool
val equal_tag__local : tag @ local -> (tag @ local -> bool) @ local
val tags : tag t
val to_alist : 'a t -> (tag * 'a) list

Create association list indexed by tag.

val of_alist : (tag * 'a) list -> 'a t

Create interface from association list indexed by tag.

val sum_of_port_widths : int

Sum of all port widths specified in the interface definition.

module Unsafe_assoc_by_port_name : sig ... end
val zip : 'a t -> 'b t -> ('a * 'b) t
val zip3 : 'a t -> 'b t -> 'c t -> ('a * 'b * 'c) t
val zip4 : 'a t -> 'b t -> 'c t -> 'd t -> ('a * 'b * 'c * 'd) t
val zip5 : 'a t -> 'b t -> 'c t -> 'd t -> 'e t -> ('a * 'b * 'c * 'd * 'e) t
val map3 : 'a t -> 'b t -> 'c t -> f:('a -> ('b -> ('c -> 'd) @ local) @ local) @ local -> 'd t
val map4 : 'a t -> 'b t -> 'c t -> 'd t -> f:('a -> ('b -> ('c -> ('d -> 'e) @ local) @ local) @ local) @ local -> 'e t
val map5 : 'a t -> 'b t -> 'c t -> 'd t -> 'e t -> f: ('a -> ('b -> ('c -> ('d -> ('e -> 'f) @ local) @ local) @ local) @ local) @ local -> 'f t
val iter3 : 'a t -> 'b t -> 'c t -> f:('a -> ('b -> ('c -> unit) @ local) @ local) @ local -> unit
val iter4 : 'a t -> 'b t -> 'c t -> 'd t -> f:('a -> ('b -> ('c -> ('d -> unit) @ local) @ local) @ local) @ local -> unit
val iter5 : 'a t -> 'b t -> 'c t -> 'd t -> 'e t -> f: ('a -> ('b -> ('c -> ('d -> ('e -> unit) @ local) @ local) @ local) @ local) @ local -> unit
val fold : 'a t -> init:'acc -> f:('acc -> ('a -> 'acc) @ local) @ local -> 'acc
val fold2 : 'a t -> 'b t -> init:'acc -> f:('acc -> ('a -> ('b -> 'acc) @ local) @ local) @ local -> 'acc
val scan : 'a t -> init:'acc -> f:('acc -> ('a -> 'acc * 'b) @ local) @ local -> 'b t
val scan2 : 'a t -> 'b t -> init:'acc -> f:('acc -> ('a -> ('b -> 'acc * 'c) @ local) @ local) @ local -> 'c t
val offsets : ?rev:bool -> unit -> int t

Offset of each field within the interface. The first field is placed at the least significant bit, unless the rev argument is true.

val of_interface_list : 'a t list -> 'a list t

Take a list of interfaces and produce a single interface where each field is a list.

val to_interface_list : 'a list t -> 'a t list

Create a list of interfaces from a single interface where each field is a list. Raises if all lists don't have the same length.

module All (M : Base.Monad.S) : sig ... end

Similar to Monad.all for lists -- combine and lift the monads to outside the interface.

val or_error_all : 'a Core.Or_error.t t -> 'a t Core.Or_error.t

Equivalent to All(Or_error).all. This is made a special case for convenience.

module type Comb = sig ... end
module Of_clocked_signal : sig ... end
module Names_and_widths : sig ... end
val wave_formats : Wave_format.t t

Optional Metadata

val ast : Interface.Ast.t
val of_enum : (module Comb.S with type t = 'a) -> Cases.t -> 'a t
val to_enum : Bits.t t -> Cases.t Core.Or_error.t
val to_enum_exn : Bits.t t -> Cases.t
val (==:) : (module Comb.S with type t = 'a) -> 'a t -> 'a t -> 'a
val match_ : (module Comb.S with type t = 'a) -> ?default:'a -> 'a t -> (Cases.t * 'a) list -> 'a
val to_raw : 'a t -> 'a
type 'a outer := 'a t
module Of_signal : sig ... end
module Of_bits : sig ... end
module Of_always : sig ... end

Helper functions to ease usage of the Always API when working with interfaces.

module Make_comb (X : Comb.S) : sig ... end
val sim_set : Bits.t ref t -> Cases.t -> unit

Set an input port in simulation to a concrete Cases value.

val sim_set_raw : Bits.t ref t -> Bits.t -> unit

Similar to sim_set, but operates on raw Bits.t instead.

Read an output port from simulation to a concreate Cases value. Returns Ok enum when the Bits.t value can be parsed, and Error _ when the value is unhandled.

val sim_get_exn : Bits.t ref t -> Cases.t

Equivalent to ok_exn (sim_get x)

val sim_get_raw : Bits.t ref t -> Bits.t

Similar to sim_get, but operates on raw Bits.t instead. This doesn't return _ Or_error.t. Undefined values will be returned as it is.

val unwrap : 'a t -> 'a
module Unsafe : sig ... end