WX5.FP Class Reference

This class contains widely-used functions from Functional Paradigm like Map() or Fold(). More...

List of all members.

Static Public Member Functions
static List< A >	Cons< A > (IList< A > src, params A[] args)
	Returns a concatenation of SRC and ARGS as a list.
static List< A >	Cons< A > (IList< A >[] args)
	Returns a concatenation of ARGS as a list.
static List< A >	Cons< A > (params A[] args)
	Returns a concatenation of ARGS as a list.
static List< A >	Cons< A > (IEnumerable src)
	Creates a list from IEnumerable source.
static List< A >	Cons< A > (ref List< A > target, IList< A > src, params A[] args)
	Returns a concatenation of TARGET, SRC and ARGS as a TARGET list.
static List< A >	Cons< A > (ref List< A > target, IList< A >[] args)
	Returns a concatenation of TARGET and ARGS as a list.
static List< A >	Cons< A > (ref List< A > target, params A[] args)
	Returns a concatenation of TARGET and ARGS as a list.
static List< A >	Cons< A > (ref List< A > target, IEnumerable src)
	Creates a list from IEnumerable source and adds it to TARGET list.
static List< A >	Tail< A > (IList< A > src)
	Returns a tail of the input list.
static FuncX< A, C >	Compose< A, B, C > (FuncX< A, B > f, FuncX< B, C > g)
	Returns a composition of f and g functions.
static FuncX< A, B >	Compose< A, B > (FuncX< A, B > f, FuncX< B, B > g)
	Returns a composition of f and g functions.
static FuncX< A, B >	Compose< A, B > (FuncX< A, A > f, FuncX< A, B > g)
	Returns a composition of f and g functions.
static FuncX< A, A >	Compose< A > (FuncX< A, A > f, FuncX< A, A > g)
	Returns a composition of f and g functions.
static FuncX< FuncX< A, B > , FuncX< A, C > >	Up< A, B, C > (FuncX< B, C > fn)
	Increases the order of the input function.
static FuncX< FuncX< A, B > , FuncX< A, B > >	Up< A, B > (FuncX< B, B > fn)
	Increases the order of the input function.
static FuncX< FuncX< A, A > , FuncX< A, B > >	Up< A, B > (FuncX< A, B > fn)
	Increases the order of the input function.
static FuncX< FuncX< A, A > , FuncX< A, A > >	Up< A > (FuncX< A, A > fn)
	Increases the order of the input function.
static List< B >	Map< A, B > (FuncX< A, B > fn, IList< A > args)
	Applies function fn for each element of the ARGS list.
static List< A >	Map< A > (FuncX< A, A > fn, IList< A > args)
	Applies function fn for each element of the ARGS list.
static List< B >	_Map< A, B > (FuncX< A, B > fn, IEnumerable args)
	Applies function fn for each element of the ARGS list.
static List< A >	Filter< A > (FuncX< A, bool > fn, IList< A > args)
	Filters elements from the source list using filtering function.
static List< A >	_Filter< A > (FuncX< A, bool > fn, IEnumerable args)
	Filters elements from the source list using filtering function.
static B	Fold< A, B > (FuncXY< A, B, B > fn, B initial, IList< A > args)
	It takes the second argument (initial) and the first item of the list and applies the function, then it takes the next item from the begin and the result, and so on.
static A	Fold< A > (FuncXY< A, A, A > fn, A initial, IList< A > args)
	It takes the second argument (initial) and the first item of the list and applies the function, then it takes the next item from the begin and the result, and so on.
static B	_Fold< A, B > (FuncXY< A, B, B > fn, B initial, IEnumerable args)
	It takes the second argument (initial) and the first item of the list and applies the function, then it takes the next item from the begin and the result, and so on.
static A	Min< A > (IList< A > args)
	Returns a minimal element in the list.
static A	Min< A > (params A[] args)
	Returns a minimal element in the list.
static A	Max< A > (IList< A > args)
	Returns a maximal element in the list.
static A	Max< A > (params A[] args)
	Returns a maximal element in the list.
static double	Avg< A > (IList< A > args)
	Returns an average value of the input list.
static double	Avg< A > (params A[] args)
	Returns an average value of the input list.
static Tuple2< A, B >	Tuple< A, B > (A a, B b)
	Creates 2-element tuple.
static Tuple3< A, B, C >	Tuple< A, B, C > (A a, B b, C c)
	Creates 3-element tuple.
static Tuple3< A, B, C >	Tuple< A, B, C > (Tuple2< A, B > a, C b)
	Creates 3-element tuple.
static Tuple4< A, B, C, D >	Tuple< A, B, C, D > (A a, B b, C c, D d)
	Creates 4-element tuple.
static Tuple4< A, B, C, D >	Tuple< A, B, C, D > (Tuple2< A, B > a, C b, D c)
	Creates 4-element tuple.
static Tuple4< A, B, C, D >	Tuple< A, B, C, D > (Tuple2< A, B > a, Tuple2< C, D > b)
	Creates 4-element tuple.
static Tuple4< A, B, C, D >	Tuple< A, B, C, D > (Tuple3< A, B, C > a, D b)
	Creates 4-element tuple.
static Tuple5< A, B, C, D, E >	Tuple< A, B, C, D, E > (A a, B b, C c, D d, E e)
	Creates 5-element tuple.
static Tuple5< A, B, C, D, E >	Tuple< A, B, C, D, E > (Tuple2< A, B > a, C b, D c, E d)
	Creates 5-element tuple.
static Tuple5< A, B, C, D, E >	Tuple< A, B, C, D, E > (Tuple2< A, B > a, Tuple2< C, D > b, E c)
	Creates 5-element tuple.
static Tuple5< A, B, C, D, E >	Tuple< A, B, C, D, E > (Tuple3< A, B, C > a, D b, E c)
	Creates 5-element tuple.
static Tuple5< A, B, C, D, E >	Tuple< A, B, C, D, E > (Tuple3< A, B, C > a, Tuple2< D, E > b)
	Creates 5-element tuple.
static Tuple5< A, B, C, D, E >	Tuple< A, B, C, D, E > (Tuple4< A, B, C, D > a, E b)
	Creates 5-element tuple.
static List< Tuple2< A, B > >	Zip< A, B > (IList< A > a, IList< B > b)
	Makes a list of 2-item tuples, each tuple conteining elements of both lists occuring at the same position.
static List< Tuple2< A, B > >	Zip< A, B > (IList< A > a, params B[] b)
	Makes a list of 2-item tuples, each tuple conteining elements of both lists occuring at the same position.
static List< Tuple2< A, B > >	Zip< A, B > (A[] a, params B[] b)
	Makes a list of 2-item tuples, each tuple conteining elements of both lists occuring at the same position.
static List< Tuple3< A, B, C > >	Zip< A, B, C > (IList< A > a, IList< B > b, IList< C > c)
	Makes a list of 3-item tuples, each tuple conteining elements of both lists occuring at the same position.
static List< Tuple3< A, B, C > >	Zip< A, B, C > (IList< A > a, IList< B > b, params C[] c)
	Makes a list of 3-item tuples, each tuple conteining elements of both lists occuring at the same position.
static List< Tuple3< A, B, C > >	Zip< A, B, C > (IList< A > a, B[] b, params C[] c)
	Makes a list of 3-item tuples, each tuple conteining elements of both lists occuring at the same position.
static List< Tuple3< A, B, C > >	Zip< A, B, C > (A[] a, B[] b, params C[] c)
	Makes a list of 3-item tuples, each tuple conteining elements of both lists occuring at the same position.
static List< Tuple4< A, B, C, D > >	Zip< A, B, C, D > (IList< A > a, IList< B > b, IList< C > c, List< D > d)
	Makes a list of 4-item tuples, each tuple conteining elements of both lists occuring at the same position.
static List< Tuple4< A, B, C, D > >	Zip< A, B, C, D > (IList< A > a, IList< B > b, IList< C > c, params D[] d)
	Makes a list of 4-item tuples, each tuple conteining elements of both lists occuring at the same position.
static List< Tuple4< A, B, C, D > >	Zip< A, B, C, D > (IList< A > a, IList< B > b, C[] c, params D[] d)
	Makes a list of 4-item tuples, each tuple conteining elements of both lists occuring at the same position.
static List< Tuple4< A, B, C, D > >	Zip< A, B, C, D > (IList< A > a, B[] b, C[] c, params D[] d)
	Makes a list of 4-item tuples, each tuple conteining elements of both lists occuring at the same position.
static List< Tuple4< A, B, C, D > >	Zip< A, B, C, D > (A[] a, B[] b, C[] c, params D[] d)
	Makes a list of 4-item tuples, each tuple conteining elements of both lists occuring at the same position.
static List< Tuple5< A, B, C, D, E > >	Zip< A, B, C, D, E > (IList< A > a, IList< B > b, IList< C > c, IList< D > d, IList< E > e)
	Makes a list of 5-item tuples, each tuple conteining elements of both lists occuring at the same position.
static List< Tuple5< A, B, C, D, E > >	Zip< A, B, C, D, E > (A[] a, B[] b, C[] c, D[] d, params E[] e)
	Makes a list of 5-item tuples, each tuple conteining elements of both lists occuring at the same position.
static List< A >	Generate< A > (FuncX< int, A > gen, int count)
	Creates the list of elements using generation rule .NET 2 FP.Generate<string>(delegate(int x){return x.ToString();}, 5); // Will return {"0","1","2","3","4"} .NET 3 FP.Generate<string>(x => x.ToString(), 5); // Will return {"0","1","2","3","4"}
static FuncX< IList< A >, List < B > >	MapFilter< A, B > (FuncX< A, B > map, FuncX< B, bool > filter)
	Returns a function that maps ant then filters the input list.
static FuncX< IList< A >, List < A > >	MapFilter< A > (FuncX< A, A > map, FuncX< A, bool > filter)
	Returns a function that maps ant then filters the input list.
static FuncX< IList< A >, List < B > >	FilterMap< A, B > (FuncX< A, bool > filter, FuncX< A, B > map)
	Returns a function that filters ant then maps the input list.
static FuncX< IList< A >, List < A > >	FilterMap< A > (FuncX< A, bool > filter, FuncX< A, A > map)
	Returns a function that filters ant then maps the input list.
static FuncXY< IList< A >, C, C >	MapFold< A, B, C > (FuncX< A, B > map, FuncXY< B, C, C > fold)
	Returns a function that maps the input list and then folds it.
static FuncX< IList< A >, C >	MapFold< A, B, C > (FuncX< A, B > map, FuncXY< B, C, C > fold, C init)
	Returns a function that maps the input list and then folds it.
static FuncXY< IList< A >, B, B >	MapFold< A, B > (FuncX< A, B > map, FuncXY< B, B, B > fold)
	Returns a function that maps the input list and then folds it.
static FuncX< IList< A >, B >	MapFold< A, B > (FuncX< A, B > map, FuncXY< B, B, B > fold, B init)
	Returns a function that maps the input list and then folds it.
static FuncXY< IList< A >, B, B >	MapFold< A, B > (FuncX< A, A > map, FuncXY< A, B, B > fold)
	Returns a function that maps the input list and then folds it.
static FuncX< IList< A >, B >	MapFold< A, B > (FuncX< A, A > map, FuncXY< A, B, B > fold, B init)
	Returns a function that maps the input list and then folds it.
static FuncXY< IList< A >, A, A >	MapFold< A > (FuncX< A, A > map, FuncXY< A, A, A > fold)
	Returns a function that maps the input list and then folds it.
static FuncX< IList< A >, A >	MapFold< A > (FuncX< A, A > map, FuncXY< A, A, A > fold, A init)
	Returns a function that maps the input list and then folds it.

---

Detailed Description

This class contains widely-used functions from Functional Paradigm like Map() or Fold().

---

Member Function Documentation

static List<A> WX5.FP._Filter< A >	(	FuncX< A, bool >	fn,
		IEnumerable	args
	)			[static]

Filters elements from the source list using filtering function.

Template Parameters:

A

Parameters:

	fn	filtering function
	args	source list

Returns:

filtered list

static B WX5.FP._Fold< A, B >	(	FuncXY< A, B, B >	fn,
		B	initial,
		IEnumerable	args
	)			[static]

It takes the second argument (initial) and the first item of the list and applies the function, then it takes the next item from the begin and the result, and so on.

Template Parameters:

	A
	B

Parameters:

	fn	function to apply
	initial	initial argument
	args	a list of input elements

Returns:

result of calculations

static List<B> WX5.FP._Map< A, B >	(	FuncX< A, B >	fn,
		IEnumerable	args
	)			[static]

Applies function fn for each element of the ARGS list.

Template Parameters:

	A
	B

Parameters:

	fn	mapping function
	args	elements to be applied

Returns:

resulting list of the applying

static double WX5.FP.Avg< A >

(

params A[]

args

)

[static]

Returns an average value of the input list.

Template Parameters:

A

should be IConvertible

Parameters:

args

input list

Returns:

average value

Type Constraints

A

:

IConvertible

static double WX5.FP.Avg< A >

(

IList< A >

args

)

[static]

Returns an average value of the input list.

Template Parameters:

A

should be IConvertible

Parameters:

args

input list

Returns:

average value

Type Constraints

A

:

IConvertible

static FuncX<A, A> WX5.FP.Compose< A >	(	FuncX< A, A >	f,
		FuncX< A, A >	g
	)			[static]

Returns a composition of f and g functions.

Template Parameters:

A

Parameters:

	f	first function
	g	second function

Returns:

a composition (g*f) = g(f(x))

static FuncX<A, B> WX5.FP.Compose< A, B >	(	FuncX< A, A >	f,
		FuncX< A, B >	g
	)			[static]

Returns a composition of f and g functions.

Template Parameters:

	A
	B

Parameters:

	f	first function
	g	second function

Returns:

a composition (g*f) = g(f(x))

static FuncX<A, B> WX5.FP.Compose< A, B >	(	FuncX< A, B >	f,
		FuncX< B, B >	g
	)			[static]

Returns a composition of f and g functions.

Template Parameters:

	A
	B

Parameters:

	f	first function
	g	second function

Returns:

a composition (g*f) = g(f(x))

static FuncX<A, C> WX5.FP.Compose< A, B, C >	(	FuncX< A, B >	f,
		FuncX< B, C >	g
	)			[static]

Returns a composition of f and g functions.

Template Parameters:

	A
	B
	C

Parameters:

	f	first function
	g	second function

Returns:

a composition (g*f) = g(f(x))

static List<A> WX5.FP.Cons< A >	(	ref List< A >	target,
		IEnumerable	src
	)			[static]

Creates a list from IEnumerable source and adds it to TARGET list.

Template Parameters:

A

Parameters:

	target	target list
	src	IEnumerable source

Returns:

TARGET list

static List<A> WX5.FP.Cons< A >	(	ref List< A >	target,
		params A[]	args
	)			[static]

Returns a concatenation of TARGET and ARGS as a list.

Template Parameters:

A

Parameters:

	target	target list
	args	a sequence of values

Returns:

TARGET list

static List<A> WX5.FP.Cons< A >	(	ref List< A >	target,
		IList< A >[]	args
	)			[static]

Returns a concatenation of TARGET and ARGS as a list.

Template Parameters:

A

Parameters:

	target	target list
	args	a sequence of lists

Returns:

TARGET list

static List<A> WX5.FP.Cons< A >	(	ref List< A >	target,
		IList< A >	src,
		params A[]	args
	)			[static]

Returns a concatenation of TARGET, SRC and ARGS as a TARGET list.

Template Parameters:

A

Parameters:

	target	target list
	src	a list of values
	args	a sequence of values

Returns:

TARGET list

static List<A> WX5.FP.Cons< A >

(

IEnumerable

src

)

[static]

Creates a list from IEnumerable source.

Template Parameters:

A

Parameters:

src

IEnumerable source

Returns:

resulting list

static List<A> WX5.FP.Cons< A >

(

params A[]

args

)

[static]

Returns a concatenation of ARGS as a list.

Template Parameters:

A

Parameters:

args

a sequence of values

Returns:

resulting list

static List<A> WX5.FP.Cons< A >

(

IList< A >[]

args

)

[static]

Returns a concatenation of ARGS as a list.

Template Parameters:

A

Parameters:

args

a sequence of lists

Returns:

resulting list

static List<A> WX5.FP.Cons< A >	(	IList< A >	src,
		params A[]	args
	)			[static]

Returns a concatenation of SRC and ARGS as a list.

Template Parameters:

A

Parameters:

	src	a list of values
	args	a sequence of values

Returns:

resulting list

static List<A> WX5.FP.Filter< A >	(	FuncX< A, bool >	fn,
		IList< A >	args
	)			[static]

Filters elements from the source list using filtering function.

Template Parameters:

A

Parameters:

	fn	filtering function
	args	source list

Returns:

filtered list

static FuncX<IList<A>, List<A> > WX5.FP.FilterMap< A >	(	FuncX< A, bool >	filter,
		FuncX< A, A >	map
	)			[static]

Returns a function that filters ant then maps the input list.

Template Parameters:

A

Parameters:

	filter	filtering function
	map	map function

Returns:

function that filters ant then maps the input list

static FuncX<IList<A>, List<B> > WX5.FP.FilterMap< A, B >	(	FuncX< A, bool >	filter,
		FuncX< A, B >	map
	)			[static]

Returns a function that filters ant then maps the input list.

Template Parameters:

	A
	B

Parameters:

	filter	filtering function
	map	map function

Returns:

function that filters ant then maps the input list

static A WX5.FP.Fold< A >	(	FuncXY< A, A, A >	fn,
		A	initial,
		IList< A >	args
	)			[static]

It takes the second argument (initial) and the first item of the list and applies the function, then it takes the next item from the begin and the result, and so on.

Template Parameters:

A

Parameters:

	fn	function to apply
	initial	initial argument
	args	a list of input elements

Returns:

result of calculations

static B WX5.FP.Fold< A, B >	(	FuncXY< A, B, B >	fn,
		B	initial,
		IList< A >	args
	)			[static]

It takes the second argument (initial) and the first item of the list and applies the function, then it takes the next item from the begin and the result, and so on.

Template Parameters:

	A
	B

Parameters:

	fn	function to apply
	initial	initial argument
	args	a list of input elements

Returns:

result of calculations

static List<A> WX5.FP.Generate< A >	(	FuncX< int, A >	gen,
		int	count
	)			[static]

Creates the list of elements using generation rule .NET 2 FP.Generate<string>(delegate(int x){return x.ToString();}, 5); // Will return {"0","1","2","3","4"} .NET 3 FP.Generate<string>(x => x.ToString(), 5); // Will return {"0","1","2","3","4"}

Template Parameters:

A

Parameters:

	gen	generation rule
	count	how much items to create

Returns:

list of generates items

static List<A> WX5.FP.Map< A >	(	FuncX< A, A >	fn,
		IList< A >	args
	)			[static]

Applies function fn for each element of the ARGS list.

Template Parameters:

A

Parameters:

	fn	mapping function
	args	elements to be applied

Returns:

resulting list of the applying

static List<B> WX5.FP.Map< A, B >	(	FuncX< A, B >	fn,
		IList< A >	args
	)			[static]

Applies function fn for each element of the ARGS list.

Template Parameters:

	A
	B

Parameters:

	fn	mapping function
	args	elements to be applied

Returns:

resulting list of the applying

static FuncX<IList<A>, List<A> > WX5.FP.MapFilter< A >	(	FuncX< A, A >	map,
		FuncX< A, bool >	filter
	)			[static]

Returns a function that maps ant then filters the input list.

Template Parameters:

A

Parameters:

	map	map function
	filter	filtering function

Returns:

function that maps ant then filters the input list

static FuncX<IList<A>, List<B> > WX5.FP.MapFilter< A, B >	(	FuncX< A, B >	map,
		FuncX< B, bool >	filter
	)			[static]

Returns a function that maps ant then filters the input list.

Template Parameters:

	A
	B

Parameters:

	map	map function
	filter	filtering function

Returns:

function that maps ant then filters the input list

static FuncX<IList<A>, A> WX5.FP.MapFold< A >	(	FuncX< A, A >	map,
		FuncXY< A, A, A >	fold,
		A	init
	)			[static]

Returns a function that maps the input list and then folds it.

Template Parameters:

A

Parameters:

	map	mapping function
	fold	folding function
	init	initial value for folding

Returns:

function that maps the input list and then folds it

static FuncXY<IList<A>, A, A> WX5.FP.MapFold< A >	(	FuncX< A, A >	map,
		FuncXY< A, A, A >	fold
	)			[static]

Returns a function that maps the input list and then folds it.

Template Parameters:

A

Parameters:

	map	mapping function
	fold	folding function

Returns:

function that maps the input list and then folds it

static FuncX<IList<A>, B> WX5.FP.MapFold< A, B >	(	FuncX< A, A >	map,
		FuncXY< A, B, B >	fold,
		B	init
	)			[static]

Returns a function that maps the input list and then folds it.

Template Parameters:

	A
	B

Parameters:

	map	mapping function
	fold	folding function
	init	initial value for folding

Returns:

function that maps the input list and then folds it

static FuncXY<IList<A>, B, B> WX5.FP.MapFold< A, B >	(	FuncX< A, A >	map,
		FuncXY< A, B, B >	fold
	)			[static]

Returns a function that maps the input list and then folds it.

Template Parameters:

	A
	B

Parameters:

	map	mapping function
	fold	folding function

Returns:

function that maps the input list and then folds it

static FuncX<IList<A>, B> WX5.FP.MapFold< A, B >	(	FuncX< A, B >	map,
		FuncXY< B, B, B >	fold,
		B	init
	)			[static]

Returns a function that maps the input list and then folds it.

Template Parameters:

	A
	B

Parameters:

	map	mapping function
	fold	folding function
	init	initial value for folding

Returns:

function that maps the input list and then folds it

static FuncXY<IList<A>, B, B> WX5.FP.MapFold< A, B >	(	FuncX< A, B >	map,
		FuncXY< B, B, B >	fold
	)			[static]

Returns a function that maps the input list and then folds it.

Template Parameters:

	A
	B

Parameters:

	map	mapping function
	fold	folding function

Returns:

function that maps the input list and then folds it

static FuncX<IList<A>, C> WX5.FP.MapFold< A, B, C >	(	FuncX< A, B >	map,
		FuncXY< B, C, C >	fold,
		C	init
	)			[static]

Returns a function that maps the input list and then folds it.

Template Parameters:

	A
	B
	C

Parameters:

	map	mapping function
	fold	folding function
	init	initial value for folding

Returns:

function that maps the input list and then folds it

static FuncXY<IList<A>, C, C> WX5.FP.MapFold< A, B, C >	(	FuncX< A, B >	map,
		FuncXY< B, C, C >	fold
	)			[static]

Returns a function that maps the input list and then folds it.

Template Parameters:

	A
	B
	C

Parameters:

	map	mapping function
	fold	folding function

Returns:

function that maps the input list and then folds it

static A WX5.FP.Max< A >

(

params A[]

args

)

[static]

Returns a maximal element in the list.

Template Parameters:

A

should be IComparable

Parameters:

args

input list

Returns:

maximal element

Type Constraints

A

:

IComparable<A>

static A WX5.FP.Max< A >

(

IList< A >

args

)

[static]

Returns a maximal element in the list.

Template Parameters:

A

should be IComparable

Parameters:

args

input list

Returns:

maximal element

Type Constraints

A

:

IComparable<A>

static A WX5.FP.Min< A >

(

params A[]

args

)

[static]

Returns a minimal element in the list.

Template Parameters:

A

should be IComparable

Parameters:

args

input list

Returns:

minimal element

Type Constraints

A

:

IComparable<A>

static A WX5.FP.Min< A >

(

IList< A >

args

)

[static]

Returns a minimal element in the list.

Template Parameters:

A

should be IComparable

Parameters:

args

input list

Returns:

minimal element

Type Constraints

A

:

IComparable<A>

static List<A> WX5.FP.Tail< A >

(

IList< A >

src

)

[static]

Returns a tail of the input list.

Template Parameters:

A

Parameters:

src

input list

Returns:

a tail of the list, or NULL, if input list contains less than 2 elements

static Tuple2<A, B> WX5.FP.Tuple< A, B >	(	A	a,
		B	b
	)			[static]

Creates 2-element tuple.

Template Parameters:

	A
	B

Parameters:

	a
	b

Returns:

static Tuple3<A, B, C> WX5.FP.Tuple< A, B, C >	(	Tuple2< A, B >	a,
		C	b
	)			[static]

Creates 3-element tuple.

Template Parameters:

	A
	B
	C

Parameters:

	a
	b

Returns:

static Tuple3<A, B, C> WX5.FP.Tuple< A, B, C >	(	A	a,
		B	b,
		C	c
	)			[static]

Creates 3-element tuple.

Template Parameters:

	A
	B
	C

Parameters:

	a
	b
	c

Returns:

static Tuple4<A, B, C, D> WX5.FP.Tuple< A, B, C, D >	(	Tuple3< A, B, C >	a,
		D	b
	)			[static]

Creates 4-element tuple.

Template Parameters:

	A
	B
	C
	D

Parameters:

	a
	b

Returns:

static Tuple4<A, B, C, D> WX5.FP.Tuple< A, B, C, D >	(	Tuple2< A, B >	a,
		Tuple2< C, D >	b
	)			[static]

Creates 4-element tuple.

Template Parameters:

	A
	B
	C
	D

Parameters:

	a
	b

Returns:

static Tuple4<A, B, C, D> WX5.FP.Tuple< A, B, C, D >	(	Tuple2< A, B >	a,
		C	b,
		D	c
	)			[static]

Creates 4-element tuple.

Template Parameters:

	A
	B
	C
	D

Parameters:

	a
	b
	c

Returns:

static Tuple4<A, B, C, D> WX5.FP.Tuple< A, B, C, D >	(	A	a,
		B	b,
		C	c,
		D	d
	)			[static]

Creates 4-element tuple.

Template Parameters:

	A
	B
	C
	D

Parameters:

	a
	b
	c
	d

Returns:

static Tuple5<A, B, C, D, E> WX5.FP.Tuple< A, B, C, D, E >	(	Tuple4< A, B, C, D >	a,
		E	b
	)			[static]

Creates 5-element tuple.

Template Parameters:

	A
	B
	C
	D
	E

Parameters:

	a
	b

Returns:

static Tuple5<A, B, C, D, E> WX5.FP.Tuple< A, B, C, D, E >	(	Tuple3< A, B, C >	a,
		Tuple2< D, E >	b
	)			[static]

Creates 5-element tuple.

Template Parameters:

	A
	B
	C
	D
	E

Parameters:

	a
	b

Returns:

static Tuple5<A, B, C, D, E> WX5.FP.Tuple< A, B, C, D, E >	(	Tuple3< A, B, C >	a,
		D	b,
		E	c
	)			[static]

Creates 5-element tuple.

Template Parameters:

	A
	B
	C
	D
	E

Parameters:

	a
	b
	c

Returns:

static Tuple5<A, B, C, D, E> WX5.FP.Tuple< A, B, C, D, E >	(	Tuple2< A, B >	a,
		Tuple2< C, D >	b,
		E	c
	)			[static]

Creates 5-element tuple.

Template Parameters:

	A
	B
	C
	D
	E

Parameters:

	a
	b
	c

Returns:

static Tuple5<A, B, C, D, E> WX5.FP.Tuple< A, B, C, D, E >	(	Tuple2< A, B >	a,
		C	b,
		D	c,
		E	d
	)			[static]

Creates 5-element tuple.

Template Parameters:

	A
	B
	C
	D
	E

Parameters:

	a
	b
	c
	d

Returns:

static Tuple5<A, B, C, D, E> WX5.FP.Tuple< A, B, C, D, E >	(	A	a,
		B	b,
		C	c,
		D	d,
		E	e
	)			[static]

Creates 5-element tuple.

Template Parameters:

	A
	B
	C
	D
	E

Parameters:

	a
	b
	c
	d
	e

Returns:

static FuncX<FuncX<A, A>, FuncX<A, A> > WX5.FP.Up< A >

(

FuncX< A, A >

fn

)

[static]

Increases the order of the input function.

Template Parameters:

A

Parameters:

fn

input function

Returns:

increased-order function

static FuncX<FuncX<A, A>, FuncX<A, B> > WX5.FP.Up< A, B >

(

FuncX< A, B >

fn

)

[static]

Increases the order of the input function.

Template Parameters:

	A
	B

Parameters:

fn

input function

Returns:

increased-order function

static FuncX<FuncX<A, B>, FuncX<A, B> > WX5.FP.Up< A, B >

(

FuncX< B, B >

fn

)

[static]

Increases the order of the input function.

Template Parameters:

	A
	B

Parameters:

fn

input function

Returns:

increased-order function

static FuncX<FuncX<A, B>, FuncX<A, C> > WX5.FP.Up< A, B, C >

(

FuncX< B, C >

fn

)

[static]

Increases the order of the input function.

Template Parameters:

	A
	B
	C

Parameters:

fn

input function

Returns:

increased-order function

static List<Tuple2<A, B> > WX5.FP.Zip< A, B >	(	A[]	a,
		params B[]	b
	)			[static]

Makes a list of 2-item tuples, each tuple conteining elements of both lists occuring at the same position.

Template Parameters:

	A
	B

Parameters:

	a
	b

Returns:

static List<Tuple2<A, B> > WX5.FP.Zip< A, B >	(	IList< A >	a,
		params B[]	b
	)			[static]

Makes a list of 2-item tuples, each tuple conteining elements of both lists occuring at the same position.

Template Parameters:

	A
	B

Parameters:

	a
	b

Returns:

static List<Tuple2<A, B> > WX5.FP.Zip< A, B >	(	IList< A >	a,
		IList< B >	b
	)			[static]

Makes a list of 2-item tuples, each tuple conteining elements of both lists occuring at the same position.

Template Parameters:

	A
	B

Parameters:

	a
	b

Returns:

static List<Tuple3<A, B, C> > WX5.FP.Zip< A, B, C >	(	A[]	a,
		B[]	b,
		params C[]	c
	)			[static]

Makes a list of 3-item tuples, each tuple conteining elements of both lists occuring at the same position.

Template Parameters:

	A
	B
	C

Parameters:

	a
	b
	c

Returns:

static List<Tuple3<A, B, C> > WX5.FP.Zip< A, B, C >	(	IList< A >	a,
		B[]	b,
		params C[]	c
	)			[static]

Makes a list of 3-item tuples, each tuple conteining elements of both lists occuring at the same position.

Template Parameters:

	A
	B
	C

Parameters:

	a
	b
	c

Returns:

static List<Tuple3<A, B, C> > WX5.FP.Zip< A, B, C >	(	IList< A >	a,
		IList< B >	b,
		params C[]	c
	)			[static]

Makes a list of 3-item tuples, each tuple conteining elements of both lists occuring at the same position.

Template Parameters:

	A
	B
	C

Parameters:

	a
	b
	c

Returns:

static List<Tuple3<A, B, C> > WX5.FP.Zip< A, B, C >	(	IList< A >	a,
		IList< B >	b,
		IList< C >	c
	)			[static]

Makes a list of 3-item tuples, each tuple conteining elements of both lists occuring at the same position.

Template Parameters:

	A
	B
	C

Parameters:

	a
	b
	c

Returns:

static List<Tuple4<A, B, C, D> > WX5.FP.Zip< A, B, C, D >	(	A[]	a,
		B[]	b,
		C[]	c,
		params D[]	d
	)			[static]

Makes a list of 4-item tuples, each tuple conteining elements of both lists occuring at the same position.

Template Parameters:

	A
	B
	C
	D

Parameters:

	a
	b
	c
	d

Returns:

static List<Tuple4<A, B, C, D> > WX5.FP.Zip< A, B, C, D >	(	IList< A >	a,
		B[]	b,
		C[]	c,
		params D[]	d
	)			[static]

Makes a list of 4-item tuples, each tuple conteining elements of both lists occuring at the same position.

Template Parameters:

	A
	B
	C
	D

Parameters:

	a
	b
	c
	d

Returns:

static List<Tuple4<A, B, C, D> > WX5.FP.Zip< A, B, C, D >	(	IList< A >	a,
		IList< B >	b,
		C[]	c,
		params D[]	d
	)			[static]

Makes a list of 4-item tuples, each tuple conteining elements of both lists occuring at the same position.

Template Parameters:

	A
	B
	C
	D

Parameters:

	a
	b
	c
	d

Returns:

static List<Tuple4<A, B, C, D> > WX5.FP.Zip< A, B, C, D >	(	IList< A >	a,
		IList< B >	b,
		IList< C >	c,
		params D[]	d
	)			[static]

Makes a list of 4-item tuples, each tuple conteining elements of both lists occuring at the same position.

Template Parameters:

	A
	B
	C
	D

Parameters:

	a
	b
	c
	d

Returns:

static List<Tuple4<A, B, C, D> > WX5.FP.Zip< A, B, C, D >	(	IList< A >	a,
		IList< B >	b,
		IList< C >	c,
		List< D >	d
	)			[static]

Makes a list of 4-item tuples, each tuple conteining elements of both lists occuring at the same position.

Template Parameters:

	A
	B
	C
	D

Parameters:

	a
	b
	c
	d

Returns:

static List<Tuple5<A, B, C, D, E> > WX5.FP.Zip< A, B, C, D, E >	(	A[]	a,
		B[]	b,
		C[]	c,
		D[]	d,
		params E[]	e
	)			[static]

Makes a list of 5-item tuples, each tuple conteining elements of both lists occuring at the same position.

Template Parameters:

	A
	B
	C
	D
	E

Parameters:

	a
	b
	c
	d
	e

Returns:

static List<Tuple5<A, B, C, D, E> > WX5.FP.Zip< A, B, C, D, E >	(	IList< A >	a,
		IList< B >	b,
		IList< C >	c,
		IList< D >	d,
		IList< E >	e
	)			[static]

Makes a list of 5-item tuples, each tuple conteining elements of both lists occuring at the same position.

Template Parameters:

	A
	B
	C
	D
	E

Parameters:

	a
	b
	c
	d
	e

Returns: