package regular

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

Overview
Features
1. Type definitions
  1. Reader and Writer type classes

package regular

regular
- Regular
  - Std
    
    Bytes
    
    Hash_queue
    
    Key
    
    Hash_set
    
    Map
    
    Key
    
    Tree
    
    Replace_polymorphic_compare
    
    Set
    
    Elt
    
    Tree
    
    Table
    
    Unsafe
    
    Data
    
    Cache
    
    Digest
    
    Hash_queue
    
    Key
    
    Hash_set
    
    Map
    
    Key
    
    Tree
    
    Replace_polymorphic_compare
    
    Set
    
    Elt
    
    Tree
    
    Table
    
    Service
    
    Make
    
    Cache
    
    Io
    
    T
    
    Read
    
    S
    
    Cache
    
    Io
    
    Versioned
    
    S
    
    Write
    
    Opaque
    
    Make
    
    Hash_queue
    
    Key
    
    Hash_set
    
    M
    
    Map
    
    Key
    
    Tree
    
    Replace_polymorphic_compare
    
    Set
    
    Elt
    
    Tree
    
    Table
    
    S
    
    Hash_queue
    
    Key
    
    Hash_set
    
    Map
    
    Key
    
    Tree
    
    Replace_polymorphic_compare
    
    Set
    
    Elt
    
    Tree
    
    Table
    
    Printable
    
    Make
    
    M
    
    S
    
    Regular
    
    Make
    
    Cache
    
    Hash_queue
    
    Key
    
    Hash_set
    
    Io
    
    M
    
    Map
    
    Key
    
    Tree
    
    Replace_polymorphic_compare
    
    Set
    
    Elt
    
    Tree
    
    Table
    
    S
    
    Cache
    
    Hash_queue
    
    Key
    
    Hash_set
    
    Io
    
    Map
    
    Key
    
    Tree
    
    Replace_polymorphic_compare
    
    Set
    
    Elt
    
    Tree
    
    Table
    
    Seq
    
    Generator
    
    Let_syntax
    
    Let_syntax
    
    Open_in_body
    
    Open_on_rhs
    
    Monad_infix
    
    Infix
    
    Let_syntax
    
    Let_syntax
    
    Open_in_body
    
    Open_on_rhs
    
    Merge_with_duplicates_element
    
    Monad_infix
    
    Step

Legend:
Library
Module
Module type
Parameter
Class
Class type

Interface that should support any regular data type.

Overview

A regular type is catch all term for all data types that are regular, like numbers, characters, strings and their algebraic closure. A proper term for such types would be inductive types. A regular type always has a concrete representation, it is printable, comparable (with total order), hashable, etc.

To contrast, functions, closures, proxies, descriptors, and any co-inductive types are non-regular. The main difference, is that regular type is self contained, where non-regular types, usually represent something that can be only observed, but not really represented with the data type.

On the border line we have Opaque data types. These are types, that pretend to be Regular, but we can't actually inspect their representation.

Features

So what the library actually provides. First of all it defines the Regular interface, that each regular data type is expected to implement. This includes a full set of Io functions, that allows one to read, write and serialize values of the type (see Data interface). It also provides an inteface for creating different collections from the values of that type, including trees, hashtables, maps, sets, etc. Also, it describes the whole algebra of comparison functions. For the opaque data types an interface called Opaque is provided, that is a proper subset of the Regular. It doesn't provide printing and serialization, but has everything that can be derived for a type with a total order (e.g., containers, comparison function, etc).

A functor is provided for each interface, that requires the minimal implementation, and derives the rest.

Finally, a Bytes module is provided that facilitates the transfer from mutable to immutable Strings. It is the extension of OCaml standard Bytes module, enhanced with the expected set of functions.

see https://ocaml.janestreet.com/ocaml-core/latest/doc/core_kernel/
Core Kernel Documentation

Type definitions

type bytes = Core_kernel.Std.Bytes.t

bytes is a mutable sequence of bytes that has a fixed length.

include sig ... end

val bytes_of_sexp : Sexplib.Sexp.t -> bytes

val sexp_of_bytes : bytes -> Sexplib.Sexp.t

val compare_bytes : bytes -> bytes -> int

val bin_bytes : bytes Core_kernel.Std.Bin_prot.Type_class.t

val bin_read_bytes : bytes Core_kernel.Std.Bin_prot.Read.reader

val __bin_read_bytes__ : (int -> bytes) Core_kernel.Std.Bin_prot.Read.reader

val bin_reader_bytes : bytes Core_kernel.Std.Bin_prot.Type_class.reader

val bin_size_bytes : bytes Core_kernel.Std.Bin_prot.Size.sizer

val bin_write_bytes : bytes Core_kernel.Std.Bin_prot.Write.writer

val bin_writer_bytes : bytes Core_kernel.Std.Bin_prot.Type_class.writer

Reader and Writer type classes

Each type class is an abstraction of a tuple of function.

type 'a reader

an interface for reading a value from the input.

type 'a writer

an interface for writing a value to the output.

type digest

a string that digests data

include sig ... end

val digest_of_sexp : Sexplib.Sexp.t -> digest

val sexp_of_digest : digest -> Sexplib.Sexp.t

val compare_digest : digest -> digest -> int

val bin_digest : digest Core_kernel.Std.Bin_prot.Type_class.t

val bin_read_digest : digest Core_kernel.Std.Bin_prot.Read.reader

val __bin_read_digest__ : (int -> digest) Core_kernel.Std.Bin_prot.Read.reader

val bin_reader_digest : digest Core_kernel.Std.Bin_prot.Type_class.reader

val bin_size_digest : digest Core_kernel.Std.Bin_prot.Size.sizer

val bin_write_digest : digest Core_kernel.Std.Bin_prot.Write.writer

val bin_writer_digest : digest Core_kernel.Std.Bin_prot.Type_class.writer

type 'a printer = Format.formatter -> 'a -> unit

'a printer constructs a printer type for arbitrary type 'a.

A value of type 'a printer is a function that is expected by the %a specifier of the Format.printf family of functions.

module Printable : sig ... end

Printable data structures.

module Seq : sig ... end

Lazy sequence.

type 'a seq = 'a Seq.t

Abbreviation for 'a Sequence.t

include sig ... end

val seq_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a seq

val sexp_of_seq : ('a -> Sexplib.Sexp.t) -> 'a seq -> Sexplib.Sexp.t

val compare_seq : ('a -> 'a -> int) -> 'a seq -> 'a seq -> int

val bin_seq : 
  'a Core_kernel.Std.Bin_prot.Type_class.t ->
  'a seq Core_kernel.Std.Bin_prot.Type_class.t

val bin_read_seq : 
  'a Core_kernel.Std.Bin_prot.Read.reader ->
  'a seq Core_kernel.Std.Bin_prot.Read.reader

val __bin_read_seq__ : 
  'a Core_kernel.Std.Bin_prot.Read.reader ->
  (int -> 'a seq) Core_kernel.Std.Bin_prot.Read.reader

val bin_reader_seq : 
  'a Core_kernel.Std.Bin_prot.Type_class.reader ->
  'a seq Core_kernel.Std.Bin_prot.Type_class.reader

val bin_size_seq : 
  'a Core_kernel.Std.Bin_prot.Size.sizer ->
  'a seq Core_kernel.Std.Bin_prot.Size.sizer

val bin_write_seq : 
  'a Core_kernel.Std.Bin_prot.Write.writer ->
  'a seq Core_kernel.Std.Bin_prot.Write.writer

val bin_writer_seq : 
  'a Core_kernel.Std.Bin_prot.Type_class.writer ->
  'a seq Core_kernel.Std.Bin_prot.Type_class.writer

val (^::) : 'a -> 'a seq -> 'a seq

x ^:: xs is a consing operator for sequences

module Data : sig ... end

Data types support module.

module Regular : sig ... end

Regular types models a general concept of value, i.e., something that can be used in way similar to regular int, string, char and other built in types. So that it can be compared, used in maps, sets, hashtables, printer, etc.

module Opaque : sig ... end

Opaque type is like regular type, except that we can print or examine it in any way. So it can't be serialized or pretty-printed. An Opaque.Make can create an instances of such type.

module Bytes : sig ... end

Extension of the standard bytes module.