FSharpPlus

Plus Type

Namespace: FSharpPlus.Control
Assembly: FSharpPlus.dll
Base Type: Default1

Static members

Static member Description

Plus.Invoke(x) (y)

Full Usage: Plus.Invoke(x) (y)

Parameters:
    x : ^Plus
    y : ^Plus

Returns: ^Plus
Modifiers: inline
Type parameters: ^Plus
x : ^Plus
y : ^Plus
Returns: ^Plus

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: NonEmptySeq<'a>
Modifiers: inline
x : NonEmptySeq<'a>
y : NonEmptySeq<'a>
?_mthd : Default3
Returns: NonEmptySeq<'a>

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: IReadOnlyDictionary<'K, ^V>
Modifiers: inline
Type parameters: 'K, ^V
x : IReadOnlyDictionary<'K, ^V>
y : IReadOnlyDictionary<'K, ^V>
?_mthd : Default3
Returns: IReadOnlyDictionary<'K, ^V>

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: IDictionary<'K, ^V>
Modifiers: inline
Type parameters: 'K, ^V
x : IDictionary<'K, ^V>
y : IDictionary<'K, ^V>
?_mthd : Default3
Returns: IDictionary<'K, ^V>

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: IEnumerator<'a>
x : IEnumerator<'a>
y : IEnumerator<'a>
?_mthd : Default3
Returns: IEnumerator<'a>

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
    x : 'a seq
    y : 'a seq
    ?_mthd : Default3

Returns: 'a seq
x : 'a seq
y : 'a seq
?_mthd : Default3
Returns: 'a seq

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: IObservable<'a>
x : IObservable<'a>
y : IObservable<'a>
?_mthd : Default3
Returns: IObservable<'a>

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
    x : ResizeArray<'a>
    y : ResizeArray<'a>
    ?_mthd : Plus

Returns: ResizeArray<'a>
x : ResizeArray<'a>
y : ResizeArray<'a>
?_mthd : Plus
Returns: ResizeArray<'a>

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: Lazy<^a>
Modifiers: inline
Type parameters: ^a
x : Lazy<^a>
y : Lazy<^a>
?_mthd : Plus
Returns: Lazy<^a>

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: Expr<^a>
Modifiers: inline
Type parameters: ^a
x : Expr<^a>
y : Expr<^a>
?_mthd : Plus
Returns: Expr<^a>

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: Async<^S>
Modifiers: inline
Type parameters: ^S
x : Async<^S>
y : Async<^S>
?_mthd : Plus
Returns: Async<^S>

Plus.``+``(f, g, ?_mthd)

Full Usage: Plus.``+``(f, g, ?_mthd)

Parameters:
    f : 'T -> ^Monoid
    g : 'T -> ^Monoid
    ?_mthd : Plus

Returns: 'T -> ^Monoid
Modifiers: inline
Type parameters: 'T, ^Monoid
f : 'T -> ^Monoid
g : 'T -> ^Monoid
?_mthd : Plus
Returns: 'T -> ^Monoid

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: Dictionary<'Key, ^Value>
Modifiers: inline
Type parameters: 'Key, ^Value
x : Dictionary<'Key, ^Value>
y : Dictionary<'Key, ^Value>
?_mthd : Plus
Returns: Dictionary<'Key, ^Value>

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: Map<'a, ^b>
Modifiers: inline
Type parameters: 'a, ^b
x : Map<'a, ^b>
y : Map<'a, ^b>
?_mthd : Plus
Returns: Map<'a, ^b>

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: Task<^a>
Modifiers: inline
Type parameters: ^a
x : Task<^a>
y : Task<^a>
?_mthd : Plus
Returns: Task<^a>

Plus.``+``(arg1, arg2, ?_mthd)

Full Usage: Plus.``+``(arg1, arg2, ?_mthd)

Parameters:
    arg0 : ^a * ^b * ^c * ^d * ^e * ^f * ^g
    arg1 : ^a * ^b * ^c * ^d * ^e * ^f * ^g
    ?_mthd : Plus

Returns: ^a * ^b * ^c * ^d * ^e * ^f * ^g
Modifiers: inline
Type parameters: ^a, ^b, ^c, ^d, ^e, ^f, ^g
arg0 : ^a * ^b * ^c * ^d * ^e * ^f * ^g
arg1 : ^a * ^b * ^c * ^d * ^e * ^f * ^g
?_mthd : Plus
Returns: ^a * ^b * ^c * ^d * ^e * ^f * ^g

Plus.``+``(arg1, arg2, ?_mthd)

Full Usage: Plus.``+``(arg1, arg2, ?_mthd)

Parameters:
    arg0 : ^a * ^b * ^c * ^d * ^e * ^f
    arg1 : ^a * ^b * ^c * ^d * ^e * ^f
    ?_mthd : Plus

Returns: ^a * ^b * ^c * ^d * ^e * ^f
Modifiers: inline
Type parameters: ^a, ^b, ^c, ^d, ^e, ^f
arg0 : ^a * ^b * ^c * ^d * ^e * ^f
arg1 : ^a * ^b * ^c * ^d * ^e * ^f
?_mthd : Plus
Returns: ^a * ^b * ^c * ^d * ^e * ^f

Plus.``+``(arg1, arg2, ?_mthd)

Full Usage: Plus.``+``(arg1, arg2, ?_mthd)

Parameters:
    arg0 : ^a * ^b * ^c * ^d * ^e
    arg1 : ^a * ^b * ^c * ^d * ^e
    ?_mthd : Plus

Returns: ^a * ^b * ^c * ^d * ^e
Modifiers: inline
Type parameters: ^a, ^b, ^c, ^d, ^e
arg0 : ^a * ^b * ^c * ^d * ^e
arg1 : ^a * ^b * ^c * ^d * ^e
?_mthd : Plus
Returns: ^a * ^b * ^c * ^d * ^e

Plus.``+``(arg1, arg2, ?_mthd)

Full Usage: Plus.``+``(arg1, arg2, ?_mthd)

Parameters:
    arg0 : ^a * ^b * ^c * ^d
    arg1 : ^a * ^b * ^c * ^d
    ?_mthd : Plus

Returns: ^a * ^b * ^c * ^d
Modifiers: inline
Type parameters: ^a, ^b, ^c, ^d
arg0 : ^a * ^b * ^c * ^d
arg1 : ^a * ^b * ^c * ^d
?_mthd : Plus
Returns: ^a * ^b * ^c * ^d

Plus.``+``(arg1, arg2, ?_mthd)

Full Usage: Plus.``+``(arg1, arg2, ?_mthd)

Parameters:
    arg0 : ^a * ^b * ^c
    arg1 : ^a * ^b * ^c
    ?_mthd : Plus

Returns: ^a * ^b * ^c
Modifiers: inline
Type parameters: ^a, ^b, ^c
arg0 : ^a * ^b * ^c
arg1 : ^a * ^b * ^c
?_mthd : Plus
Returns: ^a * ^b * ^c

Plus.``+``(arg1, arg2, ?_mthd)

Full Usage: Plus.``+``(arg1, arg2, ?_mthd)

Parameters:
    arg0 : ^a * ^b
    arg1 : ^a * ^b
    ?_mthd : Plus

Returns: ^a * ^b
Modifiers: inline
Type parameters: ^a, ^b
arg0 : ^a * ^b
arg1 : ^a * ^b
?_mthd : Plus
Returns: ^a * ^b

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: ValueTuple<^a>
Modifiers: inline
Type parameters: ^a
x : ValueTuple<^a>
y : ValueTuple<^a>
?_mthd : Plus
Returns: ValueTuple<^a>

Plus.``+``(arg1, arg2, ?_mthd)

Full Usage: Plus.``+``(arg1, arg2, ?_mthd)

Parameters:
    arg0 : ^a * ^b * ^c * ^d * ^e * ^f * ^g
    arg1 : ^a * ^b * ^c * ^d * ^e * ^f * ^g
    ?_mthd : Plus

Returns: ^a * ^b * ^c * ^d * ^e * ^f * ^g
Modifiers: inline
Type parameters: ^a, ^b, ^c, ^d, ^e, ^f, ^g
arg0 : ^a * ^b * ^c * ^d * ^e * ^f * ^g
arg1 : ^a * ^b * ^c * ^d * ^e * ^f * ^g
?_mthd : Plus
Returns: ^a * ^b * ^c * ^d * ^e * ^f * ^g

Plus.``+``(arg1, arg2, ?_mthd)

Full Usage: Plus.``+``(arg1, arg2, ?_mthd)

Parameters:
    arg0 : ^a * ^b * ^c * ^d * ^e * ^f
    arg1 : ^a * ^b * ^c * ^d * ^e * ^f
    ?_mthd : Plus

Returns: ^a * ^b * ^c * ^d * ^e * ^f
Modifiers: inline
Type parameters: ^a, ^b, ^c, ^d, ^e, ^f
arg0 : ^a * ^b * ^c * ^d * ^e * ^f
arg1 : ^a * ^b * ^c * ^d * ^e * ^f
?_mthd : Plus
Returns: ^a * ^b * ^c * ^d * ^e * ^f

Plus.``+``(arg1, arg2, ?_mthd)

Full Usage: Plus.``+``(arg1, arg2, ?_mthd)

Parameters:
    arg0 : ^a * ^b * ^c * ^d * ^e
    arg1 : ^a * ^b * ^c * ^d * ^e
    ?_mthd : Plus

Returns: ^a * ^b * ^c * ^d * ^e
Modifiers: inline
Type parameters: ^a, ^b, ^c, ^d, ^e
arg0 : ^a * ^b * ^c * ^d * ^e
arg1 : ^a * ^b * ^c * ^d * ^e
?_mthd : Plus
Returns: ^a * ^b * ^c * ^d * ^e

Plus.``+``(arg1, arg2, ?_mthd)

Full Usage: Plus.``+``(arg1, arg2, ?_mthd)

Parameters:
    arg0 : ^a * ^b * ^c * ^d
    arg1 : ^a * ^b * ^c * ^d
    ?_mthd : Plus

Returns: ^a * ^b * ^c * ^d
Modifiers: inline
Type parameters: ^a, ^b, ^c, ^d
arg0 : ^a * ^b * ^c * ^d
arg1 : ^a * ^b * ^c * ^d
?_mthd : Plus
Returns: ^a * ^b * ^c * ^d

Plus.``+``(arg1, arg2, ?_mthd)

Full Usage: Plus.``+``(arg1, arg2, ?_mthd)

Parameters:
    arg0 : ^a * ^b * ^c
    arg1 : ^a * ^b * ^c
    ?_mthd : Plus

Returns: ^a * ^b * ^c
Modifiers: inline
Type parameters: ^a, ^b, ^c
arg0 : ^a * ^b * ^c
arg1 : ^a * ^b * ^c
?_mthd : Plus
Returns: ^a * ^b * ^c

Plus.``+``(arg1, arg2, ?_mthd)

Full Usage: Plus.``+``(arg1, arg2, ?_mthd)

Parameters:
    arg0 : ^a * ^b
    arg1 : ^a * ^b
    ?_mthd : Plus

Returns: ^a * ^b
Modifiers: inline
Type parameters: ^a, ^b
arg0 : ^a * ^b
arg1 : ^a * ^b
?_mthd : Plus
Returns: ^a * ^b

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: Tuple<^a>
Modifiers: inline
Type parameters: ^a
x : Tuple<^a>
y : Tuple<^a>
?_mthd : Plus
Returns: Tuple<^a>

Plus.``+``(x, y, _mthd)

Full Usage: Plus.``+``(x, y, _mthd)

Parameters:
    x : ^t
    y : ^t
    _mthd : Plus

Returns: ^t
Modifiers: inline
Type parameters: ^t, ^tr, ^t7, ^t6, ^t5, ^t4, ^t3, ^t2, ^t1
x : ^t
y : ^t
_mthd : Plus
Returns: ^t

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: Choice<^a, ^b>
Modifiers: inline
x : Choice<^a, ^b>
y : Choice<^a, ^b>
?_mthd : Plus
Returns: Choice<^a, ^b>

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: Result<^a, ^b>
Modifiers: inline
x : Result<^a, ^b>
y : Result<^a, ^b>
?_mthd : Plus
Returns: Result<^a, ^b>

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
    x : ^a voption
    y : ^a voption
    ?_mthd : Plus

Returns: ^a voption
Modifiers: inline
x : ^a voption
y : ^a voption
?_mthd : Plus
Returns: ^a voption

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
    x : ^a option
    y : ^a option
    ?_mthd : Plus

Returns: ^a option
Modifiers: inline
x : ^a option
y : ^a option
?_mthd : Plus
Returns: ^a option

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
    x : exn
    y : exn
    ?_mthd : Plus

Returns: exn
x : exn
y : exn
?_mthd : Plus
Returns: exn

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: AggregateException
x : AggregateException
y : AggregateException
?_mthd : Plus
Returns: AggregateException

Plus.``+``(arg1, arg2, ?_mthd)

Full Usage: Plus.``+``(arg1, arg2, ?_mthd)

Parameters:
Returns: Id0
arg0 : Id0
arg1 : Id0
?_mthd : Plus
Returns: Id0

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: StringBuilder
x : StringBuilder
y : StringBuilder
?_mthd : Plus
Returns: StringBuilder

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: Set<'a>
x : Set<'a>
y : Set<'a>
?_mthd : Plus
Returns: Set<'a>

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
    x : bool
    y : bool
    ?_mthd : Plus

Returns: bool
x : bool
y : bool
?_mthd : Plus
Returns: bool

Plus.``+``((), (), ?_mthd)

Full Usage: Plus.``+``((), (), ?_mthd)

Parameters:
    () : unit
    () : unit
    ?_mthd : Plus

() : unit
() : unit
?_mthd : Plus

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
    x : 'a array
    y : 'a[]
    ?_mthd : Plus

Returns: 'a[]
x : 'a array
y : 'a[]
?_mthd : Plus
Returns: 'a[]

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
    x : 'a list
    y : 'a list
    ?_mthd : Plus

Returns: 'a list
x : 'a list
y : 'a list
?_mthd : Plus
Returns: 'a list

Plus.``+``(arg1, arg2, ?_mthd)

Full Usage: Plus.``+``(arg1, arg2, ?_mthd)

Parameters:
Returns: 'a -> 'a
Modifiers: inline
arg0 : ^t
arg1 : ^t
?_mthd : Default1
Returns: 'a -> 'a

Plus.``+``(x, y, ?_mthd)

Full Usage: Plus.``+``(x, y, ?_mthd)

Parameters:
Returns: ^Plus
Modifiers: inline
Type parameters: ^Plus
x : ^Plus
y : ^Plus
?_mthd : Default1
Returns: ^Plus

Plus.``+``(x, y, _mthd)

Full Usage: Plus.``+``(x, y, _mthd)

Parameters:
Returns: ^Plus
Modifiers: inline
Type parameters: ^Plus
x : ^Plus
y : ^Plus
_mthd : Default2
Returns: ^Plus