package reason-standard

You can search for identifiers within the package.

in-package search v0.2.0

reason-standard
- README
- Library reason-standard
  - Standard
    
    Bool
    
    Char
    
    Int
    
    Integer
    
    Float
    
    String
    
    Option
    
    Infix
    
    Result
    
    Infix
    
    Tuple
    
    Tuple3
    
    Array
    
    List
    
    Set
    
    Of
    
    Poly
    
    Int
    
    String
    
    Map
    
    Of
    
    Poly
    
    Int
    
    String
    
    Container
    
    Sum
    
    Comparator
    
    T
    
    S
    
    Make
    
    Fun
- Sources
  - reason-standard
    
    Core.ml
    
    Standard.ml
    
    standard__.ml

Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Module `Standard.Comparator`

Comparator provide a way for custom data structures to be used with Maps and Sets

Say we have a module Book which we want to be able to create a Set of

  module Book = struct
    type t = {
      isbn: string;
      title: string;
    }
  end

First we need to make our module conform to the S signature.

This can be done by using the make function or the Make functor.

  module Book = struct
    type t = {
      isbn: string;
      title: string;
    }
    
    module ByIsbn = (
      val Comparator.make ~compare:(fun bookA bookB ->
        String.compare bookA.isbn bookb.isbn
      )
    )
  end

Then we can create a Set

  Set.ofList (module Book.ByIsbn) [
    { isbn="9788460767923"; title="Moby Dick or The Whale" }
  ]

module type T = sig ... end

T represents the input for the Make functor

type ('a, 'identity) t

type ('a, 'identity) comparator = ('a, 'identity) t

This just is an alias for t

module type S = sig ... end

The output type of Make and make.

type ('a, 'identity) s =
  (module S
  with type identity = 'identity
   and type t = 'a)

A type alias that is useful typing functions which accept first class modules like Map.empty or Set.ofArray

val make : compare:('a -> 'a -> int) -> (module S with type t = 'a)

Create a new comparator by providing a compare function.

Examples

   module Book = struct
     type t = {
       isbn: string;
       title: string;
     }
     
     module ByTitle = (
       val Comparator.make ~compare:(fun bookA bookB ->
         String.compare bookA.title bookb.title)
     )
   end

   let books = Set.empty (module Book.ByTitle)

module Make (Comparable : T) : S with type t := Comparable.t

Create a new comparator by providing a module which satisifies T.

package reason-standard

Module Standard.Comparator

Module `Standard.Comparator`