asn1-combinators 0.2.5 · OCaml Package

module OID = Asn_oid

val id : 'a -> 'a

val const : 'a -> 'b -> 'a

val (&.) : ('a -> 'b) -> ('c -> 'a) -> 'c -> 'b

val opt : 'a -> 'a option -> 'a

type 'a endo = 'a -> 'a

type ('a, 'b) sum =

| L of 'a
| R of 'b

val strf : ('a, Stdlib.Format.formatter, unit, string) Stdlib.format4 -> 'a

val pf : 
  Stdlib.Format.formatter ->
  ('a, Stdlib.Format.formatter, unit) Stdlib.format ->
  'a

val kstrf : 
  (string -> 'a) ->
  ('b, Stdlib.Format.formatter, unit, 'a) Stdlib.format4 ->
  'b

val invalid_arg : ('a, unit, string, 'b) Stdlib.format4 -> 'a

val pp_list : 
  sep:(Stdlib.Format.formatter -> unit -> unit) ->
  (Stdlib.Format.formatter -> 'a -> unit) ->
  Stdlib.Format.formatter ->
  'a list ->
  unit

val pp_dump_list : 
  (Stdlib.Format.formatter -> 'a -> unit) ->
  Stdlib.Format.formatter ->
  'a list ->
  unit

val pp_cs : Stdlib.Format.formatter -> Cstruct.t -> unit

module Tag : sig ... end

type tag = Tag.t

type tags = Tag.t list

module Generic : sig ... end

type bits = int * Cstruct.t

type 'a rand = unit -> 'a

type _ asn =

| Iso : ('a -> 'b) * ('b -> 'a) * 'b rand option * 'a asn -> 'b asn
| Fix : ('a asn -> 'a asn) * 'a Asn_cache.var -> 'a asn
| Sequence : 'a sequence -> 'a asn
| Sequence_of : 'a asn -> 'a list asn
| Set : 'a sequence -> 'a asn
| Set_of : 'a asn -> 'a list asn
| Choice : 'a asn * 'b asn -> ('a, 'b) sum asn
| Implicit : tag * 'a asn -> 'a asn
| Explicit : tag * 'a asn -> 'a asn
| Prim : 'a prim -> 'a asn

and _ element =

| Required : string option * 'a asn -> 'a element
| Optional : string option * 'a asn -> 'a option element

and _ sequence =

| Last : 'a element -> 'a sequence
| Pair : 'a element * 'b sequence -> ('a * 'b) sequence

and _ prim =

| Bool : bool prim
| Int : Z.t prim
| Bits : bits prim
| Octets : Cstruct.t prim
| Null : unit prim
| OID : OID.t prim
| CharString : string prim

val label : string option -> string

val seq_tag : Tag.t

val set_tag : Tag.t

val tag_of_p : 'a. 'a prim -> tag

val tag_set : 'a. 'a asn -> tags

val tag : 'a. 'a -> 'a asn -> tag

type error = [

| `Parse of string

]

val pp_error : Stdlib.Format.formatter -> [< `Parse of string ] -> unit

exception Ambiguous_syntax

exception Parse_error of error

val error : error -> 'a

val parse_error : ('a, Stdlib.Format.formatter, unit, 'b) Stdlib.format4 -> 'a

module FSet : sig ... end

val validate : 'a asn -> unit

package asn1-combinators