module Index: `sig`

.. `end`

Fast data structures using natural number indexing.

The implementations use `Vec`

as the underlying
representation. This allows us to perform most operations in
constant time but also requires that the type being used have an
indexing function that assigns unique natural number indices to
its elements.

module type IndexedType = `sig`

.. `end`

Signature for types with natural number indexing.

## Map

module type Map = `sig`

.. `end`

Signature of maps over indexed types.

module Make_map:

Functor building an implementation of maps overs indices.

module Nat_map: `Map`

` with type key = int`

A map for natural numbers.

## Map2

module type Map2 = `sig`

.. `end`

Signature of two argument maps where the first argument is an
indexed type.

module Nat_map2:

A two argument map where the first key is a natural number and the
second is a hashed type.

module Make_map2:

A two argument map where the first key is an indexed type and the
second is a hashed type.

## Set

module type Set = `sig`

.. `end`

Signature of sets over indexed types.

module Make_set:

Functor building an implementation of sets over indices.

module Nat_set: `Set`

` with type elt = int`

A set implementation for natural numbers.

module Make_hashed_set:

Functor building an implementation of sets over hashable elements.

## Priority Queue

module type PriorityQueue = `sig`

.. `end`

Signature of priority queues over indexed types.

module Make_priority_queue:

Functor building an implementation of priority queues for indexed types.

module Nat_priority_queue: `PriorityQueue`

` with type elt = int`

An implementation of priority queue with natural number elements.

Hosted by the
^{*} web site.

^{*}Other names and brands may be claimed as the property
of others.