FSharpPlus


Map Type

Static members

Static member Description

Map.Invoke(mapping) (source)

Full Usage: Map.Invoke(mapping) (source)

Parameters:
    mapping : 'T -> 'U
    source : ^Functor<'T>

Returns: ^Functor<'U>
Modifiers: inline
Type parameters: 'T, 'U, ^Functor<'T>, ^Functor<'U>
mapping : 'T -> 'U
source : ^Functor<'T>
Returns: ^Functor<'U>

Map.InvokeOnInstance(mapping) (source)

Full Usage: Map.InvokeOnInstance(mapping) (source)

Parameters:
    mapping : 'T -> 'U
    source : ^Functor<'T>

Returns: 'Functor<'U>
Modifiers: inline
Type parameters: 'T, 'U, ^Functor<'T>, 'Functor<'U>
mapping : 'T -> 'U
source : ^Functor<'T>
Returns: 'Functor<'U>

Map.Map(arg1, ?_mthd)

Full Usage: Map.Map(arg1, ?_mthd)

Parameters:
    arg0 : ^Profunctor<'B,'C> * ('C -> 'D)
    ?_mthd : Default5

Returns: 'Profunctor<'B,'D>
Modifiers: inline
arg0 : ^Profunctor<'B,'C> * ('C -> 'D)
?_mthd : Default5
Returns: 'Profunctor<'B,'D>

Map.Map(arg1, ?_mthd)

Full Usage: Map.Map(arg1, ?_mthd)

Parameters:
    arg0 : ^Bifunctor<'T,'V> * ('V -> 'W)
    ?_mthd : Default6

Returns: 'b
Modifiers: inline
arg0 : ^Bifunctor<'T,'V> * ('V -> 'W)
?_mthd : Default6
Returns: 'b

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
Modifiers: inline
arg0 : ^t * 'a
_mthd : Default1

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
    arg0 : ^Functor<'T> * ('T -> 'U)
    _mthd : Default1

Returns: 'Functor<'U>
Modifiers: inline
Type parameters: ^Functor<'T>, 'T, 'U, 'Functor<'U>
arg0 : ^Functor<'T> * ('T -> 'U)
_mthd : Default1
Returns: 'Functor<'U>

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
Returns: IReadOnlyCollection<'U>
arg0 : IReadOnlyCollection<'T> * ('T -> 'U)
_mthd : Default1
Returns: IReadOnlyCollection<'U>

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
Returns: Nullable<'U>
arg0 : Nullable<'T> * ('T -> 'U)
_mthd : Default2
Returns: Nullable<'U>

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
Returns: IObservable<'U>
arg0 : IObservable<'T> * ('T -> 'U)
_mthd : Default2
Returns: IObservable<'U>

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
Returns: IReadOnlyDictionary<'Key, 'U>
arg0 : IReadOnlyDictionary<'Key, 'T> * ('T -> 'U)
_mthd : Default2
Returns: IReadOnlyDictionary<'Key, 'U>

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
Returns: IDictionary<'Key, 'U>
arg0 : IDictionary<'Key, 'T> * ('T -> 'U)
_mthd : Default2
Returns: IDictionary<'Key, 'U>

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
Returns: IEnumerator<'U>
arg0 : IEnumerator<'T> * ('T -> 'U)
_mthd : Default2
Returns: IEnumerator<'U>

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
Returns: NonEmptySeq<'U>
arg0 : NonEmptySeq<'T> * ('T -> 'U)
_mthd : Default2
Returns: NonEmptySeq<'U>

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
    arg0 : 'T seq * ('T -> 'U)
    _mthd : Default2

Returns: 'U seq
arg0 : 'T seq * ('T -> 'U)
_mthd : Default2
Returns: 'U seq

Map.Map(arg1, ?_mthd)

Full Usage: Map.Map(arg1, ?_mthd)

Parameters:
    arg0 : ^Applicative<'T> * ('T -> 'U)
    ?_mthd : Default3

Returns: ^Applicative<'U>
Modifiers: inline
Type parameters: ^Applicative<'T>, ^Applicative<'T->'U>, 'T, 'U, ^Applicative<'U>
arg0 : ^Applicative<'T> * ('T -> 'U)
?_mthd : Default3
Returns: ^Applicative<'U>

Map.Map(arg1, ?_mthd)

Full Usage: Map.Map(arg1, ?_mthd)

Parameters:
    arg0 : ^Monad<'T> * ('T -> 'U)
    ?_mthd : Default4

Returns: ^Monad<'U>
Modifiers: inline
Type parameters: ^Monad<'T>, 'T, ^Monad<'U>, 'U
arg0 : ^Monad<'T> * ('T -> 'U)
?_mthd : Default4
Returns: ^Monad<'U>

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
    arg0 : Set2<'T> * ('T -> 'U)
    _mthd : Map

Returns: Set2<'U>
arg0 : Set2<'T> * ('T -> 'U)
_mthd : Map
Returns: Set2<'U>

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
    arg0 : Set<'a> * ('a -> 'b)
    _mthd : Map

Returns: Set<'b>
arg0 : Set<'a> * ('a -> 'b)
_mthd : Map
Returns: Set<'b>

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
Returns: StringBuilder
arg0 : StringBuilder * (char -> char)
_mthd : Map
Returns: StringBuilder

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
    arg0 : string * (char -> char)
    _mthd : Map

Returns: string
arg0 : string * (char -> char)
_mthd : Map
Returns: string

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
    arg0 : ResizeArray<'T> * ('T -> 'U)
    _mthd : Map

Returns: ResizeArray<'U>
arg0 : ResizeArray<'T> * ('T -> 'U)
_mthd : Map
Returns: ResizeArray<'U>

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
    arg0 : Expr<'T> * ('T -> 'U)
    _mthd : Map

Returns: Expr<'U>
arg0 : Expr<'T> * ('T -> 'U)
_mthd : Map
Returns: Expr<'U>

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
Returns: Dictionary<'Key, 'U>
arg0 : Dictionary<'Key, 'T> * ('T -> 'U)
_mthd : Map
Returns: Dictionary<'Key, 'U>

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
    arg0 : Map<'Key, 'T> * ('T -> 'U)
    _mthd : Map

Returns: Map<'Key, 'U>
arg0 : Map<'Key, 'T> * ('T -> 'U)
_mthd : Map
Returns: Map<'Key, 'U>

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
Returns: KeyValuePair2<'a, 'U>
arg0 : KeyValuePair2<'a, 'T> * ('T -> 'U)
_mthd : Map
Returns: KeyValuePair2<'a, 'U>

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
Returns: KeyValuePair<'a, 'U>
arg0 : KeyValuePair<'a, 'T> * ('T -> 'U)
_mthd : Map
Returns: KeyValuePair<'a, 'U>

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
    arg0 : Choice<'T, 'E> * ('T -> 'U)
    _mthd : Map

Returns: Choice<'U, 'E>
arg0 : Choice<'T, 'E> * ('T -> 'U)
_mthd : Map
Returns: Choice<'U, 'E>

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
    arg0 : Result<'T, 'E> * ('T -> 'U)
    _mthd : Map

Returns: Result<'U, 'E>
arg0 : Result<'T, 'E> * ('T -> 'U)
_mthd : Map
Returns: Result<'U, 'E>

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
    arg0 : Async<'T> * ('T -> 'U)
    _mthd : Map

Returns: Async<'U>
arg0 : Async<'T> * ('T -> 'U)
_mthd : Map
Returns: Async<'U>

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
    arg0 : 'T[,,,] * ('T -> 'U)
    _mthd : Map

Returns: 'U[,,,]
arg0 : 'T[,,,] * ('T -> 'U)
_mthd : Map
Returns: 'U[,,,]

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
    arg0 : 'T[,,] * ('T -> 'U)
    _mthd : Map

Returns: 'U[,,]
arg0 : 'T[,,] * ('T -> 'U)
_mthd : Map
Returns: 'U[,,]

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
    arg0 : 'T[,] * ('T -> 'U)
    _mthd : Map

Returns: 'U[,]
arg0 : 'T[,] * ('T -> 'U)
_mthd : Map
Returns: 'U[,]

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
    arg0 : 'T[] * ('T -> 'U)
    _mthd : Map

Returns: 'U[]
arg0 : 'T[] * ('T -> 'U)
_mthd : Map
Returns: 'U[]

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
    arg0 : ('Monoid * 'T) * ('T -> 'U)
    _mthd : Map

Returns: 'Monoid * 'U
arg0 : ('Monoid * 'T) * ('T -> 'U)
_mthd : Map
Returns: 'Monoid * 'U

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
    arg0 : ('Monoid * 'T) * ('T -> 'U)
    _mthd : Map

Returns: 'Monoid * 'U
arg0 : ('Monoid * 'T) * ('T -> 'U)
_mthd : Map
Returns: 'Monoid * 'U

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
    arg0 : Func<'R, 'T> * ('T -> 'U)
    _mthd : Map

Returns: Func<'R, 'U>
arg0 : Func<'R, 'T> * ('T -> 'U)
_mthd : Map
Returns: Func<'R, 'U>

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
    arg0 : ('R -> 'T) * ('T -> 'U)
    _mthd : Map

Returns: 'R -> 'U
arg0 : ('R -> 'T) * ('T -> 'U)
_mthd : Map
Returns: 'R -> 'U

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
    arg0 : 'T list * ('T -> 'U)
    _mthd : Map

Returns: 'U list
arg0 : 'T list * ('T -> 'U)
_mthd : Map
Returns: 'U list

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
    arg0 : 'T voption * ('T -> 'U)
    _mthd : Map

Returns: 'U voption
arg0 : 'T voption * ('T -> 'U)
_mthd : Map
Returns: 'U voption

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
    arg0 : 'T option * ('T -> 'U)
    _mthd : Map

Returns: 'U option
arg0 : 'T option * ('T -> 'U)
_mthd : Map
Returns: 'U option

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
    arg0 : Task<'T> * ('T -> 'U)
    _mthd : Map

Returns: Task<'U>
arg0 : Task<'T> * ('T -> 'U)
_mthd : Map
Returns: Task<'U>

Map.Map(arg1, _mthd)

Full Usage: Map.Map(arg1, _mthd)

Parameters:
    arg0 : Lazy<'T> * ('T -> 'U)
    _mthd : Map

Returns: Lazy<'U>
arg0 : Lazy<'T> * ('T -> 'U)
_mthd : Map
Returns: Lazy<'U>