bap-c 2.1.0 · OCaml Package

C Type System.

We represent a C type structurally, i.e., the type representation is self-containted and doesn't require any typing requirement.

Polymorphic variants are used to represent C type constructors and type groups.

The type system is extended with attributes, i.e., it is possible to attach attributes of the form attr(args) to C type declarations.

type char = [

| `schar
| `char
| `uchar

]

val bin_shape_char : Core_kernel.Bin_prot.Shape.t

val bin_size_char : 'a -> int

val bin_write_char : 
  Bin_prot.Common.buf ->
  pos:Bin_prot.Common.pos ->
  [< `char | `schar | `uchar ] ->
  Bin_prot.Common.pos

val bin_writer_char : 
  [< `char | `schar | `uchar ] Core_kernel.Bin_prot.Type_class.writer

val __bin_read_char__ : 'a -> pos_ref:'b -> int -> [> `char | `schar | `uchar ]

val bin_read_char : 
  Bin_prot.Common.buf ->
  pos_ref:Bin_prot.Common.pos_ref ->
  [> `char | `schar | `uchar ]

val bin_reader_char : 
  [> `char | `schar | `uchar ] Core_kernel.Bin_prot.Type_class.reader

val bin_char : [ `char | `schar | `uchar ] Core_kernel.Bin_prot.Type_class.t

val compare_char : char -> char -> int

val __char_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> char

val char_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> char

val sexp_of_char : char -> Ppx_sexp_conv_lib.Sexp.t

val all_of_char : char list

type short = [

| `sshort
| `ushort

]

val bin_shape_short : Core_kernel.Bin_prot.Shape.t

val bin_size_short : 'a -> int

val bin_write_short : 
  Bin_prot.Common.buf ->
  pos:Bin_prot.Common.pos ->
  [< `sshort | `ushort ] ->
  Bin_prot.Common.pos

val bin_writer_short : 
  [< `sshort | `ushort ] Core_kernel.Bin_prot.Type_class.writer

val __bin_read_short__ : 'a -> pos_ref:'b -> int -> [> `sshort | `ushort ]

val bin_read_short : 
  Bin_prot.Common.buf ->
  pos_ref:Bin_prot.Common.pos_ref ->
  [> `sshort | `ushort ]

val bin_reader_short : 
  [> `sshort | `ushort ] Core_kernel.Bin_prot.Type_class.reader

val bin_short : [ `sshort | `ushort ] Core_kernel.Bin_prot.Type_class.t

val compare_short : short -> short -> int

val __short_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> short

val short_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> short

val sexp_of_short : short -> Ppx_sexp_conv_lib.Sexp.t

val all_of_short : short list

type cint = [

| `uint
| `sint

]

val bin_shape_cint : Core_kernel.Bin_prot.Shape.t

val bin_size_cint : 'a -> int

val bin_write_cint : 
  Bin_prot.Common.buf ->
  pos:Bin_prot.Common.pos ->
  [< `sint | `uint ] ->
  Bin_prot.Common.pos

val bin_writer_cint : [< `sint | `uint ] Core_kernel.Bin_prot.Type_class.writer

val __bin_read_cint__ : 'a -> pos_ref:'b -> int -> [> `sint | `uint ]

val bin_read_cint : 
  Bin_prot.Common.buf ->
  pos_ref:Bin_prot.Common.pos_ref ->
  [> `sint | `uint ]

val bin_reader_cint : [> `sint | `uint ] Core_kernel.Bin_prot.Type_class.reader

val bin_cint : [ `sint | `uint ] Core_kernel.Bin_prot.Type_class.t

val compare_cint : cint -> cint -> int

val __cint_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> cint

val cint_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> cint

val sexp_of_cint : cint -> Ppx_sexp_conv_lib.Sexp.t

val all_of_cint : cint list

type long = [

| `slong
| `ulong

]

val bin_shape_long : Core_kernel.Bin_prot.Shape.t

val bin_size_long : 'a -> int

val bin_write_long : 
  Bin_prot.Common.buf ->
  pos:Bin_prot.Common.pos ->
  [< `slong | `ulong ] ->
  Bin_prot.Common.pos

val bin_writer_long : 
  [< `slong | `ulong ] Core_kernel.Bin_prot.Type_class.writer

val __bin_read_long__ : 'a -> pos_ref:'b -> int -> [> `slong | `ulong ]

val bin_read_long : 
  Bin_prot.Common.buf ->
  pos_ref:Bin_prot.Common.pos_ref ->
  [> `slong | `ulong ]

val bin_reader_long : 
  [> `slong | `ulong ] Core_kernel.Bin_prot.Type_class.reader

val bin_long : [ `slong | `ulong ] Core_kernel.Bin_prot.Type_class.t

val compare_long : long -> long -> int

val __long_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> long

val long_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> long

val sexp_of_long : long -> Ppx_sexp_conv_lib.Sexp.t

val all_of_long : long list

type long_long = [

| `slong_long
| `ulong_long

]

val bin_shape_long_long : Core_kernel.Bin_prot.Shape.t

val bin_size_long_long : 'a -> int

val bin_write_long_long : 
  Bin_prot.Common.buf ->
  pos:Bin_prot.Common.pos ->
  [< `slong_long | `ulong_long ] ->
  Bin_prot.Common.pos

val bin_writer_long_long : 
  [< `slong_long | `ulong_long ] Core_kernel.Bin_prot.Type_class.writer

val __bin_read_long_long__ : 
  'a ->
  pos_ref:'b ->
  int ->
  [> `slong_long | `ulong_long ]

val bin_read_long_long : 
  Bin_prot.Common.buf ->
  pos_ref:Bin_prot.Common.pos_ref ->
  [> `slong_long | `ulong_long ]

val bin_reader_long_long : 
  [> `slong_long | `ulong_long ] Core_kernel.Bin_prot.Type_class.reader

val bin_long_long : 
  [ `slong_long | `ulong_long ] Core_kernel.Bin_prot.Type_class.t

val compare_long_long : long_long -> long_long -> int

val __long_long_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> long_long

val long_long_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> long_long

val sexp_of_long_long : long_long -> Ppx_sexp_conv_lib.Sexp.t

val all_of_long_long : long_long list

type signed = [

| `schar
| `sshort
| `sint
| `slong
| `slong_long

]

val bin_shape_signed : Core_kernel.Bin_prot.Shape.t

val bin_size_signed : 'a -> int

val bin_write_signed : 
  Bin_prot.Common.buf ->
  pos:Bin_prot.Common.pos ->
  [< `schar | `sint | `slong | `slong_long | `sshort ] ->
  Bin_prot.Common.pos

val bin_writer_signed : 
  [< `schar | `sint | `slong | `slong_long | `sshort ]
    Core_kernel.Bin_prot.Type_class.writer

val __bin_read_signed__ : 
  'a ->
  pos_ref:'b ->
  int ->
  [> `schar | `sint | `slong | `slong_long | `sshort ]

val bin_read_signed : 
  Bin_prot.Common.buf ->
  pos_ref:Bin_prot.Common.pos_ref ->
  [> `schar | `sint | `slong | `slong_long | `sshort ]

val bin_reader_signed : 
  [> `schar | `sint | `slong | `slong_long | `sshort ]
    Core_kernel.Bin_prot.Type_class.reader

val bin_signed : 
  [ `schar | `sint | `slong | `slong_long | `sshort ]
    Core_kernel.Bin_prot.Type_class.t

val compare_signed : signed -> signed -> int

val __signed_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> signed

val signed_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> signed

val sexp_of_signed : signed -> Ppx_sexp_conv_lib.Sexp.t

val all_of_signed : signed list

type unsigned = [

| `uchar
| `ushort
| `uint
| `ulong
| `ulong_long

]

val bin_shape_unsigned : Core_kernel.Bin_prot.Shape.t

val bin_size_unsigned : 'a -> int

val bin_write_unsigned : 
  Bin_prot.Common.buf ->
  pos:Bin_prot.Common.pos ->
  [< `uchar | `uint | `ulong | `ulong_long | `ushort ] ->
  Bin_prot.Common.pos

val bin_writer_unsigned : 
  [< `uchar | `uint | `ulong | `ulong_long | `ushort ]
    Core_kernel.Bin_prot.Type_class.writer

val __bin_read_unsigned__ : 
  'a ->
  pos_ref:'b ->
  int ->
  [> `uchar | `uint | `ulong | `ulong_long | `ushort ]

val bin_read_unsigned : 
  Bin_prot.Common.buf ->
  pos_ref:Bin_prot.Common.pos_ref ->
  [> `uchar | `uint | `ulong | `ulong_long | `ushort ]

val bin_reader_unsigned : 
  [> `uchar | `uint | `ulong | `ulong_long | `ushort ]
    Core_kernel.Bin_prot.Type_class.reader

val bin_unsigned : 
  [ `uchar | `uint | `ulong | `ulong_long | `ushort ]
    Core_kernel.Bin_prot.Type_class.t

val compare_unsigned : unsigned -> unsigned -> int

val __unsigned_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> unsigned

val unsigned_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> unsigned

val sexp_of_unsigned : unsigned -> Ppx_sexp_conv_lib.Sexp.t

val all_of_unsigned : unsigned list

type enum = [

| `enum of (string * int64 option) list

]

val bin_shape_enum : Core_kernel.Bin_prot.Shape.t

val bin_size_enum : 
  [< `enum of (Base.String.t * Base.Int64.t Base.Option.t) Base.List.t ] ->
  int

val bin_write_enum : 
  Bin_prot.Common.buf ->
  pos:Bin_prot.Common.pos ->
  [< `enum of (Base.String.t * Base.Int64.t Base.Option.t) Base.List.t ] ->
  Bin_prot.Common.pos

val bin_writer_enum : 
  [< `enum of (Base.String.t * Base.Int64.t Base.Option.t) Base.List.t ]
    Core_kernel.Bin_prot.Type_class.writer

val __bin_read_enum__ : 
  Bin_prot.Common.buf ->
  pos_ref:Bin_prot.Common.pos_ref ->
  int ->
  [> `enum of (Base.String.t * Base.Int64.t Base.Option.t) Base.List.t ]

val bin_read_enum : 
  Bin_prot.Common.buf ->
  pos_ref:Bin_prot.Common.pos_ref ->
  [> `enum of (Base.String.t * Base.Int64.t Base.Option.t) Base.List.t ]

val bin_reader_enum : 
  [> `enum of (Base.String.t * Base.Int64.t Base.Option.t) Base.List.t ]
    Core_kernel.Bin_prot.Type_class.reader

val bin_enum : 
  [ `enum of (Base.String.t * Base.Int64.t Base.Option.t) Base.List.t ]
    Core_kernel.Bin_prot.Type_class.t

val compare_enum : enum -> enum -> int

val __enum_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> enum

val enum_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> enum

val sexp_of_enum : enum -> Ppx_sexp_conv_lib.Sexp.t

type integer = [

| char
| signed
| unsigned
| enum

]

val bin_shape_integer : Core_kernel.Bin_prot.Shape.t

val bin_size_integer : 
  [< `char
  | `enum of (Base.String.t * Base.Int64.t Base.Option.t) Base.List.t
  | `schar
  | `sint
  | `slong
  | `slong_long
  | `sshort
  | `uchar
  | `uint
  | `ulong
  | `ulong_long
  | `ushort ] ->
  int

val bin_write_integer : 
  Bin_prot.Common.buf ->
  pos:Bin_prot.Common.pos ->
  [< `char
  | `enum of (Base.String.t * Base.Int64.t Base.Option.t) Base.List.t
  | `schar
  | `sint
  | `slong
  | `slong_long
  | `sshort
  | `uchar
  | `uint
  | `ulong
  | `ulong_long
  | `ushort ] ->
  Bin_prot.Common.pos

val bin_writer_integer : 
  [< `char
  | `enum of (Base.String.t * Base.Int64.t Base.Option.t) Base.List.t
  | `schar
  | `sint
  | `slong
  | `slong_long
  | `sshort
  | `uchar
  | `uint
  | `ulong
  | `ulong_long
  | `ushort ]
    Core_kernel.Bin_prot.Type_class.writer

val __bin_read_integer__ : 
  Bin_prot.Common.buf ->
  pos_ref:Bin_prot.Common.pos_ref ->
  int ->
  integer

val bin_read_integer : 
  Bin_prot.Common.buf ->
  pos_ref:Bin_prot.Common.pos_ref ->
  integer

val bin_reader_integer : integer Core_kernel.Bin_prot.Type_class.reader

val bin_integer : integer Core_kernel.Bin_prot.Type_class.t

val compare_integer : integer -> integer -> int

val __integer_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> integer

val integer_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> integer

val sexp_of_integer : integer -> Ppx_sexp_conv_lib.Sexp.t

type real = [

| `float
| `double
| `long_double

]

val bin_shape_real : Core_kernel.Bin_prot.Shape.t

val bin_size_real : 'a -> int

val bin_write_real : 
  Bin_prot.Common.buf ->
  pos:Bin_prot.Common.pos ->
  [< `double | `float | `long_double ] ->
  Bin_prot.Common.pos

val bin_writer_real : 
  [< `double | `float | `long_double ] Core_kernel.Bin_prot.Type_class.writer

val __bin_read_real__ : 
  'a ->
  pos_ref:'b ->
  int ->
  [> `double | `float | `long_double ]

val bin_read_real : 
  Bin_prot.Common.buf ->
  pos_ref:Bin_prot.Common.pos_ref ->
  [> `double | `float | `long_double ]

val bin_reader_real : 
  [> `double | `float | `long_double ] Core_kernel.Bin_prot.Type_class.reader

val bin_real : 
  [ `double | `float | `long_double ] Core_kernel.Bin_prot.Type_class.t

val compare_real : real -> real -> int

val __real_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> real

val real_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> real

val sexp_of_real : real -> Ppx_sexp_conv_lib.Sexp.t

val all_of_real : real list

type complex = [

| `cfloat
| `cdouble
| `clong_double

]

val bin_shape_complex : Core_kernel.Bin_prot.Shape.t

val bin_size_complex : 'a -> int

val bin_write_complex : 
  Bin_prot.Common.buf ->
  pos:Bin_prot.Common.pos ->
  [< `cdouble | `cfloat | `clong_double ] ->
  Bin_prot.Common.pos

val bin_writer_complex : 
  [< `cdouble | `cfloat | `clong_double ]
    Core_kernel.Bin_prot.Type_class.writer

val __bin_read_complex__ : 
  'a ->
  pos_ref:'b ->
  int ->
  [> `cdouble | `cfloat | `clong_double ]

val bin_read_complex : 
  Bin_prot.Common.buf ->
  pos_ref:Bin_prot.Common.pos_ref ->
  [> `cdouble | `cfloat | `clong_double ]

val bin_reader_complex : 
  [> `cdouble | `cfloat | `clong_double ]
    Core_kernel.Bin_prot.Type_class.reader

val bin_complex : 
  [ `cdouble | `cfloat | `clong_double ] Core_kernel.Bin_prot.Type_class.t

val compare_complex : complex -> complex -> int

val __complex_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> complex

val complex_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> complex

val sexp_of_complex : complex -> Ppx_sexp_conv_lib.Sexp.t

val all_of_complex : complex list

type floating = [

| real
| complex

]

val bin_shape_floating : Core_kernel.Bin_prot.Shape.t

val bin_size_floating : 
  [< `cdouble | `cfloat | `clong_double | `double | `float | `long_double ] ->
  int

val bin_write_floating : 
  Bin_prot.Common.buf ->
  pos:Bin_prot.Common.pos ->
  [< `cdouble | `cfloat | `clong_double | `double | `float | `long_double ] ->
  Bin_prot.Common.pos

val bin_writer_floating : 
  [< `cdouble | `cfloat | `clong_double | `double | `float | `long_double ]
    Core_kernel.Bin_prot.Type_class.writer

val __bin_read_floating__ : 'a -> pos_ref:'b -> int -> floating

val bin_read_floating : 
  Bin_prot.Common.buf ->
  pos_ref:Bin_prot.Common.pos_ref ->
  floating

val bin_reader_floating : floating Core_kernel.Bin_prot.Type_class.reader

val bin_floating : floating Core_kernel.Bin_prot.Type_class.t

val compare_floating : floating -> floating -> int

val __floating_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> floating

val floating_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> floating

val sexp_of_floating : floating -> Ppx_sexp_conv_lib.Sexp.t

val all_of_floating : floating list

type basic = [

| integer
| floating

]

val bin_shape_basic : Core_kernel.Bin_prot.Shape.t

val bin_size_basic : 
  [< `cdouble
  | `cfloat
  | `char
  | `clong_double
  | `double
  | `enum of (Base.String.t * Base.Int64.t Base.Option.t) Base.List.t
  | `float
  | `long_double
  | `schar
  | `sint
  | `slong
  | `slong_long
  | `sshort
  | `uchar
  | `uint
  | `ulong
  | `ulong_long
  | `ushort ] ->
  int

val bin_write_basic : 
  Bin_prot.Common.buf ->
  pos:Bin_prot.Common.pos ->
  [< `cdouble
  | `cfloat
  | `char
  | `clong_double
  | `double
  | `enum of (Base.String.t * Base.Int64.t Base.Option.t) Base.List.t
  | `float
  | `long_double
  | `schar
  | `sint
  | `slong
  | `slong_long
  | `sshort
  | `uchar
  | `uint
  | `ulong
  | `ulong_long
  | `ushort ] ->
  Bin_prot.Common.pos

val bin_writer_basic : 
  [< `cdouble
  | `cfloat
  | `char
  | `clong_double
  | `double
  | `enum of (Base.String.t * Base.Int64.t Base.Option.t) Base.List.t
  | `float
  | `long_double
  | `schar
  | `sint
  | `slong
  | `slong_long
  | `sshort
  | `uchar
  | `uint
  | `ulong
  | `ulong_long
  | `ushort ]
    Core_kernel.Bin_prot.Type_class.writer

val __bin_read_basic__ : 
  Bin_prot.Common.buf ->
  pos_ref:Bin_prot.Common.pos_ref ->
  int ->
  basic

val bin_read_basic : 
  Bin_prot.Common.buf ->
  pos_ref:Bin_prot.Common.pos_ref ->
  basic

val bin_reader_basic : basic Core_kernel.Bin_prot.Type_class.reader

val bin_basic : basic Core_kernel.Bin_prot.Type_class.t

val compare_basic : basic -> basic -> int

val __basic_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> basic

val basic_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> basic

val sexp_of_basic : basic -> Ppx_sexp_conv_lib.Sexp.t

type cv = unit

val bin_shape_cv : Core_kernel.Bin_prot.Shape.t

val bin_size_cv : cv Core_kernel.Bin_prot.Size.sizer

val bin_write_cv : cv Core_kernel.Bin_prot.Write.writer

val bin_writer_cv : cv Core_kernel.Bin_prot.Type_class.writer

val __bin_read_cv__ : (int -> cv) Core_kernel.Bin_prot.Read.reader

val bin_read_cv : cv Core_kernel.Bin_prot.Read.reader

val bin_reader_cv : cv Core_kernel.Bin_prot.Type_class.reader

val bin_cv : cv Core_kernel.Bin_prot.Type_class.t

val compare_cv : cv -> cv -> int

val cv_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> cv

val sexp_of_cv : cv -> Ppx_sexp_conv_lib.Sexp.t

type cvr = Core_kernel.Bool.t

val bin_shape_cvr : Core_kernel.Bin_prot.Shape.t

val bin_size_cvr : cvr Core_kernel.Bin_prot.Size.sizer

val bin_write_cvr : cvr Core_kernel.Bin_prot.Write.writer

val bin_writer_cvr : cvr Core_kernel.Bin_prot.Type_class.writer

val __bin_read_cvr__ : (int -> cvr) Core_kernel.Bin_prot.Read.reader

val bin_read_cvr : cvr Core_kernel.Bin_prot.Read.reader

val bin_reader_cvr : cvr Core_kernel.Bin_prot.Type_class.reader

val bin_cvr : cvr Core_kernel.Bin_prot.Type_class.t

val compare_cvr : cvr -> cvr -> int

val cvr_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> cvr

val sexp_of_cvr : cvr -> Ppx_sexp_conv_lib.Sexp.t

module Qualifier : sig ... end

type 'a qualifier = 'a Qualifier.t

val bin_shape_qualifier : 
  Core_kernel.Bin_prot.Shape.t ->
  Core_kernel.Bin_prot.Shape.t

val bin_size_qualifier : 
  'a. 'a Core_kernel.Bin_prot.Size.sizer ->
  'a qualifier Core_kernel.Bin_prot.Size.sizer

val bin_write_qualifier : 
  'a. 'a Core_kernel.Bin_prot.Write.writer ->
  'a qualifier Core_kernel.Bin_prot.Write.writer

val bin_writer_qualifier : 
  'a Core_kernel.Bin_prot.Type_class.writer ->
  'a qualifier Core_kernel.Bin_prot.Type_class.writer

val __bin_read_qualifier__ : 
  'a. 'a Core_kernel.Bin_prot.Read.reader ->
  (int -> 'a qualifier) Core_kernel.Bin_prot.Read.reader

val bin_read_qualifier : 
  'a. 'a Core_kernel.Bin_prot.Read.reader ->
  'a qualifier Core_kernel.Bin_prot.Read.reader

val bin_reader_qualifier : 
  'a Core_kernel.Bin_prot.Type_class.reader ->
  'a qualifier Core_kernel.Bin_prot.Type_class.reader

val bin_qualifier : 
  'a Core_kernel.Bin_prot.Type_class.t ->
  'a qualifier Core_kernel.Bin_prot.Type_class.t

val compare_qualifier : 
  'a. ('a -> 'a -> int) ->
  'a qualifier ->
  'a qualifier ->
  int

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

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

module Attr : sig ... end

type attr = Attr.t

val bin_shape_attr : Core_kernel.Bin_prot.Shape.t

val bin_size_attr : attr Core_kernel.Bin_prot.Size.sizer

val bin_write_attr : attr Core_kernel.Bin_prot.Write.writer

val bin_writer_attr : attr Core_kernel.Bin_prot.Type_class.writer

val __bin_read_attr__ : (int -> attr) Core_kernel.Bin_prot.Read.reader

val bin_read_attr : attr Core_kernel.Bin_prot.Read.reader

val bin_reader_attr : attr Core_kernel.Bin_prot.Type_class.reader

val bin_attr : attr Core_kernel.Bin_prot.Type_class.t

val compare_attr : attr -> attr -> int

val attr_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> attr

val sexp_of_attr : attr -> Ppx_sexp_conv_lib.Sexp.t

module Spec : sig ... end

type ('a, 'b) spec = ('a, 'b) Spec.t

val bin_shape_spec : 
  Core_kernel.Bin_prot.Shape.t ->
  Core_kernel.Bin_prot.Shape.t ->
  Core_kernel.Bin_prot.Shape.t

val bin_size_spec : 
  'a 'b. 'a Core_kernel.Bin_prot.Size.sizer ->
  'b Core_kernel.Bin_prot.Size.sizer ->
  ('a, 'b) spec Core_kernel.Bin_prot.Size.sizer

val bin_write_spec : 
  'a 'b. 'a Core_kernel.Bin_prot.Write.writer ->
  'b Core_kernel.Bin_prot.Write.writer ->
  ('a, 'b) spec Core_kernel.Bin_prot.Write.writer

val bin_writer_spec : 
  'a Core_kernel.Bin_prot.Type_class.writer ->
  'b Core_kernel.Bin_prot.Type_class.writer ->
  ('a, 'b) spec Core_kernel.Bin_prot.Type_class.writer

val __bin_read_spec__ : 
  'a 'b. 'a Core_kernel.Bin_prot.Read.reader ->
  'b Core_kernel.Bin_prot.Read.reader ->
  (int -> ('a, 'b) spec) Core_kernel.Bin_prot.Read.reader

val bin_read_spec : 
  'a 'b. 'a Core_kernel.Bin_prot.Read.reader ->
  'b Core_kernel.Bin_prot.Read.reader ->
  ('a, 'b) spec Core_kernel.Bin_prot.Read.reader

val bin_reader_spec : 
  'a Core_kernel.Bin_prot.Type_class.reader ->
  'b Core_kernel.Bin_prot.Type_class.reader ->
  ('a, 'b) spec Core_kernel.Bin_prot.Type_class.reader

val bin_spec : 
  'a Core_kernel.Bin_prot.Type_class.t ->
  'b Core_kernel.Bin_prot.Type_class.t ->
  ('a, 'b) spec Core_kernel.Bin_prot.Type_class.t

val compare_spec : 
  'a 'b. ('a -> 'a -> Base.Int.t) ->
  ('b -> 'b -> Base.Int.t) ->
  ('a, 'b) spec ->
  ('a, 'b) spec ->
  Base.Int.t

val spec_of_sexp : 
  'a 'b. (Ppx_sexp_conv_lib.Sexp.t -> 'a) ->
  (Ppx_sexp_conv_lib.Sexp.t -> 'b) ->
  Ppx_sexp_conv_lib.Sexp.t ->
  ('a, 'b) spec

val sexp_of_spec : 
  'a 'b. ('a -> Ppx_sexp_conv_lib.Sexp.t) ->
  ('b -> Ppx_sexp_conv_lib.Sexp.t) ->
  ('a, 'b) spec ->
  Ppx_sexp_conv_lib.Sexp.t

type no_qualifier = [

| `no_qualifier

]

val bin_shape_no_qualifier : Core_kernel.Bin_prot.Shape.t

val bin_size_no_qualifier : 'a -> int

val bin_write_no_qualifier : 
  Bin_prot.Common.buf ->
  pos:Bin_prot.Common.pos ->
  [< `no_qualifier ] ->
  Bin_prot.Common.pos

val bin_writer_no_qualifier : 
  [< `no_qualifier ] Core_kernel.Bin_prot.Type_class.writer

val __bin_read_no_qualifier__ : 'a -> pos_ref:'b -> int -> [> `no_qualifier ]

val bin_read_no_qualifier : 
  Bin_prot.Common.buf ->
  pos_ref:Bin_prot.Common.pos_ref ->
  [> `no_qualifier ]

val bin_reader_no_qualifier : 
  [> `no_qualifier ] Core_kernel.Bin_prot.Type_class.reader

val bin_no_qualifier : [ `no_qualifier ] Core_kernel.Bin_prot.Type_class.t

val compare_no_qualifier : no_qualifier -> no_qualifier -> int

val __no_qualifier_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> no_qualifier

val no_qualifier_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> no_qualifier

val sexp_of_no_qualifier : no_qualifier -> Ppx_sexp_conv_lib.Sexp.t

module Proto : sig ... end

module Compound : sig ... end

module Array : sig ... end

type t = [

| `Void
| `Basic of (cv qualifier, basic) spec
| `Pointer of (cvr qualifier, t) spec
| `Array of (cvr qualifier, array) spec
| `Structure of (no_qualifier, compound) spec
| `Union of (no_qualifier, compound) spec
| `Function of (no_qualifier, proto) spec

]

and proto = t Proto.t

and compound = t Compound.t

and array = t Array.t

val bin_shape_t : Core_kernel.Bin_prot.Shape.t

val bin_shape_proto : Core_kernel.Bin_prot.Shape.t

val bin_shape_compound : Core_kernel.Bin_prot.Shape.t

val bin_shape_array : Core_kernel.Bin_prot.Shape.t

val bin_size_t : t Core_kernel.Bin_prot.Size.sizer

val bin_size_proto : proto Core_kernel.Bin_prot.Size.sizer

val bin_size_compound : compound Core_kernel.Bin_prot.Size.sizer

val bin_size_array : array Core_kernel.Bin_prot.Size.sizer

val bin_write_t : t Core_kernel.Bin_prot.Write.writer

val bin_write_proto : proto Core_kernel.Bin_prot.Write.writer

val bin_write_compound : compound Core_kernel.Bin_prot.Write.writer

val bin_write_array : array Core_kernel.Bin_prot.Write.writer

val bin_writer_t : t Core_kernel.Bin_prot.Type_class.writer

val bin_writer_proto : proto Core_kernel.Bin_prot.Type_class.writer

val bin_writer_compound : compound Core_kernel.Bin_prot.Type_class.writer

val bin_writer_array : array Core_kernel.Bin_prot.Type_class.writer

val __bin_read_t__ : (int -> t) Core_kernel.Bin_prot.Read.reader

val __bin_read_proto__ : (int -> proto) Core_kernel.Bin_prot.Read.reader

val __bin_read_compound__ : (int -> compound) Core_kernel.Bin_prot.Read.reader

val __bin_read_array__ : (int -> array) Core_kernel.Bin_prot.Read.reader

val bin_read_t : t Core_kernel.Bin_prot.Read.reader

val bin_read_proto : proto Core_kernel.Bin_prot.Read.reader

val bin_read_compound : compound Core_kernel.Bin_prot.Read.reader

val bin_read_array : array Core_kernel.Bin_prot.Read.reader

val bin_reader_t : t Core_kernel.Bin_prot.Type_class.reader

val bin_reader_proto : proto Core_kernel.Bin_prot.Type_class.reader

val bin_reader_compound : compound Core_kernel.Bin_prot.Type_class.reader

val bin_reader_array : array Core_kernel.Bin_prot.Type_class.reader

val bin_t : t Core_kernel.Bin_prot.Type_class.t

val bin_proto : proto Core_kernel.Bin_prot.Type_class.t

val bin_compound : compound Core_kernel.Bin_prot.Type_class.t

val bin_array : array Core_kernel.Bin_prot.Type_class.t

val compare : t -> t -> Base.Int.t

val compare_proto : proto -> proto -> Base.Int.t

val compare_compound : compound -> compound -> Base.Int.t

val compare_array : array -> array -> Base.Int.t

val __t_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> t

val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t

val proto_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> proto

val compound_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> compound

val array_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> array

val sexp_of_t : t -> Ppx_sexp_conv_lib.Sexp.t

val sexp_of_proto : proto -> Ppx_sexp_conv_lib.Sexp.t

val sexp_of_compound : compound -> Ppx_sexp_conv_lib.Sexp.t

val sexp_of_array : array -> Ppx_sexp_conv_lib.Sexp.t

type scalar = [

| `Basic of (cv qualifier, basic) spec
| `Pointer of (cvr qualifier, t) spec

]

val bin_shape_scalar : Core_kernel.Bin_prot.Shape.t

val bin_size_scalar : 
  [< `Basic of
       (cv qualifier,
         [< `cdouble
         | `cfloat
         | `char
         | `clong_double
         | `double
         | `enum of (Base.String.t * Base.Int64.t Base.Option.t) Base.List.t
         | `float
         | `long_double
         | `schar
         | `sint
         | `slong
         | `slong_long
         | `sshort
         | `uchar
         | `uint
         | `ulong
         | `ulong_long
         | `ushort ])
         spec
  | `Pointer of (cvr qualifier, t) spec ] ->
  int

val bin_write_scalar : 
  Bin_prot.Common.buf ->
  pos:Bin_prot.Common.pos ->
  [< `Basic of
       (cv qualifier,
         [< `cdouble
         | `cfloat
         | `char
         | `clong_double
         | `double
         | `enum of (Base.String.t * Base.Int64.t Base.Option.t) Base.List.t
         | `float
         | `long_double
         | `schar
         | `sint
         | `slong
         | `slong_long
         | `sshort
         | `uchar
         | `uint
         | `ulong
         | `ulong_long
         | `ushort ])
         spec
  | `Pointer of (cvr qualifier, t) spec ] ->
  Bin_prot.Common.pos

val bin_writer_scalar : 
  [< `Basic of
       (cv qualifier,
         [< `cdouble
         | `cfloat
         | `char
         | `clong_double
         | `double
         | `enum of (Base.String.t * Base.Int64.t Base.Option.t) Base.List.t
         | `float
         | `long_double
         | `schar
         | `sint
         | `slong
         | `slong_long
         | `sshort
         | `uchar
         | `uint
         | `ulong
         | `ulong_long
         | `ushort ])
         spec & (cv qualifier,
                  [< `cdouble
                  | `cfloat
                  | `char
                  | `clong_double
                  | `double
                  | `enum of
                    (Base.String.t * Base.Int64.t Base.Option.t) Base.List.t
                  | `float
                  | `long_double
                  | `schar
                  | `sint
                  | `slong
                  | `slong_long
                  | `sshort
                  | `uchar
                  | `uint
                  | `ulong
                  | `ulong_long
                  | `ushort ])
                  spec
  | `Pointer of (cvr qualifier, t) spec ]
    Core_kernel.Bin_prot.Type_class.writer

val __bin_read_scalar__ : 
  Bin_prot.Common.buf ->
  pos_ref:Bin_prot.Common.pos_ref ->
  int ->
  [> `Basic of (cv qualifier, basic) spec
  | `Pointer of (cvr qualifier, t) spec ]

val bin_read_scalar : 
  Bin_prot.Common.buf ->
  pos_ref:Bin_prot.Common.pos_ref ->
  [> `Basic of (cv qualifier, basic) spec
  | `Pointer of (cvr qualifier, t) spec ]

val bin_reader_scalar : 
  [> `Basic of (cv qualifier, basic) spec
  | `Pointer of (cvr qualifier, t) spec ]
    Core_kernel.Bin_prot.Type_class.reader

val bin_scalar : 
  [ `Basic of (cv qualifier, basic) spec
  | `Pointer of (cvr qualifier, t) spec ]
    Core_kernel.Bin_prot.Type_class.t

val compare_scalar : scalar -> scalar -> int

val __scalar_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> scalar

val scalar_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> scalar

val sexp_of_scalar : scalar -> Ppx_sexp_conv_lib.Sexp.t

type aggregate = [

| `Array of (no_qualifier, t) spec
| `Structure of (no_qualifier, t list) spec

]

val bin_shape_aggregate : Core_kernel.Bin_prot.Shape.t

val bin_size_aggregate : 
  [< `Array of ('a, t) spec | `Structure of ('b, t Base.List.t) spec ] ->
  int

val bin_write_aggregate : 
  Bin_prot.Common.buf ->
  pos:Bin_prot.Common.pos ->
  [< `Array of ([< `no_qualifier ], t) spec
  | `Structure of ([< `no_qualifier ], t Base.List.t) spec ] ->
  Bin_prot.Common.pos

val bin_writer_aggregate : 
  [< `Array of ('a, t) spec & ([< `no_qualifier ], t) spec
  | `Structure of
    ('b, t Base.List.t) spec & ([< `no_qualifier ], t Base.List.t) spec ]
    Core_kernel.Bin_prot.Type_class.writer

val __bin_read_aggregate__ : 
  Bin_prot.Common.buf ->
  pos_ref:Bin_prot.Common.pos_ref ->
  int ->
  [> `Array of ([> `no_qualifier ], t) spec
  | `Structure of ([> `no_qualifier ], t Base.List.t) spec ]

val bin_read_aggregate : 
  Bin_prot.Common.buf ->
  pos_ref:Bin_prot.Common.pos_ref ->
  [> `Array of ([> `no_qualifier ], t) spec
  | `Structure of ([> `no_qualifier ], t Base.List.t) spec ]

val bin_reader_aggregate : 
  [> `Array of ([> `no_qualifier ], t) spec
  | `Structure of ([> `no_qualifier ], t Base.List.t) spec ]
    Core_kernel.Bin_prot.Type_class.reader

val bin_aggregate : 
  [ `Array of ([ `no_qualifier ], t) spec
  | `Structure of ([ `no_qualifier ], t Base.List.t) spec ]
    Core_kernel.Bin_prot.Type_class.t

val compare_aggregate : aggregate -> aggregate -> int

val __aggregate_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> aggregate

val aggregate_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> aggregate

val sexp_of_aggregate : aggregate -> Ppx_sexp_conv_lib.Sexp.t