FSharpx.Collections


MapTree Module

Types

Type Description

MapIterator<'Key, 'T>

Imperative left-to-right iterators.

Functions and values

Function or value Description

MapTree.MapOne (k, v)

Full Usage: MapTree.MapOne (k, v)

Parameters:
    k : 'a
    v : 'b

Returns: MapTree<'a, 'b>
k : 'a
v : 'b
Returns: MapTree<'a, 'b>

MapTree.add comparer k v m

Full Usage: MapTree.add comparer k v m

Parameters:
Returns: MapTree<'T, 'a>
comparer : IComparer<'T>
k : 'T
v : 'a
m : MapTree<'T, 'a>
Returns: MapTree<'T, 'a>

MapTree.containsKey comparer k m

Full Usage: MapTree.containsKey comparer k m

Parameters:
Returns: bool
comparer : IComparer<'T>
k : 'T
m : MapTree<'T, 'a>
Returns: bool

MapTree.copyToArray s arr i

Full Usage: MapTree.copyToArray s arr i

Parameters:
s : MapTree<'a, 'b>
arr : KeyValuePair<'a, 'b>[]
i : int

MapTree.count x

Full Usage: MapTree.count x

Parameters:
Returns: int
x : MapTree<'a, 'b>
Returns: int

MapTree.empty

Full Usage: MapTree.empty

Returns: MapTree<'a, 'b>
Returns: MapTree<'a, 'b>

MapTree.exists f m

Full Usage: MapTree.exists f m

Parameters:
    f : 'a -> 'b -> bool
    m : MapTree<'a, 'b>

Returns: bool
f : 'a -> 'b -> bool
m : MapTree<'a, 'b>
Returns: bool

MapTree.filter comparer f s

Full Usage: MapTree.filter comparer f s

Parameters:
Returns: MapTree<'T, 'a>
comparer : IComparer<'T>
f : 'T -> 'a -> bool
s : MapTree<'T, 'a>
Returns: MapTree<'T, 'a>

MapTree.filter1 comparer f k v acc

Full Usage: MapTree.filter1 comparer f k v acc

Parameters:
    comparer : IComparer<'T>
    f : 'T -> 'a -> bool
    k : 'T
    v : 'a
    acc : MapTree<'T, 'a>

Returns: MapTree<'T, 'a>
comparer : IComparer<'T>
f : 'T -> 'a -> bool
k : 'T
v : 'a
acc : MapTree<'T, 'a>
Returns: MapTree<'T, 'a>

MapTree.filterAux comparer f s acc

Full Usage: MapTree.filterAux comparer f s acc

Parameters:
Returns: MapTree<'T, 'a>
comparer : IComparer<'T>
f : 'T -> 'a -> bool
s : MapTree<'T, 'a>
acc : MapTree<'T, 'a>
Returns: MapTree<'T, 'a>

MapTree.find comparer k m

Full Usage: MapTree.find comparer k m

Parameters:
Returns: 'a
comparer : IComparer<'T>
k : 'T
m : MapTree<'T, 'a>
Returns: 'a

MapTree.first f m

Full Usage: MapTree.first f m

Parameters:
    f : 'a -> 'b -> 'c option
    m : MapTree<'a, 'b>

Returns: 'c option
f : 'a -> 'b -> 'c option
m : MapTree<'a, 'b>
Returns: 'c option

MapTree.fold f m x

Full Usage: MapTree.fold f m x

Parameters:
    f : 'a -> 'b -> 'c -> 'c
    m : MapTree<'a, 'b>
    x : 'c

Returns: 'c
f : 'a -> 'b -> 'c -> 'c
m : MapTree<'a, 'b>
x : 'c
Returns: 'c

MapTree.foldMap comparer f m z acc

Full Usage: MapTree.foldMap comparer f m z acc

Parameters:
Returns: MapTree<'T, 'c> * 'b
comparer : IComparer<'T>
f : 'T -> 'a -> 'b -> 'c * 'b
m : MapTree<'T, 'a>
z : 'b
acc : MapTree<'T, 'c>
Returns: MapTree<'T, 'c> * 'b

MapTree.foldSection comparer lo hi f m x

Full Usage: MapTree.foldSection comparer lo hi f m x

Parameters:
    comparer : IComparer<'T>
    lo : 'T
    hi : 'T
    f : 'T -> 'a -> 'b -> 'b
    m : MapTree<'T, 'a>
    x : 'b

Returns: 'b
comparer : IComparer<'T>
lo : 'T
hi : 'T
f : 'T -> 'a -> 'b -> 'b
m : MapTree<'T, 'a>
x : 'b
Returns: 'b

MapTree.forAll f m

Full Usage: MapTree.forAll f m

Parameters:
    f : 'a -> 'b -> bool
    m : MapTree<'a, 'b>

Returns: bool
f : 'a -> 'b -> bool
m : MapTree<'a, 'b>
Returns: bool

MapTree.height x

Full Usage: MapTree.height x

Parameters:
Returns: int
x : MapTree<'a, 'b>
Returns: int

MapTree.indexNotFound ()

Full Usage: MapTree.indexNotFound ()

Parameters:
    () : unit

Returns: 'a
() : unit
Returns: 'a

MapTree.isEmpty m

Full Usage: MapTree.isEmpty m

Parameters:
Returns: bool
m : MapTree<'a, 'b>
Returns: bool

MapTree.iter f m

Full Usage: MapTree.iter f m

Parameters:
    f : 'a -> 'b -> unit
    m : MapTree<'a, 'b>

f : 'a -> 'b -> unit
m : MapTree<'a, 'b>

MapTree.map f m

Full Usage: MapTree.map f m

Parameters:
Returns: MapTree<'c, 'b>
f : 'a -> 'b
m : MapTree<'c, 'a>
Returns: MapTree<'c, 'b>

MapTree.mapi f m

Full Usage: MapTree.mapi f m

Parameters:
    f : 'a -> 'b -> 'c
    m : MapTree<'a, 'b>

Returns: MapTree<'a, 'c>
f : 'a -> 'b -> 'c
m : MapTree<'a, 'b>
Returns: MapTree<'a, 'c>

MapTree.mk l k v r

Full Usage: MapTree.mk l k v r

Parameters:
Returns: MapTree<'a, 'b>
l : MapTree<'a, 'b>
k : 'a
v : 'b
r : MapTree<'a, 'b>
Returns: MapTree<'a, 'b>

MapTree.mkFromEnumerator comparer acc e

Full Usage: MapTree.mkFromEnumerator comparer acc e

Parameters:
Returns: MapTree<'a, 'b>
comparer : IComparer<'a>
acc : MapTree<'a, 'b>
e : IEnumerator<'a * 'b>
Returns: MapTree<'a, 'b>

MapTree.ofList comparer l

Full Usage: MapTree.ofList comparer l

Parameters:
    comparer : IComparer<'a>
    l : ('a * 'b) list

Returns: MapTree<'a, 'b>
comparer : IComparer<'a>
l : ('a * 'b) list
Returns: MapTree<'a, 'b>

MapTree.ofSeq comparer c

Full Usage: MapTree.ofSeq comparer c

Parameters:
Returns: MapTree<'a, 'b>
comparer : IComparer<'a>
c : seq<'a * 'b>
Returns: MapTree<'a, 'b>

MapTree.partition comparer f s

Full Usage: MapTree.partition comparer f s

Parameters:
Returns: MapTree<'T, 'a> * MapTree<'T, 'a>
comparer : IComparer<'T>
f : 'T -> 'a -> bool
s : MapTree<'T, 'a>
Returns: MapTree<'T, 'a> * MapTree<'T, 'a>

MapTree.partition1 comparer f k v (acc1, acc2)

Full Usage: MapTree.partition1 comparer f k v (acc1, acc2)

Parameters:
Returns: MapTree<'T, 'a> * MapTree<'T, 'a>
comparer : IComparer<'T>
f : 'T -> 'a -> bool
k : 'T
v : 'a
acc1 : MapTree<'T, 'a>
acc2 : MapTree<'T, 'a>
Returns: MapTree<'T, 'a> * MapTree<'T, 'a>

MapTree.partitionAux comparer f s (arg4, arg5)

Full Usage: MapTree.partitionAux comparer f s (arg4, arg5)

Parameters:
Returns: MapTree<'T, 'a> * MapTree<'T, 'a>
comparer : IComparer<'T>
f : 'T -> 'a -> bool
s : MapTree<'T, 'a>
arg3 : MapTree<'T, 'a>
arg4 : MapTree<'T, 'a>
Returns: MapTree<'T, 'a> * MapTree<'T, 'a>

MapTree.rebalance t1 k v t2

Full Usage: MapTree.rebalance t1 k v t2

Parameters:
Returns: MapTree<'a, 'b>
t1 : MapTree<'a, 'b>
k : 'a
v : 'b
t2 : MapTree<'a, 'b>
Returns: MapTree<'a, 'b>

MapTree.remove comparer k m

Full Usage: MapTree.remove comparer k m

Parameters:
Returns: MapTree<'T, 'a>
comparer : IComparer<'T>
k : 'T
m : MapTree<'T, 'a>
Returns: MapTree<'T, 'a>

MapTree.sizeAux acc m

Full Usage: MapTree.sizeAux acc m

Parameters:
Returns: int
acc : int
m : MapTree<'a, 'b>
Returns: int

MapTree.spliceOutSuccessor m

Full Usage: MapTree.spliceOutSuccessor m

Parameters:
Returns: 'a * 'b * MapTree<'a, 'b>
m : MapTree<'a, 'b>
Returns: 'a * 'b * MapTree<'a, 'b>

MapTree.toArray m

Full Usage: MapTree.toArray m

Parameters:
Returns: ('a * 'b)[]
m : MapTree<'a, 'b>
Returns: ('a * 'b)[]

MapTree.toList m

Full Usage: MapTree.toList m

Parameters:
Returns: ('a * 'b) list
m : MapTree<'a, 'b>
Returns: ('a * 'b) list

MapTree.toSeq s

Full Usage: MapTree.toSeq s

Parameters:
Returns: IEnumerator<KeyValuePair<'a, 'b>>
s : MapTree<'a, 'b>
Returns: IEnumerator<KeyValuePair<'a, 'b>>

MapTree.tryFind comparer k m

Full Usage: MapTree.tryFind comparer k m

Parameters:
Returns: 'a option
comparer : IComparer<'T>
k : 'T
m : MapTree<'T, 'a>
Returns: 'a option