This is documentation for version v0.9.0 of patricia-tree, but the latest version is v0.10.0.
Click here to redirect to the latest version.

Patricia Tree API - NODE

We use a uniform type 'map view to pattern match on maps and sets The actual types 'map t can be a bit different from 'map view to allow for more efficient representations, but view should be a constant time operation for quick conversions.

Types

type 'a key = Key.t

The type of keys.

type ('key, 'map) value = ('key, 'map) snd

The type of value, which depends on the type of the key and the type of the map.

type 'map t

The type of the map, which is parameterized by a type.

Constructors: build values

val empty : 'map t

The empty map

val leaf : 'key key -> ('key, 'map) value -> 'map t

A singleton leaf, similar to BASE_MAP.singleton

val branch : prefix:intkey -> branching_bit:mask -> tree0:'map t -> tree1:'map t -> 'map t

A branch node. This shouldn't be called externally unless you know what you're doing! Doing so could easily break the data structure's invariants.

When called, it assumes that:

• Neither tree0 nor tree1 should be empty.
• branching_bit should have a single bit set
• prefix should be normalized (bits below branching_bit set to zero)
• All elements of tree0 should have their to_int start by prefix followed by 0 at position branching_bit).
• All elements of tree1 should have their to_int start by prefix followed by 0 at position branching_bit).

Destructors: access the value

type 'map view = private

1. | Empty : 'map view
   (*

   Can happen only at the toplevel: there is no empty interior node.

   *)
2. | Branch : {
   1. prefix : intkey;
   2. branching_bit : mask;
   3. tree0 : 'map t;
   4. tree1 : 'map t;
   } -> 'map view
   (*

   Branching bit contains only one bit set; the corresponding mask is (branching_bit - 1). The prefixes are normalized: the bits below the branching bit are set to zero (i.e. prefix & (branching_bit - 1) = 0).

   *)
3. | Leaf : {
   1. key : 'key key;
   2. value : ('key, 'map) value;
   } -> 'map view
   (*

   A key -> value mapping.

   *)

This makes the map nodes accessible to the pattern matching algorithm; this corresponds 1:1 to the SimpleNode implementation. This just needs to be copy-and-pasted for every node type.

val is_empty : 'map t -> bool

Check if the map is empty. Should be constant time.

val view : 'a t -> 'a view

Convert the map to a view. Should be constant time.