Index of values

add x t Return the set t with the element x.

append t1 t2 Appends the list t2 onto the back of list t1.

append t1 t2 Appends all of the elements in queue t2 onto the back of t1.

append t1 t2 Append the list t2 onto the back of t1.

append t1 t2 Appends the list t2 onto the back of list t1.

append t1 t2 Append the list t2 onto the end of list t1.

at_front t Retruns true if there are no elements to the right of t.

at_end curs Returns true if there are no elements to the right of curs.

Returns true if the iterator is at the beginning of the collection as governed by the current traversal strategy.

Returns true if the iterator has reached the end of the collection as governed by the current traversal strategy.

at_front t Retruns true if there are no elements to the left of t.

at_front curs Returns true if there are no elements to the left of curs.

Returns true if the cursor is at the left most element in the current subtree.

Returns true if the cursor is at the right most element in the current subtree.

Returns true if the cursor is at the top of the tree.

Returns the number of elements in the set.

Choose an arbitrary element from the set.

compare f t1 t2 Compares the lists t1 and t2 using f to compare individual elements.

compare f t1 t2 Compares the lists t1 and t2 using f to compare individual elements.

compare f t1 t2 Compares the queues t1 and t2 using f to compare individual elements.

compare f t1 t2 Compares the lists t1 and t2 using f to compare individual elements.

compare f t1 t2 Compares the lists t1 and t2 using f to compare individual elements.

compare t1 t2 Compares the sets t1 and t2 and returns 0 if they are equal.

compare f t1 t2 Compares the lists t1 and t2 using f to compare individual elements.

cons x t Adds the element x to the front of the list t.

cons x t Adds x onto the front of the list t.

cons x t Adds x to the front of queue t so that a subsequent call to hd returns x.

cons x t Adds x as the first element to the right of t.

cons x t Adds x onto the front of the list t.

cons x t Add the element x to the front of list t

cons_back x t Adds x to the back of queue t so that a subsequent call to hd_back returns x.

create dir trav col Create an iterator for the collection col using the direction and traversal given.

dequeue x t is an alias for Reins.DoubleQueue.hd x t, removing the first element from the front of t.

Description of the test.

A copy of the test description supplied by the Law module

diff t1 t2 Returns a set containing only the elements contained in t1 and not t2

The empty list

The empty list.

The empty queue

The empty list

The empty list

The empty set

The empty list

enqueue x t is an alias for Reins.DoubleQueue.cons_back x t, adding x to the back of t.

equal t1 t2 Returns true if t1 and t2 contain the same elements.

flatten t Appends all of the elements of t into a new list.

flatten l Appends all of the elements of l into a new queue.

flatten l Appends all of the elements of l into a new list.

flatten l Appends all of the elements of l into a new list.

Flatten a list of lists into a single list

Reverse the direction of the iterator.

fold f acc t Accumulates the result acc by applying f acc x for each element x in t.

fold f acc l Equivalent to fold_left f acc l

fold f acc t Accumulates the result acc by applying f acc x for each element x in t.

fold f acc t Accumulates the result acc by applying f acc x for each element x in t.

fold f acc t Accumulates the result acc by applying f acc x for each element x in t.

fold f acc t Accumulates the result acc by applying f acc x for each element x in t.

fold f acc t Accumulates the result acc by applying f acc x for each element x in t.

fold f acc t Accumulates the result acc by applying f acc x for each element x in the collection that satisfies the traversal strategy.

Return the tree pointed to by the cursor.

from_cursor curs Return the list that is pointed to by curs.

from_cursor dir trav curs Create an iterator for the collection starting at the cursor curs.

from_list l Convert the standard list l into a SkewBinaryList.

from_list t Included for compatibility with the common ListSig signature.

from_list l Convert the standard list l into a DoubleQueue.t.

from_list l Convert the standard list l into a DList.t.

from_list l Convert the standard list l into a CatenableList.

Create a list from a builtin list type

gen f ?size rs Generates a random list whose length is bounded by size.

gen f ?size rs Generates a random list whose length is bounded by size.

gen f ?size rs Generates a random queue whose length is bounded by size.

gen f ?size rs Generates a random list whose length is bounded by size.

gen f ?size rs Generates a random list whose length is bounded by size.

gen f ?size rs Generates a random list whose length is bounded by size.

gen1 f ?size rs Generates a random set whose size is bounded by size.

Extracts the value from the current node.

Similar to Reins.Iterator.S.value except it throws the exception Failure "get_value" if the iterator has reached the end of the collection .

goto_back curs Moves the cursor to the back of the list.

Advance the iterator to the beginning of the collection as governed by the traversal strategy

Advance the iterator to the end of the collection as governed by the traversal strategy

goto_front curs Moves the cursor to the front of the list.

Returns true if there is another element in the traversal after the current element.

Returns true if there is another element that occurs before the current element.

Returns true if the cursor points to a node that contains a value.

hd t Returns the element at the front of the list t.

hd q Return the element at the front of the queue.

hd t Returns the element to the immediate right of t.

hd t Return the element at the front of the list.

hd t Return the first element at the front of the list.

hd_back q Return the element at the back of the queue.

inter t1 t2 Returns a set containing only the elements contained in both t1 and t2

Returns tree if the list is emtpy.

Returns true if the list is empty

Returns true is the queue is empty

Returns true if the list is empty.

returns true if the list is empty

Returns true if the set is empty

Returns true if the list is empty

iter f t Iterates over each element in the list t in order and applies f to that element.

iter f t Iterates over each element in the queue t in order and applies f to that element.

iter f t Iterates over each element in the list t and applies f to that element.

iter f t Iterates over each element in the list t in order and applies f to that element.

iter f t Apply f to each element in list t.

iter f t Apply f to each element in list t.

iter f t Apply f to each element in the collection that satisfies the traversal strategy.

last t Returns the element at the back of the list.

last t Returns the element at the back of the list.

last q is an alias for hd_back q

last t Returns the last element the right of t.

last t Returns the element at the back of the list.

last t Returns the element at the back of the list.

The function that implements the law.

length t returns the lenth of the list t.

length t Returns the number of elements in the queue t

length t Returns the length of the entire list.

length t Returns the length of the list t.

Returns the length of the list

list curs Returns all of the elements to the right of curs as a 'a list_.

lookup i t Returns the element at position i (O-indexed) in the list t.

map f t Creates a new list by applying f to each element of t.

map f t Creates a new queue by applying f to each element of t.

map f t Creates a new list by applying f to each element of t.

map f t Creates a new list by applying f to each element of t.

map f t Creates a new list by applying f to each element of t.

Return the largest element in the set.

This value determines how many inputs are allowed to be classified as trivial before giving up and classifying the law as failed.

mem x t Returns true if x is contained in the set t.

Return the smallest element in the set.

Move the cursor down the tree to the left child.

Move the cursor down the tree to the right child.

move_left curs Moves the cursor one element to the left.

move_right curs Moves the cursor one element to the right.

Move the cursor up the tree from a sibling to a parent.

next t Advance t to the next element in the list.

Advances the iterator to the next element in the collection.

next_length t Returns the number of elements to the right of t.

This value determines how many inputs will be passed to the Reins.Quickcheck.Law.law function.

Returns the result part of a result_ value.

pop t Equivalent to (hd t), (tl t) but is more efficient.

pop t equivalent to (hd t), (tl t) but is more efficient.

pop t Equivalent to (hd t), (tl t) but is more efficient.

pop t Equivalent to (hd t), (tl t) but is slightly more efficient.

pop t Equivalent to (hd t), (tl t) but is more efficient.

Returns both the first element of the list and the remaining tail of the list.

pop_back t Equivalent to (hd_back t), (tl_back t) but is more efficient.

prev t Advance t to the previous element in the list.

Advances the iterator to the previous element in the collection.

prev_cons x t Adds x as the first element to the left of t.

prev_hd t Returns the element to the left of t.

prev_length t Returns the number of elements in front of t.

prev_pop t Equivalent to (prev_hd t), (prev_tl t) but is slightly more efficient.

snoc x t Adds x as the last element to the left of t t (i.e., the first element in the entire list).

prev_tl t Return the list with the first element to the left of t removed.

remove x t Return the set t with the element x removed.

replace_list l curs Replaces the list of elements to the right of curs with l.

rev t Reverse the list t.

rev t Reverses the order of the queue t.

rev t Reverse the list t.

rev t Returns the list t in reversed order.

Reverse the list

rev_map f t Creates a new list by applying f to each element of t.

rev_map f t Creates a new queue by applying f to each element of t.

rev_map f t Creates a new list by applying f to each element of t.

rev_map f t Creates a new list by applying f to each element of t.

rev_map f t Creates a new list by applying f to each element of t.

singleton x Return the set consisting of only the element x

This value is passed as the option size paramter to the function Reins.Types.Mono.Arbitrary.gen when generating input for a law.

snoc x t Adds the element x to the back of the list t.

snoc x t Adds the element x to the back of the list t.

snoc x t is an alias for Reins.DoubleQueue.cons_back x t, adding x to the back of t.

snoc x t Adds x as the last element to the right of t (i.e., the last element in the entire list).

snoc t x Adds x onto the back of the list t.

snoc x t Add the element x to the end of list t

splice t1 t2 Splices the elements of t1 into t2.

The function which executes the series random tests on law L

tl t Returns the list t with the first element removed.

tl t Return the queue t with the element at the front of the queue removed.

tl t Return the list with the first element to the right of t removed.

tl t Return the tail of the list (the list with the first element removed).

tl t Return the list with the first element removed.

tl t Return the queue t with the element at the back of the queue removed.

Create a cursor from a tree.

to_cursor t Create a cursor that points to the beginning of list t.

to_list t Convert the SkewBinaryList t into a standard list.

to_list t Included for compatibility with the common ListSig signature.

to_list t Convert the DoubleQueue t into a standard list.

to_list t Convert the DList t into a standard list.

to_list t Convert the CatenableList t into a standard list.

Convert the list into a builtin list type

to_string to_s t Convert the list t into a string using to_s to individually convert each element into a string.

to_string to_s t Convert the list t into a string using to_s to individually convert each element into a string.

to_string to_s t Convert the queue t into a string using to_s to individually convert each element into a string.

to_string to_s t Convert the list t into a string using to_s to individually convert each element into a string.

to_string to_s t Convert the list t into a string using to_s to individually convert each element into a string.

to_string to_s t Convert the list t into a string using to_s to individually convert each element into a string.

union t1 t2 Returns a set containing all of the elements in t1 and t2

update i v t Returns a new list where the element in position i (0-indexed) has been replaced by v.

If the cursor currently points to an element x, return that element as Some x, otherwise return None.

Return the element currently pointed to by the iterator.

Current version of the Reins library

A predicate to test if the set is well-formed.

Returns true if the cursor points to an element that is the left sibling of its parent.

Returns true if the cursor points to an element that is the right sibling of its parent.