hardcaml v0.14.0 · OCaml Package

type 'a t

val sexp_of_t : 
  ('a -> Ppx_sexp_conv_lib.Sexp.t) ->
  'a t ->
  Ppx_sexp_conv_lib.Sexp.t

val iter : 'a t -> f:('a -> Base.Unit.t) -> Base.Unit.t

val iter2 : 'a t -> 'b t -> f:('a -> 'b -> Base.Unit.t) -> Base.Unit.t

val map : 'a t -> f:('a -> 'b) -> 'b t

val map2 : 'a t -> 'b t -> f:('a -> 'b -> 'c) -> 'c t

val to_list : 'a t -> 'a Base.List.t

val t : (Base.String.t * Base.Int.t) t

include Base.Equal.S1 with type 'a t := 'a t

val equal : 'a Base.Equal.equal -> 'a t Base.Equal.equal

val port_names : Base.String.t t

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

val port_widths : Base.Int.t t

Bit widths specified in the interface definition.

val to_alist : 'a t -> (Base.String.t * 'a) Base.List.t

Create association list indexed by field names.

val of_alist : (Base.String.t * 'a) Base.List.t -> 'a t

Create interface from association list indexed by field names

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) -> 'd t

val map4 : 
  'a t ->
  'b t ->
  'c t ->
  'd t ->
  f:('a -> 'b -> 'c -> 'd -> 'e) ->
  'e t

val map5 : 
  'a t ->
  'b t ->
  'c t ->
  'd t ->
  'e t ->
  f:('a -> 'b -> 'c -> 'd -> 'e -> 'f) ->
  'f t

val iter3 : 
  'a t ->
  'b t ->
  'c t ->
  f:('a -> 'b -> 'c -> Base.Unit.t) ->
  Base.Unit.t

val iter4 : 
  'a t ->
  'b t ->
  'c t ->
  'd t ->
  f:('a -> 'b -> 'c -> 'd -> Base.Unit.t) ->
  Base.Unit.t

val iter5 : 
  'a t ->
  'b t ->
  'c t ->
  'd t ->
  'e t ->
  f:('a -> 'b -> 'c -> 'd -> 'e -> Base.Unit.t) ->
  Base.Unit.t

val fold : 'a t -> init:'acc -> f:('acc -> 'a -> 'acc) -> 'acc

val fold2 : 'a t -> 'b t -> init:'acc -> f:('acc -> 'a -> 'b -> 'acc) -> 'acc

val scan : 'a t -> init:'acc -> f:('acc -> 'a -> 'acc * 'b) -> 'b t

val scan2 : 
  'a t ->
  'b t ->
  init:'acc ->
  f:('acc -> 'a -> 'b -> 'acc * 'c) ->
  'c t

val offsets : ?rev:Base.Bool.t -> Base.Unit.t -> Base.Int.t 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 Base.List.t -> 'a Base.List.t t

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

val to_interface_list : 'a Base.List.t t -> 'a t Base.List.t

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 type Comb = sig ... end

module Make_comb (Comb : Comb.S) : Comb with type comb = Comb.t

module Of_bits : Comb with type comb = Bits.t

module Of_signal : sig ... end

val of_enum : (module Comb.S with type t = 'a) -> Enum.t -> 'a t

val to_enum : Bits.t t -> Enum.t

val mux : 
  (module Comb.S with type t = 'a) ->
  default:'a ->
  'a t ->
  (Enum.t * 'a) Base.List.t ->
  'a

module For_testing : sig ... end

package hardcaml