Logo fantomas

NameMap Module

Namespace: Internal.Utilities.Library
Assembly: Fantomas.FCS.dll

Functions and values

Function or value Description

add v x m

Full Usage: add v x m

Parameters:
    v : string
    x : 'T
    m : NameMap<'T>

Returns: Map<string, 'T>
Type parameters: 'T
v : string
x : 'T
m : NameMap<'T>
Returns: Map<string, 'T>

empty

Full Usage: empty

Returns: Map<'a, 'b>
Type parameters: 'a, 'b (requires comparison)
Returns: Map<'a, 'b>

exists f m

Full Usage: exists f m

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

Returns: bool
Type parameters: 'a, 'b (requires comparison)
f : 'a -> 'b -> bool
m : Map<'a, 'b>
Returns: bool

existsInRange p m

Full Usage: existsInRange p m

Parameters:
    p : 'a -> bool
    m : Map<'b, 'a>

Returns: bool
Type parameters: 'a, 'b (requires comparison)
p : 'a -> bool
m : Map<'b, 'a>
Returns: bool

filterRange f l

Full Usage: filterRange f l

Parameters:
Returns: Map<string, 'T>
Type parameters: 'T
f : 'T -> bool
l : NameMap<'T>
Returns: Map<string, 'T>

find v m

Full Usage: find v m

Parameters:
Returns: 'T
Type parameters: 'T
v : string
m : NameMap<'T>
Returns: 'T

foldBack f m z

Full Usage: foldBack f m z

Parameters:
    f : string -> 'T -> 'a -> 'a
    m : NameMap<'T>
    z : 'a

Returns: 'a
Type parameters: 'T, 'a
f : string -> 'T -> 'a -> 'a
m : NameMap<'T>
z : 'a
Returns: 'a

foldBackRange f l acc

Full Usage: foldBackRange f l acc

Parameters:
    f : 'T -> 'a -> 'a
    l : NameMap<'T>
    acc : 'a

Returns: 'a
Type parameters: 'T, 'a
f : 'T -> 'a -> 'a
l : NameMap<'T>
acc : 'a
Returns: 'a

forall f m

Full Usage: forall f m

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

Returns: bool
Type parameters: 'a, 'b (requires comparison)
f : 'a -> 'b -> bool
m : Map<'a, 'b>
Returns: bool

isEmpty m

Full Usage: isEmpty m

Parameters:
Returns: bool
Type parameters: 'T
m : NameMap<'T>
Returns: bool

iter f l

Full Usage: iter f l

Parameters:
Type parameters: 'T
f : 'T -> unit
l : NameMap<'T>

layer m1 m2

Full Usage: layer m1 m2

Parameters:
Returns: Map<string, 'T>
Type parameters: 'T
m1 : NameMap<'T>
m2 : Map<string, 'T>
Returns: Map<string, 'T>

layerAdditive addf m1 m2

Full Usage: layerAdditive addf m1 m2

Parameters:
    addf : 'a list -> 'b -> 'a list
    m1 : Map<'c, 'b>
    m2 : Map<'c, 'a list>

Returns: Map<'c, 'a list>
Type parameters: 'a, 'b, 'c (requires comparison)

Not a very useful function - only called in one place - should be changed

addf : 'a list -> 'b -> 'a list
m1 : Map<'c, 'b>
m2 : Map<'c, 'a list>
Returns: Map<'c, 'a list>

map f l

Full Usage: map f l

Parameters:
Returns: Map<string, 'a>
Type parameters: 'T, 'a
f : 'T -> 'a
l : NameMap<'T>
Returns: Map<string, 'a>

mapFilter f l

Full Usage: mapFilter f l

Parameters:
    f : 'T -> 'a option
    l : NameMap<'T>

Returns: Map<string, 'a>
Type parameters: 'T, 'a
f : 'T -> 'a option
l : NameMap<'T>
Returns: Map<string, 'a>

mapFold f s l

Full Usage: mapFold f s l

Parameters:
    f : 'a -> string -> 'T -> 'b * 'a
    s : 'a
    l : NameMap<'T>

Returns: Map<string, 'b> * 'a
Type parameters: 'a, 'T, 'b
f : 'a -> string -> 'T -> 'b * 'a
s : 'a
l : NameMap<'T>
Returns: Map<string, 'b> * 'a

mem v m

Full Usage: mem v m

Parameters:
Returns: bool
Type parameters: 'T
v : string
m : NameMap<'T>
Returns: bool

ofKeyedList f l

Full Usage: ofKeyedList f l

Parameters:
    f : 'a -> 'b
    l : 'a list

Returns: Map<'b, 'a>
Type parameters: 'a, 'b (requires comparison)
f : 'a -> 'b
l : 'a list
Returns: Map<'b, 'a>

ofList l

Full Usage: ofList l

Parameters:
    l : (string * 'T) list

Returns: NameMap<'T>
Type parameters: 'T
l : (string * 'T) list
Returns: NameMap<'T>

ofSeq l

Full Usage: ofSeq l

Parameters:
    l : (string * 'T) seq

Returns: NameMap<'T>
Type parameters: 'T
l : (string * 'T) seq
Returns: NameMap<'T>

partition f l

Full Usage: partition f l

Parameters:
Returns: Map<string, 'T> * Map<string, 'T>
Type parameters: 'T
f : 'T -> bool
l : NameMap<'T>
Returns: Map<string, 'T> * Map<string, 'T>

range m

Full Usage: range m

Parameters:
    m : Map<'a, 'b>

Returns: 'b list
Type parameters: 'a, 'b (requires comparison)
m : Map<'a, 'b>
Returns: 'b list

suball2 errf p m1 m2

Full Usage: suball2 errf p m1 m2

Parameters:
    errf : 'a -> 'b -> bool
    p : 'c -> 'b -> bool
    m1 : Map<'a, 'c>
    m2 : Map<'a, 'b>

Returns: bool
Type parameters: 'a, 'b, 'c (requires comparison)
errf : 'a -> 'b -> bool
p : 'c -> 'b -> bool
m1 : Map<'a, 'c>
m2 : Map<'a, 'b>
Returns: bool

subfold2 errf f m1 m2 acc

Full Usage: subfold2 errf f m1 m2 acc

Parameters:
    errf : 'a -> 'b -> 'c
    f : 'a -> 'd -> 'b -> 'c -> 'c
    m1 : Map<'a, 'd>
    m2 : Map<'a, 'b>
    acc : 'c

Returns: 'c
Type parameters: 'a, 'b, 'c, 'd (requires comparison)

For every entry in m2 find an entry in m1 and fold

errf : 'a -> 'b -> 'c
f : 'a -> 'd -> 'b -> 'c -> 'c
m1 : Map<'a, 'd>
m2 : Map<'a, 'b>
acc : 'c
Returns: 'c

toList l

Full Usage: toList l

Parameters:
Returns: (string * 'T) list
Type parameters: 'T
l : NameMap<'T>
Returns: (string * 'T) list

tryFind v m

Full Usage: tryFind v m

Parameters:
Returns: 'T option
Type parameters: 'T
v : string
m : NameMap<'T>
Returns: 'T option

tryFindInRange p m

Full Usage: tryFindInRange p m

Parameters:
    p : 'a -> bool
    m : Map<'b, 'a>

Returns: 'a option
Type parameters: 'a, 'b (requires comparison)
p : 'a -> bool
m : Map<'b, 'a>
Returns: 'a option

union unionf ms

Full Usage: union unionf ms

Parameters:
    unionf : 'a seq -> 'b
    ms : NameMap<'a> seq

Returns: Map<string, 'b>
Type parameters: 'a, 'b

Union entries by identical key, using the provided function to union sets of values

unionf : 'a seq -> 'b
ms : NameMap<'a> seq
Returns: Map<string, 'b>

Type something to start searching.