Contents
- Prelude
- fun <R> (Func<R> f)
- fun <T1, R> (Func<T1, R> f)
- fun <T1, T2, R> (Func<T1, T2, R> f)
- fun <T1, T2, T3, R> (Func<T1, T2, T3, R> f)
- fun <T1, T2, T3, T4, R> (Func<T1, T2, T3, T4, R> f)
- fun <T1, T2, T3, T4, T5, R> (Func<T1, T2, T3, T4, T5, R> f)
- fun <T1, T2, T3, T4, T5, T6, R> (Func<T1, T2, T3, T4, T5, T6, R> f)
- fun <T1, T2, T3, T4, T5, T6, T7, R> (Func<T1, T2, T3, T4, T5, T6, T7, R> f)
- fun (Action f)
- fun <T1> (Action<T1> f)
- fun <T1, T2> (Action<T1, T2> f)
- fun <T1, T2, T3> (Action<T1, T2, T3> f)
- fun <T1, T2, T3, T4> (Action<T1, T2, T3, T4> f)
- fun <T1, T2, T3, T4, T5> (Action<T1, T2, T3, T4, T5> f)
- fun <T1, T2, T3, T4, T5, T6> (Action<T1, T2, T3, T4, T5, T6> f)
- fun <T1, T2, T3, T4, T5, T6, T7> (Action<T1, T2, T3, T4, T5, T6, T7> f)
- act (Action f)
- act <T1> (Action<T1> f)
- act <T1, T2> (Action<T1, T2> f)
- act <T1, T2, T3> (Action<T1, T2, T3> f)
- act <T1, T2, T3, T4> (Action<T1, T2, T3, T4> f)
- act <T1, T2, T3, T4, T5> (Action<T1, T2, T3, T4, T5> f)
- act <T1, T2, T3, T4, T5, T6> (Action<T1, T2, T3, T4, T5, T6> f)
- act <T1, T2, T3, T4, T5, T6, T7> (Action<T1, T2, T3, T4, T5, T6, T7> f)
- act <R> (Func<R> f)
- act <T1, R> (Func<T1, R> f)
- act <T1, T2, R> (Func<T1, T2, R> f)
- act <T1, T2, T3, R> (Func<T1, T2, T3, R> f)
- act <T1, T2, T3, T4, R> (Func<T1, T2, T3, T4, R> f)
- act <T1, T2, T3, T4, T5, R> (Func<T1, T2, T3, T4, T5, R> f)
- act <T1, T2, T3, T4, T5, T6, R> (Func<T1, T2, T3, T4, T5, T6, R> f)
- act <T1, T2, T3, T4, T5, T6, T7, R> (Func<T1, T2, T3, T4, T5, T6, T7, R> f)
- expr <R> (Expression<Func<R>> f)
- expr <T1, R> (Expression<Func<T1, R>> f)
- expr <T1, T2, R> (Expression<Func<T1, T2, R>> f)
- expr <T1, T2, T3, R> (Expression<Func<T1, T2, T3, R>> f)
- expr <T1, T2, T3, T4, R> (Expression<Func<T1, T2, T3, T4, R>> f)
- expr <T1, T2, T3, T4, T5, R> (Expression<Func<T1, T2, T3, T4, T5, R>> f)
- expr <T1, T2, T3, T4, T5, T6, R> (Expression<Func<T1, T2, T3, T4, T5, T6, R>> f)
- expr <T1, T2, T3, T4, T5, T6, T7, R> (Expression<Func<T1, T2, T3, T4, T5, T6, T7, R>> f)
- expr (Expression<Action> f)
- expr <T1> (Expression<Action<T1>> f)
- expr <T1, T2> (Expression<Action<T1, T2>> f)
- expr <T1, T2, T3> (Expression<Action<T1, T2, T3>> f)
- expr <T1, T2, T3, T4> (Expression<Action<T1, T2, T3, T4>> f)
- expr <T1, T2, T3, T4, T5> (Expression<Action<T1, T2, T3, T4, T5>> f)
- expr <T1, T2, T3, T4, T5, T6> (Expression<Action<T1, T2, T3, T4, T5, T6>> f)
- expr <T1, T2, T3, T4, T5, T6, T7> (Expression<Action<T1, T2, T3, T4, T5, T6, T7>> f)
- compose <T1, T2> (Func<T1> a, Func<T1, T2> b)
- compose <T1, T2, T3> (Func<T1, T2> a, Func<T2, T3> b)
- compose <T1, T2, T3, T4> (Func<T1, T2> a, Func<T2, T3> b, Func<T3, T4> c)
- compose <T1, T2, T3, T4, T5> (Func<T1, T2> a, Func<T2, T3> b, Func<T3, T4> c, Func<T4, T5> d)
- compose <T1, T2, T3, T4, T5, T6> (Func<T1, T2> a, Func<T2, T3> b, Func<T3, T4> c, Func<T4, T5> d, Func<T5, T6> e)
- compose <T1, T2, T3, T4, T5, T6, T7> (Func<T1, T2> a, Func<T2, T3> b, Func<T3, T4> c, Func<T4, T5> d, Func<T5, T6> e, Func<T6, T7> f)
- Prelude
- pipe <A, B> (A x, Func<A, B> f)
- pipe <A, B, C> (A x, Func<A, B> f, Func<B, C> g)
- pipe <A, B, C, D> (A x, Func<A, B> f, Func<B, C> g, Func<C, D> h)
- pipe <A, B, C, D, E> (A x, Func<A, B> f, Func<B, C> g, Func<C, D> h, Func<D, E> i)
- pipe <A, B, C, D, E, F> (A x, Func<A, B> f, Func<B, C> g, Func<C, D> h, Func<D, E> i, Func<E, F> j)
- pipe <A, B, C, D, E, F, G> (A x, Func<A, B> f, Func<B, C> g, Func<C, D> h, Func<D, E> i, Func<E, F> j, Func<F, G> k)
- pipe <A, B, C, D, E, F, G, H> (A x, Func<A, B> f, Func<B, C> g, Func<C, D> h, Func<D, E> i, Func<E, F> j, Func<F, G> k, Func<G, H> l)
- pipe <A, B, C, D, E, F, G, H, I> (A x, Func<A, B> f, Func<B, C> g, Func<C, D> h, Func<D, E> i, Func<E, F> j, Func<F, G> k, Func<G, H> l, Func<H, I> m)
Methods
method Func<R> fun <R> (Func<R> f) Source #
Func type inference helper
Try it with lambdas, instead of doing:
Func<int,int,int> add = (int x, int y) => x + y;
You can use this function and do:
var add = fun((int x, int y) => x + y);
Parameters
| param | f | Function to infer |
| returns | The same func you gave it, but allows the type system to work out what f is | |
method Func<T1, R> fun <T1, R> (Func<T1, R> f) Source #
Func type inference helper
Try it with lambdas, instead of doing:
Func<int,int,int> add = (int x, int y) => x + y;
You can use this function and do:
var add = fun((int x, int y) => x + y);
Parameters
| param | f | Function to infer |
| returns | The same func you gave it, but allows the type system to work out what f is | |
method Func<T1, T2, R> fun <T1, T2, R> (Func<T1, T2, R> f) Source #
Func type inference helper
Try it with lambdas, instead of doing:
Func<int,int,int> add = (int x, int y) => x + y;
You can use this function and do:
var add = fun((int x, int y) => x + y);
Parameters
| param | f | Function to infer |
| returns | The same func you gave it, but allows the type system to work out what f is | |
method Func<T1, T2, T3, R> fun <T1, T2, T3, R> (Func<T1, T2, T3, R> f) Source #
Func type inference helper
Try it with lambdas, instead of doing:
Func<int,int,int> add = (int x, int y) => x + y;
You can use this function and do:
var add = fun((int x, int y) => x + y);
Parameters
| param | f | Function to infer |
| returns | The same func you gave it, but allows the type system to work out what f is | |
method Func<T1, T2, T3, T4, R> fun <T1, T2, T3, T4, R> (Func<T1, T2, T3, T4, R> f) Source #
Func type inference helper
Try it with lambdas, instead of doing:
Func<int,int,int> add = (int x, int y) => x + y;
You can use this function and do:
var add = fun((int x, int y) => x + y);
Parameters
| param | f | Function to infer |
| returns | The same func you gave it, but allows the type system to work out what f is | |
method Func<T1, T2, T3, T4, T5, R> fun <T1, T2, T3, T4, T5, R> (Func<T1, T2, T3, T4, T5, R> f) Source #
Func type inference helper
Try it with lambdas, instead of doing:
Func<int,int,int> add = (int x, int y) => x + y;
You can use this function and do:
var add = fun((int x, int y) => x + y);
Parameters
| param | f | Function to infer |
| returns | The same func you gave it, but allows the type system to work out what f is | |
method Func<T1, T2, T3, T4, T5, T6, R> fun <T1, T2, T3, T4, T5, T6, R> (Func<T1, T2, T3, T4, T5, T6, R> f) Source #
Func type inference helper
Try it with lambdas, instead of doing:
Func<int,int,int> add = (int x, int y) => x + y;
You can use this function and do:
var add = fun((int x, int y) => x + y);
Parameters
| param | f | Function to infer |
| returns | The same func you gave it, but allows the type system to work out what f is | |
method Func<T1, T2, T3, T4, T5, T6, T7, R> fun <T1, T2, T3, T4, T5, T6, T7, R> (Func<T1, T2, T3, T4, T5, T6, T7, R> f) Source #
Func type inference helper
Try it with lambdas, instead of doing:
Func<int,int,int> add = (int x, int y) => x + y;
You can use this function and do:
var add = fun((int x, int y) => x + y);
Parameters
| param | f | Function to infer |
| returns | The same func you gave it, but allows the type system to work out what f is | |
method Func<Unit> fun (Action f) Source #
Action type inference helper and converts it to a Func that returns a Unit instead of void
Try it with lambdas, instead of doing:
Func<string,Unit> putStr = (string x) => { Console.WriteLine(x); return unit; }
You can use this function and do:
var putStr = fun((string x) => Console.WriteLine(x) );
Parameters
| param | f | Function to infer |
| returns | Func that returns a Unit | |
method Func<T1, Unit> fun <T1> (Action<T1> f) Source #
Action type inference helper and converts it to a Func that returns a Unit instead of void
Try it with lambdas, instead of doing:
Func<string,Unit> putStr = (string x) => { Console.WriteLine(x); return unit; }
You can use this function and do:
var putStr = fun((string x) => Console.WriteLine(x) );
Parameters
| param | f | Function to infer |
| returns | Func that returns a Unit | |
method Func<T1, T2, Unit> fun <T1, T2> (Action<T1, T2> f) Source #
Action type inference helper and converts it to a Func that returns a Unit instead of void
Try it with lambdas, instead of doing:
Func<string,Unit> putStr = (string x) => { Console.WriteLine(x); return unit; }
You can use this function and do:
var putStr = fun((string x) => Console.WriteLine(x) );
Parameters
| param | f | Function to infer |
| returns | Func that returns a Unit | |
method Func<T1, T2, T3, Unit> fun <T1, T2, T3> (Action<T1, T2, T3> f) Source #
Action type inference helper and converts it to a Func that returns a Unit instead of void
Try it with lambdas, instead of doing:
Func<string,Unit> putStr = (string x) => { Console.WriteLine(x); return unit; }
You can use this function and do:
var putStr = fun((string x) => Console.WriteLine(x) );
Parameters
| param | f | Function to infer |
| returns | Func that returns a Unit | |
method Func<T1, T2, T3, T4, Unit> fun <T1, T2, T3, T4> (Action<T1, T2, T3, T4> f) Source #
Action type inference helper and converts it to a Func that returns a Unit instead of void
Try it with lambdas, instead of doing:
Func<string,Unit> putStr = (string x) => { Console.WriteLine(x); return unit; }
You can use this function and do:
var putStr = fun((string x) => Console.WriteLine(x) );
Parameters
| param | f | Function to infer |
| returns | Func that returns a Unit | |
method Func<T1, T2, T3, T4, T5, Unit> fun <T1, T2, T3, T4, T5> (Action<T1, T2, T3, T4, T5> f) Source #
Action type inference helper and converts it to a Func that returns a Unit instead of void
Try it with lambdas, instead of doing:
Func<string,Unit> putStr = (string x) => { Console.WriteLine(x); return unit; }
You can use this function and do:
var putStr = fun((string x) => Console.WriteLine(x) );
Parameters
| param | f | Function to infer |
| returns | Func that returns a Unit | |
method Func<T1, T2, T3, T4, T5, T6, Unit> fun <T1, T2, T3, T4, T5, T6> (Action<T1, T2, T3, T4, T5, T6> f) Source #
Action type inference helper and converts it to a Func that returns a Unit instead of void
Try it with lambdas, instead of doing:
Func<string,Unit> putStr = (string x) => { Console.WriteLine(x); return unit; }
You can use this function and do:
var putStr = fun((string x) => Console.WriteLine(x) );
Parameters
| param | f | Function to infer |
| returns | Func that returns a Unit | |
method Func<T1, T2, T3, T4, T5, T6, T7, Unit> fun <T1, T2, T3, T4, T5, T6, T7> (Action<T1, T2, T3, T4, T5, T6, T7> f) Source #
Action type inference helper and converts it to a Func that returns a Unit instead of void
Try it with lambdas, instead of doing:
Func<string,Unit> putStr = (string x) => { Console.WriteLine(x); return unit; }
You can use this function and do:
var putStr = fun((string x) => Console.WriteLine(x) );
Parameters
| param | f | Function to infer |
| returns | Func that returns a Unit | |
method Action act (Action f) Source #
Action type inference helper
Try it with lambdas, instead of doing:
Action<string> putStr = (string x) => Console.WriteLine(x);
You can use this function and do:
var putStr = act((string x) => Console.WriteLine(x));
Parameters
| param | f | Action to infer |
| returns | The same Action you gave it, but allows the type system to work out what f is | |
method Action<T1> act <T1> (Action<T1> f) Source #
Action type inference helper
Try it with lambdas, instead of doing:
Action<string> putStr = (string x) => Console.WriteLine(x);
You can use this function and do:
var putStr = act((string x) => Console.WriteLine(x));
Parameters
| param | f | Action to infer |
| returns | The same Action you gave it, but allows the type system to work out what f is | |
method Action<T1, T2> act <T1, T2> (Action<T1, T2> f) Source #
Action type inference helper
Try it with lambdas, instead of doing:
Action<string> putStr = (string x) => Console.WriteLine(x);
You can use this function and do:
var putStr = act((string x) => Console.WriteLine(x));
Parameters
| param | f | Action to infer |
| returns | The same Action you gave it, but allows the type system to work out what f is | |
method Action<T1, T2, T3> act <T1, T2, T3> (Action<T1, T2, T3> f) Source #
Action type inference helper
Try it with lambdas, instead of doing:
Action<string> putStr = (string x) => Console.WriteLine(x);
You can use this function and do:
var putStr = act((string x) => Console.WriteLine(x));
Parameters
| param | f | Action to infer |
| returns | The same Action you gave it, but allows the type system to work out what f is | |
method Action<T1, T2, T3, T4> act <T1, T2, T3, T4> (Action<T1, T2, T3, T4> f) Source #
Action type inference helper
Try it with lambdas, instead of doing:
Action<string> putStr = (string x) => Console.WriteLine(x);
You can use this function and do:
var putStr = act((string x) => Console.WriteLine(x));
Parameters
| param | f | Action to infer |
| returns | The same Action you gave it, but allows the type system to work out what f is | |
method Action<T1, T2, T3, T4, T5> act <T1, T2, T3, T4, T5> (Action<T1, T2, T3, T4, T5> f) Source #
Action type inference helper
Try it with lambdas, instead of doing:
Action<string> putStr = (string x) => Console.WriteLine(x);
You can use this function and do:
var putStr = act((string x) => Console.WriteLine(x));
Parameters
| param | f | Action to infer |
| returns | The same Action you gave it, but allows the type system to work out what f is | |
method Action<T1, T2, T3, T4, T5, T6> act <T1, T2, T3, T4, T5, T6> (Action<T1, T2, T3, T4, T5, T6> f) Source #
Action type inference helper
Try it with lambdas, instead of doing:
Action<string> putStr = (string x) => Console.WriteLine(x);
You can use this function and do:
var putStr = act((string x) => Console.WriteLine(x));
Parameters
| param | f | Action to infer |
| returns | The same Action you gave it, but allows the type system to work out what f is | |
method Action<T1, T2, T3, T4, T5, T6, T7> act <T1, T2, T3, T4, T5, T6, T7> (Action<T1, T2, T3, T4, T5, T6, T7> f) Source #
Action type inference helper
Try it with lambdas, instead of doing:
Action<string> putStr = (string x) => Console.WriteLine(x);
You can use this function and do:
var putStr = act((string x) => Console.WriteLine(x));
Parameters
| param | f | Action to infer |
| returns | The same Action you gave it, but allows the type system to work out what f is | |
method Action act <R> (Func<R> f) Source #
Func type inference helper; converts it to an Action by dropping the return value
Try it with lambdas, instead of doing:
Func<string, string> thereIs = ...
Action<string,Unit> thereIsNoReturn = (string x) => { thereis(x); };
You can use this function and do:
var thereIsNoReturn = act(thereIs);
Parameters
| param | f | Function to infer |
| returns | Action that is the same as the Func passed in, but with the return type dropped | |
method Action<T1> act <T1, R> (Func<T1, R> f) Source #
Func type inference helper; converts it to an Action by dropping the return value
Try it with lambdas, instead of doing:
Func<string, string> thereIs = ...
Action<string,Unit> thereIsNoReturn = (string x) => { thereis(x); };
You can use this function and do:
var thereIsNoReturn = act(thereIs);
Parameters
| param | f | Function to infer |
| returns | Action that is the same as the Func passed in, but with the return type dropped | |
method Action<T1, T2> act <T1, T2, R> (Func<T1, T2, R> f) Source #
Func type inference helper; converts it to an Action by dropping the return value
Try it with lambdas, instead of doing:
Func<string, string> thereIs = ...
Action<string,Unit> thereIsNoReturn = (string x) => { thereis(x); };
You can use this function and do:
var thereIsNoReturn = act(thereIs);
Parameters
| param | f | Function to infer |
| returns | Action that is the same as the Func passed in, but with the return type dropped | |
method Action<T1, T2, T3> act <T1, T2, T3, R> (Func<T1, T2, T3, R> f) Source #
Func type inference helper; converts it to an Action by dropping the return value
Try it with lambdas, instead of doing:
Func<string, string> thereIs = ...
Action<string,Unit> thereIsNoReturn = (string x) => { thereis(x); };
You can use this function and do:
var thereIsNoReturn = act(thereIs);
Parameters
| param | f | Function to infer |
| returns | Action that is the same as the Func passed in, but with the return type dropped | |
method Action<T1, T2, T3, T4> act <T1, T2, T3, T4, R> (Func<T1, T2, T3, T4, R> f) Source #
Func type inference helper; converts it to an Action by dropping the return value
Try it with lambdas, instead of doing:
Func<string, string> thereIs = ...
Action<string,Unit> thereIsNoReturn = (string x) => { thereis(x); };
You can use this function and do:
var thereIsNoReturn = act(thereIs);
Parameters
| param | f | Function to infer |
| returns | Action that is the same as the Func passed in, but with the return type dropped | |
method Action<T1, T2, T3, T4, T5> act <T1, T2, T3, T4, T5, R> (Func<T1, T2, T3, T4, T5, R> f) Source #
Func type inference helper; converts it to an Action by dropping the return value
Try it with lambdas, instead of doing:
Func<string, string> thereIs = ...
Action<string,Unit> thereIsNoReturn = (string x) => { thereis(x); };
You can use this function and do:
var thereIsNoReturn = act(thereIs);
Parameters
| param | f | Function to infer |
| returns | Action that is the same as the Func passed in, but with the return type dropped | |
method Action<T1, T2, T3, T4, T5, T6> act <T1, T2, T3, T4, T5, T6, R> (Func<T1, T2, T3, T4, T5, T6, R> f) Source #
Func type inference helper; converts it to an Action by dropping the return value
Try it with lambdas, instead of doing:
Func<string, string> thereIs = ...
Action<string,Unit> thereIsNoReturn = (string x) => { thereis(x); };
You can use this function and do:
var thereIsNoReturn = act(thereIs);
Parameters
| param | f | Function to infer |
| returns | Action that is the same as the Func passed in, but with the return type dropped | |
method Action<T1, T2, T3, T4, T5, T6, T7> act <T1, T2, T3, T4, T5, T6, T7, R> (Func<T1, T2, T3, T4, T5, T6, T7, R> f) Source #
Func type inference helper; converts it to an Action by dropping the return value
Try it with lambdas, instead of doing:
Func<string, string> thereIs = ...
Action<string,Unit> thereIsNoReturn = (string x) => { thereis(x); };
You can use this function and do:
var thereIsNoReturn = act(thereIs);
Parameters
| param | f | Function to infer |
| returns | Action that is the same as the Func passed in, but with the return type dropped | |
method Expression<Func<R>> expr <R> (Expression<Func<R>> f) Source #
Expression inference
Parameters
| returns | Same expression passed in, just gives the type system a chance to infer | |
method Expression<Func<T1, R>> expr <T1, R> (Expression<Func<T1, R>> f) Source #
Expression inference
Parameters
| returns | Same expression passed in, just gives the type system a chance to infer | |
method Expression<Func<T1, T2, R>> expr <T1, T2, R> (Expression<Func<T1, T2, R>> f) Source #
Expression inference
Parameters
| returns | Same expression passed in, just gives the type system a chance to infer | |
method Expression<Func<T1, T2, T3, R>> expr <T1, T2, T3, R> (Expression<Func<T1, T2, T3, R>> f) Source #
Expression inference
Parameters
| returns | Same expression passed in, just gives the type system a chance to infer | |
method Expression<Func<T1, T2, T3, T4, R>> expr <T1, T2, T3, T4, R> (Expression<Func<T1, T2, T3, T4, R>> f) Source #
Expression inference
Parameters
| returns | Same expression passed in, just gives the type system a chance to infer | |
method Expression<Func<T1, T2, T3, T4, T5, R>> expr <T1, T2, T3, T4, T5, R> (Expression<Func<T1, T2, T3, T4, T5, R>> f) Source #
Expression inference
Parameters
| returns | Same expression passed in, just gives the type system a chance to infer | |
method Expression<Func<T1, T2, T3, T4, T5, T6, R>> expr <T1, T2, T3, T4, T5, T6, R> (Expression<Func<T1, T2, T3, T4, T5, T6, R>> f) Source #
Expression inference
Parameters
| returns | Same expression passed in, just gives the type system a chance to infer | |
method Expression<Func<T1, T2, T3, T4, T5, T6, T7, R>> expr <T1, T2, T3, T4, T5, T6, T7, R> (Expression<Func<T1, T2, T3, T4, T5, T6, T7, R>> f) Source #
Expression inference
Parameters
| returns | Same expression passed in, just gives the type system a chance to infer | |
method Expression<Action> expr (Expression<Action> f) Source #
Expression inference
Parameters
| returns | Same expression passed in, just gives the type system a chance to infer | |
method Expression<Action<T1>> expr <T1> (Expression<Action<T1>> f) Source #
Expression inference
Parameters
| returns | Same expression passed in, just gives the type system a chance to infer | |
method Expression<Action<T1, T2>> expr <T1, T2> (Expression<Action<T1, T2>> f) Source #
Expression inference
Parameters
| returns | Same expression passed in, just gives the type system a chance to infer | |
method Expression<Action<T1, T2, T3>> expr <T1, T2, T3> (Expression<Action<T1, T2, T3>> f) Source #
Expression inference
Parameters
| returns | Same expression passed in, just gives the type system a chance to infer | |
method Expression<Action<T1, T2, T3, T4>> expr <T1, T2, T3, T4> (Expression<Action<T1, T2, T3, T4>> f) Source #
Expression inference
Parameters
| returns | Same expression passed in, just gives the type system a chance to infer | |
method Expression<Action<T1, T2, T3, T4, T5>> expr <T1, T2, T3, T4, T5> (Expression<Action<T1, T2, T3, T4, T5>> f) Source #
Expression inference
Parameters
| returns | Same expression passed in, just gives the type system a chance to infer | |
method Expression<Action<T1, T2, T3, T4, T5, T6>> expr <T1, T2, T3, T4, T5, T6> (Expression<Action<T1, T2, T3, T4, T5, T6>> f) Source #
Expression inference
Parameters
| returns | Same expression passed in, just gives the type system a chance to infer | |
method Expression<Action<T1, T2, T3, T4, T5, T6, T7>> expr <T1, T2, T3, T4, T5, T6, T7> (Expression<Action<T1, T2, T3, T4, T5, T6, T7>> f) Source #
Expression inference
Parameters
| returns | Same expression passed in, just gives the type system a chance to infer | |
method Func<T2> compose <T1, T2> (Func<T1> a, Func<T1, T2> b) Source #
Function composition
Parameters
| returns | b(a(())) | |
method Func<T1, T3> compose <T1, T2, T3> (Func<T1, T2> a, Func<T2, T3> b) Source #
Function composition
Parameters
| returns | b(a(v)) | |
method Func<T1, T4> compose <T1, T2, T3, T4> (Func<T1, T2> a, Func<T2, T3> b, Func<T3, T4> c) Source #
Function composition
Parameters
| returns | c(b(a(v))) | |
method Func<T1, T5> compose <T1, T2, T3, T4, T5> (Func<T1, T2> a, Func<T2, T3> b, Func<T3, T4> c, Func<T4, T5> d) Source #
Function composition
Parameters
| returns | c(b(a(v))) | |
Methods
method D pipe <A, B, C, D> (A x, Func<A, B> f, Func<B, C> g, Func<C, D> h) Source #
Apply function to argument
method E pipe <A, B, C, D, E> (A x, Func<A, B> f, Func<B, C> g, Func<C, D> h, Func<D, E> i) Source #
Apply function to argument
method F pipe <A, B, C, D, E, F> (A x, Func<A, B> f, Func<B, C> g, Func<C, D> h, Func<D, E> i, Func<E, F> j) Source #
Apply function to argument
method G pipe <A, B, C, D, E, F, G> (A x, Func<A, B> f, Func<B, C> g, Func<C, D> h, Func<D, E> i, Func<E, F> j, Func<F, G> k) Source #
Apply function to argument