Module type BatFingerTree.S

module type S = sig .. end

type ('a, 'm) fg 
The type of finger trees containing elements of type 'a measured by 'm.
type ('wrapped_type, 'a, 'm) wrap 
A type meant to avoid duplication of signatures.

For the generic finger tree, this type will be monoid:'m monoid -> measure:('a -> 'm) -> 'wrapped_type.

Once the finger tree has been specialized, the resulting module should be reexported in such a way that the type is now simply 'wrapped_type.


Construction

val empty : ('a, 'm) fg
empty is the sequence with no elements.
val singleton : 'a -> ('a, 'm) fg
singleton elt build the sequence containing elt as its sole element.

O(1).

val cons : (('a, 'm) fg -> 'a -> ('a, 'm) fg, 'a, 'm)
wrap
cons t elt adds elt to the left of t.

O(1) amortized, O(log(n)) worst case.

val snoc : (('a, 'm) fg -> 'a -> ('a, 'm) fg, 'a, 'm)
wrap
snoc t elt adds elt to the right of t.

O(1) amortized, O(log(n)) worst case.


Deconstruction

val front : (('a, 'm) fg -> (('a, 'm) fg * 'a) option,
'a, 'm)
wrap
front t returns None when t is empty, or Some (tl, hd) when hd is the first element of the sequence and tl is the rest of the sequence.

O(1) amortized, O(log(n)) worst case.

val front_exn : (('a, 'm) fg -> ('a, 'm) fg * 'a, 'a, 'm)
wrap
front_exn t returns (tl, hd) when hd is the first element of the sequence and tl is the rest of the sequence.
Raises Empty if t is empty.

O(1) amortized, O(log(n)) worst case.

val head : ('a, 'm) fg -> 'a option
head t returns None if t is empty, or Some hd otherwise, where hd is the first element of the sequence.

O(1).

val head_exn : ('a, 'm) fg -> 'a
head_exn t returns the first element of the sequence.
Raises Empty if t is empty.

O(1).

val last : ('a, 'm) fg -> 'a option
last t returns None if t is empty, or Some hd otherwise, where hd is the last element of the sequence.

O(1).

val last_exn : ('a, 'm) fg -> 'a
last_exn t returns the last element of the sequence.
Raises Empty if t is empty.

O(1).

val tail : (('a, 'm) fg -> ('a, 'm) fg option, 'a, 'm)
wrap
tail t returns None when t is empty, or Some tl where tl is the sequence t where the first element has been removed.

O(1) amortized, O(log(n)) worst case.

val tail_exn : (('a, 'm) fg -> ('a, 'm) fg, 'a, 'm)
wrap
tail_exn t returns the sequence t where the first element has been removed.
Raises Empty if t is empty.

O(1) amortized, O(log(n)) worst case.

val init : (('a, 'm) fg -> ('a, 'm) fg option, 'a, 'm)
wrap
init t returns None if t is empty, or Some init where init is the sequence t where the last element has been removed.

O(1) amortized, O(log(n)) worst case.

val init_exn : (('a, 'm) fg -> ('a, 'm) fg, 'a, 'm)
wrap
init_exn t returns the sequence t where the last element has been removed.
Raises Empty if t is empty.

O(1) amortized, O(log(n)) worst case.

val rear : (('a, 'm) fg -> (('a, 'm) fg * 'a) option,
'a, 'm)
wrap
rear t returns None when t is empty, or Some (init, last) where last is the last element of the sequence and init is the rest of the sequence.

O(1) amortized, O(log(n)) worst case.

val rear_exn : (('a, 'm) fg -> ('a, 'm) fg * 'a, 'a, 'm)
wrap
rear t returns (init, last) when last is the last element of the sequence and init is the rest of the sequence.
Raises Empty if t is empty.

O(1) amortized, O(log(n)) worst case.


Inspection

val size : ('a, 'm) fg -> int
size t returns the number of elements in the sequence. If you want to know that a sequence is empty, it is much better to use BatFingerTree.S.is_empty.

O(n).

val is_empty : ('a, 'm) fg -> bool
is_empty t returns true when the sequence has no elements.

O(1).

val fold_left : ('acc -> 'a -> 'acc) -> 'acc -> ('a, 'm) fg -> 'acc
fold_left is equivalent to List.fold_left.

O(n).

val fold_right : ('acc -> 'a -> 'acc) -> 'acc -> ('a, 'm) fg -> 'acc
fold_right is equivalent to List.fold_right.

O(n).

val iter : ('a -> unit) -> ('a, 'm) fg -> unit
iter is equivalent to List.iter.

O(n).

val iter_right : ('a -> unit) -> ('a, 'm) fg -> unit
iter_right is equivalent to List.iter o List.rev.

O(n).

val compare : ('a -> 'a -> int) ->
('a, 'm) fg -> ('a, 'm) fg -> int
compare cmp t1 t2 compares the two sequences lexicographically.

O(n).

val equal : ('a -> 'a -> bool) ->
('a, 'm) fg -> ('a, 'm) fg -> bool
equal eq t1 t2 returns true when the two sequences contain the the same elements.

O(n).


Conversions


Conversions to other structures

val enum : ('a, 'm) fg -> 'a BatEnum.t
enum t builds an enumeration of the elements of t going from left to right.

O(1).

Forcing the whole enumeration takes O(n).

val backwards : ('a, 'm) fg -> 'a BatEnum.t
backwards t builds an enumeration of the elements of t going from right to left. Same complexity as BatFingerTree.S.enum.
val to_list : ('a, 'm) fg -> 'a list
to_list t is equivalent to BatList.of_enum (enum t).

O(n).

val to_list_backwards : ('a, 'm) fg -> 'a list
to_list_backwards t is equivalent to BatList.of_enum (backwards t).

O(n).


Conversions from other structures

val of_enum : ('a BatEnum.t -> ('a, 'm) fg, 'a, 'm) wrap
of_enum e build the sequence containing the elements of e in the same order.

Its complexity is the complexity of forcing the enumeration.

val of_backwards : ('a BatEnum.t -> ('a, 'm) fg, 'a, 'm) wrap
of_backward e is equivalent to reverse (of_enum e).

O(n).

val of_list : ('a list -> ('a, 'm) fg, 'a, 'm) wrap
of_list l is equivalent to of_enum (BatList.enum l).

O(n).

val of_list_backwards : ('a list -> ('a, 'm) fg, 'a, 'm) wrap
of_list_backwards l is equivalent to of_enum_backwards (BatList.enum l).

O(n).


Combining/reorganizing

val map : (('a -> 'b) -> ('a, 'm) fg -> ('b, 'm) fg,
'b, 'm)
wrap
map is equivalent to List.map.

O(n).

val map_right : (('a -> 'b) -> ('a, 'm) fg -> ('b, 'm) fg,
'b, 'm)
wrap
map_right is equivalent to List.rev o List.map o List.rev.

O(n).

val append : (('a, 'm) fg ->
('a, 'm) fg -> ('a, 'm) fg, 'a, 'm)
wrap
append is equivalent to List.append.

O(log(min(n,m))).

val reverse : (('a, 'm) fg -> ('a, 'm) fg, 'a, 'm)
wrap
reverse t is equivalent to of_list (List.rev (to_list t)).

O(n).


Boilerplate code

val print : ?first:string ->
?last:string ->
?sep:string ->
('a, 'b) BatIO.printer -> (('a, 'c) fg, 'b) BatIO.printer