package tezos-stdlib

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

Compare

tezos-stdlib
- Tezos_stdlib
  - Bits
  - Bloomer
  - Bounded_heap
    
    Make
  - Circular_buffer
  - Compare
    
    Bool
    
    Bytes
    
    COMPARABLE
    
    Char
    
    Float
    
    Int
    
    Int32
    
    Int64
    
    List
    
    P
    
    List_length_with
    
    List_lengths
    
    Make
    
    P
    
    Option
    
    P
    
    Q
    
    Result
    
    Error
    
    Ok
    
    S
    
    String
    
    Uint32
    
    Uint64
    
    Z
  - FallbackArray
  - FunctionalArray
  - Hash_queue
    
    Make
    
    V
  - Hex
  - Lwt_dropbox
  - Lwt_idle_waiter
  - Lwt_pipe
    
    Bounded
    
    Maybe_bounded
    
    Unbounded
  - Lwt_utils
  - Memory
  - Tag
    
    DSL
    
    Key
  - TzBytes
  - TzEndian
  - TzFilename
    
    Infix
  - TzList
  - TzString
  - Utils
    
    Infix

Legend:
Library
Module
Module type
Parameter
Class
Class type

`Compare`

Monomorphic comparison for common ground types and common type constructors.

Compare provides a module signature for the standard comparison functions and operators as well as modules of that signature for the common OCaml ground types (int, bool, etc.) and type constructors (list, option, etc.).

Compare also provides some additional helpers for comparison-related tasks.

Signatures and a functor

module type COMPARABLE = sig ... end

COMPARABLE is a signature for basic comparison. It is used only for instantiating full comparison modules of signature S via the functor Make.

module type S = sig ... end

S is a signature for a fully-fledge comparison module. It includes all the functions and operators derived from a compare function.

module Make (P : COMPARABLE) : S with type t := P.t

Base types

The specialised comparison and all the specialised functions and operators on the base types are compatible with the polymorphic comparison and all the polymorphic functions and operators from the Stdlib.

module Char : S with type t = char

module Bool : S with type t = bool

module Int : sig ... end

Int is a comparison module. Out of performance concerns, the signature actually contains compiler builtins (external) rather than val.

module Int32 : S with type t = int32

module Uint32 : S with type t = int32

module Int64 : S with type t = int64

module Uint64 : S with type t = int64

module Float : S with type t = float

module String : S with type t = string

module Bytes : S with type t = bytes

module Z : S with type t = Z.t

Z is a comparison module for Zarith numbers.

module Q : S with type t = Q.t

Q is a comparison module for Zarith-based rational numbers.

Type constructors

Provided the functor argument(s) are compatible with the polymorphic comparison of the Stdlib, then the specialised comparison and all the specialised functions and operators on the derived types are compatible with the polymorphic comparison and all the polymorphic functions and operators from the Stdlib.

module List (P : COMPARABLE) : S with type t = P.t list

module Option (P : COMPARABLE) : S with type t = P.t option

module Result
  (Ok : COMPARABLE)
  (Error : COMPARABLE) : 
  S with type t = (Ok.t, Error.t) Stdlib.result

List lengths

Helpers for more readable Stdlib.List.compare_lengths and Stdlib.List.compare_length_with.

These modules are intended to be used as Module.(expression), most often within an if condition. E.g.,

if Compare.List_length_with.(chunks > max_number_of_chunks) then
   raise Maximum_size_exceeded
else
   ..

module List_length_with : sig ... end

module List_lengths : sig ... end

Building blocks

val or_else : int -> (unit -> int) -> int

or_else c f is c if c <> 0 or f () otherwise.

The intended use is

let compare (foo_a, bar_a) (foo_b, bar_b) =
  or_else (Foo.compare foo_a foo_b) (fun () -> Bar.compare bar_a bar_b)