/// <summary>
/// Returns the right-to-left Kleisli composition of the provided functions,each of which must return a value of a type supported by [`chain`](#chain).`R.composeK(h, g, f)` is equivalent to `R.compose(R.chain(h), R.chain(g), R.chain(f))`.
/// <para />
/// sig: Chain m => ((y -> m z), (x -> m y), ..., (a -> m b)) -> (a -> m z)
/// </summary>
/// <returns>Function</returns>
public static dynamic ComposeK(RamdaPlaceholder functions = null)
{
return(Currying.ComposeK(functions));
}
/// <summary>
/// Reports whether two objects have the same value, in `R.equals` terms, forthe specified property. Useful as a curried predicate.
/// <para />
/// sig: k -> {k: v} -> {k: v} -> Boolean
/// </summary>
/// <param name="prop">The name of the property to compare</param>
/// <param name="obj1">second</param>
/// <param name="obj2">third</param>
/// <returns>Boolean</returns>
public static dynamic EqProps <TArg1>(string props, TArg1 obj1, RamdaPlaceholder obj2 = null)
{
return(Currying.EqProps(props, obj1, obj2));
}
/// <summary>
/// Determines whether a given string matches a given regular expression.
/// <para />
/// sig: RegExp -> String -> Boolean
/// </summary>
/// <param name="pattern">first</param>
/// <param name="str">second</param>
/// <returns>Boolean</returns>
/// <see cref="R.Match"/>
public static dynamic Test(string pattern, RamdaPlaceholder str = null)
{
return(Currying.Test(new Regex(pattern), str));
}
/// <summary>
/// The complement of `filter`.Acts as a transducer if a transformer is given in list position.
/// <para />
/// sig: Filterable f => (a -> Boolean) -> f a -> f a
/// </summary>
/// <param name="pred">first</param>
/// <param name="filterable">second</param>
/// <returns>Array</returns>
/// <see cref="R.Filter"/>
/// <see cref="R.Transduce"/>
/// <see cref="R.AddIndex"/>
public static dynamic Reject <TTarget>(RamdaPlaceholder pred, TTarget filterable)
{
return(Currying.Reject(pred, filterable));
}
/// <summary>
/// The complement of `filter`.Acts as a transducer if a transformer is given in list position.
/// <para />
/// sig: Filterable f => (a -> Boolean) -> f a -> f a
/// </summary>
/// <param name="pred">first</param>
/// <param name="filterable">second</param>
/// <returns>Array</returns>
/// <see cref="R.Filter"/>
/// <see cref="R.Transduce"/>
/// <see cref="R.AddIndex"/>
public static dynamic Reject(dynamic pred, RamdaPlaceholder filterable = null)
{
return(Currying.Reject(Delegate(pred), filterable));
}
/// <summary>
/// Returns whether or not an object has an own property with the specified name
/// <para />
/// sig: s -> {s: x} -> Boolean
/// </summary>
/// <param name="prop">The name of the property to check for.</param>
/// <param name="obj">The object to query.</param>
/// <returns>Whether the property exists.</returns>
public static dynamic Has(RamdaPlaceholder prop = null, RamdaPlaceholder obj = null)
{
return(Currying.Has(prop, obj));
}
/// <summary>
/// Adds two values.
/// <para />
/// sig: Number -> Number -> Number
/// </summary>
/// <param name="a">first</param>
/// <param name="b">second</param>
/// <returns>Number</returns>
/// <see cref="R.Subtract"/>
public static dynamic Add(object a, RamdaPlaceholder b = null)
{
return(Currying.Add(a, b));
}
/// <summary>
/// Returns a string made by inserting the `separator` between each element andconcatenating all the elements into a single string.
/// <para />
/// sig: String -> [a] -> String
/// </summary>
/// <param name="separator">The string used to separate the elements.</param>
/// <param name="xs">The elements to join into a string.</param>
/// <returns>str The string made by concatenating `xs` with `separator`.</returns>
/// <see cref="R.Split"/>
public static dynamic Join(RamdaPlaceholder separator = null, RamdaPlaceholder xs = null)
{
return(Currying.Join(separator, xs));
}
/// <summary>
/// Returns a new list without any consecutively repeating elements. `R.equals`is used to determine equality.Acts as a transducer if a transformer is given in list position.
/// <para />
/// sig: [a] -> [a]
/// </summary>
/// <param name="list">The array to consider.</param>
/// <returns>`list` without repeating elements.</returns>
/// <see cref="R.Transduce"/>
public static dynamic DropRepeats(RamdaPlaceholder list = null)
{
return(Currying.DropRepeats(list));
}
/// <summary>
/// Takes a list of predicates and returns a predicate that returns true for agiven list of arguments if at least one of the provided predicates issatisfied by those arguments.The function returned is a curried function whose arity matches that of thehighest-arity predicate.
/// <para />
/// sig: [(*... -> Boolean)] -> (*... -> Boolean)
/// </summary>
/// <param name="predicates">An array of predicates to check</param>
/// <returns>The combined predicate</returns>
/// <see cref="R.AllPass"/>
public static dynamic AnyPass(RamdaPlaceholder preds = null)
{
return(Currying.AnyPass(preds));
}
/// <summary>
/// Returns a string made by inserting the `separator` between each element andconcatenating all the elements into a single string.
/// <para />
/// sig: String -> [a] -> String
/// </summary>
/// <param name="separator">The string used to separate the elements.</param>
/// <param name="xs">The elements to join into a string.</param>
/// <returns>str The string made by concatenating `xs` with `separator`.</returns>
/// <see cref="R.Split"/>
public static dynamic Join <TSource>(RamdaPlaceholder separator, IList <TSource> xs)
{
return(Currying.Join(separator, xs));
}
/// <summary>
/// Returns whether or not an object or its prototype chain has a property withthe specified name
/// <para />
/// sig: s -> {s: x} -> Boolean
/// </summary>
/// <param name="prop">The name of the property to check for.</param>
/// <param name="obj">The object to query.</param>
/// <returns>Whether the property exists.</returns>
public static dynamic HasIn(string prop, RamdaPlaceholder obj = null)
{
return(Currying.HasIn(prop, obj));
}
/// <summary>
/// A function that returns the `!` of its argument. It will return `true` whenpassed false-y value, and `false` when passed a truth-y one.
/// <para />
/// sig: * -> Boolean
/// </summary>
/// <param name="a">any value</param>
/// <returns>the logical inverse of passed argument.</returns>
/// <see cref="R.Complement"/>
public static dynamic Not(RamdaPlaceholder a = null)
{
return(Currying.Not(a));
}
/// <summary>
/// Negates its argument.
/// <para />
/// sig: Number -> Number
/// </summary>
/// <param name="n">first</param>
/// <returns>Number</returns>
public static dynamic Negate(RamdaPlaceholder n = null)
{
return(Currying.Negate(n));
}
/// <summary>
/// Returns a fixed list of size `n` containing a specified identical value.
/// <para />
/// sig: a -> n -> [a]
/// </summary>
/// <param name="value">The value to repeat.</param>
/// <param name="n">The desired size of the output list.</param>
/// <returns>A new array containing `n` `value`s.</returns>
public static dynamic Repeat(RamdaPlaceholder value = null, RamdaPlaceholder n = null)
{
return(Currying.Repeat(value, n));
}
/// <summary>
/// A function wrapping calls to the two functions in an `||` operation,returning the result of the first function if it is truth-y and the resultof the second function otherwise. Note that this is short-circuited,meaning that the second function will not be invoked if the first returns atruth-y value.In addition to functions, `R.either` also accepts any fantasy-land compatibleapplicative functor.
/// <para />
/// sig: (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)
/// </summary>
/// <param name="f">a predicate</param>
/// <param name="g">another predicate</param>
/// <returns>a function that applies its arguments to `f` and `g` and `||`s their outputs together.</returns>
/// <see cref="R.Or"/>
public static dynamic Either(RamdaPlaceholder f = null, RamdaPlaceholder g = null)
{
return(Currying.Either(f, g));
}
/// <summary>
/// Returns whether or not an object has an own property with the specified name
/// <para />
/// sig: s -> {s: x} -> Boolean
/// </summary>
/// <param name="prop">The name of the property to check for.</param>
/// <param name="obj">The object to query.</param>
/// <returns>Whether the property exists.</returns>
public static dynamic Has <TTarget>(RamdaPlaceholder prop, TTarget obj)
{
return(Currying.Has(prop, obj));
}
/// <summary>
/// A function wrapping calls to the two functions in an `||` operation,returning the result of the first function if it is truth-y and the resultof the second function otherwise. Note that this is short-circuited,meaning that the second function will not be invoked if the first returns atruth-y value.In addition to functions, `R.either` also accepts any fantasy-land compatibleapplicative functor.
/// <para />
/// sig: (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)
/// </summary>
/// <param name="f">a predicate</param>
/// <param name="g">another predicate</param>
/// <returns>a function that applies its arguments to `f` and `g` and `||`s their outputs together.</returns>
/// <see cref="R.Or"/>
public static dynamic Either <TSource>(RamdaPlaceholder f, Func <TSource, bool> g)
{
return(Currying.Either(f, Delegate(g)));
}
/// <summary>
/// Adds two values.
/// <para />
/// sig: Number -> Number -> Number
/// </summary>
/// <param name="a">first</param>
/// <param name="b">second</param>
/// <returns>Number</returns>
/// <see cref="R.Subtract"/>
public static dynamic Add(RamdaPlaceholder a, object b)
{
return(Currying.Add(a, b));
}
/// <summary>
/// A function wrapping calls to the two functions in an `||` operation,returning the result of the first function if it is truth-y and the resultof the second function otherwise. Note that this is short-circuited,meaning that the second function will not be invoked if the first returns atruth-y value.In addition to functions, `R.either` also accepts any fantasy-land compatibleapplicative functor.
/// <para />
/// sig: (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)
/// </summary>
/// <param name="f">a predicate</param>
/// <param name="g">another predicate</param>
/// <returns>a function that applies its arguments to `f` and `g` and `||`s their outputs together.</returns>
/// <see cref="R.Or"/>
public static dynamic Either <TSource>(Func <TSource, bool> f, RamdaPlaceholder g = null)
{
return(Currying.Either(Delegate(f), g));
}
/// <summary>
/// The complement of `filter`.Acts as a transducer if a transformer is given in list position.
/// <para />
/// sig: Filterable f => (a -> Boolean) -> f a -> f a
/// </summary>
/// <param name="pred">first</param>
/// <param name="filterable">second</param>
/// <returns>Array</returns>
/// <see cref="R.Filter"/>
/// <see cref="R.Transduce"/>
/// <see cref="R.AddIndex"/>
public static dynamic Reject(RamdaPlaceholder pred = null, RamdaPlaceholder filterable = null)
{
return(Currying.Reject(pred, filterable));
}
/// <summary>
/// A function wrapping calls to the two functions in an `||` operation,returning the result of the first function if it is truth-y and the resultof the second function otherwise. Note that this is short-circuited,meaning that the second function will not be invoked if the first returns atruth-y value.In addition to functions, `R.either` also accepts any fantasy-land compatibleapplicative functor.
/// <para />
/// sig: (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)
/// </summary>
/// <param name="f">a predicate</param>
/// <param name="g">another predicate</param>
/// <returns>a function that applies its arguments to `f` and `g` and `||`s their outputs together.</returns>
/// <see cref="R.Or"/>
public static dynamic Either(RamdaPlaceholder f, dynamic g)
{
return(Currying.Either(f, Delegate(g)));
}
/// <summary>
/// The complement of `filter`.Acts as a transducer if a transformer is given in list position.
/// <para />
/// sig: Filterable f => (a -> Boolean) -> f a -> f a
/// </summary>
/// <param name="pred">first</param>
/// <param name="filterable">second</param>
/// <returns>Array</returns>
/// <see cref="R.Filter"/>
/// <see cref="R.Transduce"/>
/// <see cref="R.AddIndex"/>
public static dynamic Reject <TArg>(Func <TArg, bool> pred, RamdaPlaceholder filterable = null)
{
return(Currying.Reject(Delegate(pred), filterable));
}
/// <summary>
/// A function wrapping calls to the two functions in an `||` operation,returning the result of the first function if it is truth-y and the resultof the second function otherwise. Note that this is short-circuited,meaning that the second function will not be invoked if the first returns atruth-y value.In addition to functions, `R.either` also accepts any fantasy-land compatibleapplicative functor.
/// <para />
/// sig: (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)
/// </summary>
/// <param name="f">a predicate</param>
/// <param name="g">another predicate</param>
/// <returns>a function that applies its arguments to `f` and `g` and `||`s their outputs together.</returns>
/// <see cref="R.Or"/>
public static dynamic Either(dynamic f, RamdaPlaceholder g = null)
{
return(Currying.Either(Delegate(f), g));
}
/// <summary>
/// Reports whether two objects have the same value, in `R.equals` terms, forthe specified property. Useful as a curried predicate.
/// <para />
/// sig: k -> {k: v} -> {k: v} -> Boolean
/// </summary>
/// <param name="prop">The name of the property to compare</param>
/// <param name="obj1">second</param>
/// <param name="obj2">third</param>
/// <returns>Boolean</returns>
public static dynamic EqProps <TArg1, TArg2>(RamdaPlaceholder props, TArg1 obj1, TArg2 obj2)
{
return(Currying.EqProps(props, obj1, obj2));
}
/// <summary>
/// Returns a fixed list of size `n` containing a specified identical value.
/// <para />
/// sig: a -> n -> [a]
/// </summary>
/// <param name="value">The value to repeat.</param>
/// <param name="n">The desired size of the output list.</param>
/// <returns>A new array containing `n` `value`s.</returns>
public static dynamic Repeat(RamdaPlaceholder value, int n)
{
return(Currying.Repeat(value, n));
}
/// <summary>
/// Reports whether two objects have the same value, in `R.equals` terms, forthe specified property. Useful as a curried predicate.
/// <para />
/// sig: k -> {k: v} -> {k: v} -> Boolean
/// </summary>
/// <param name="prop">The name of the property to compare</param>
/// <param name="obj1">second</param>
/// <param name="obj2">third</param>
/// <returns>Boolean</returns>
public static dynamic EqProps(RamdaPlaceholder props = null, RamdaPlaceholder obj1 = null, RamdaPlaceholder obj2 = null)
{
return(Currying.EqProps(props, obj1, obj2));
}
/// <summary>
/// Returns a fixed list of size `n` containing a specified identical value.
/// <para />
/// sig: a -> n -> [a]
/// </summary>
/// <param name="value">The value to repeat.</param>
/// <param name="n">The desired size of the output list.</param>
/// <returns>A new array containing `n` `value`s.</returns>
public static dynamic Repeat <TTarget>(TTarget value, RamdaPlaceholder n = null)
{
return(Currying.Repeat(value, n));
}
/// <summary>
/// Creates a new function that, when invoked, caches the result of calling `fn`for a given argument set and returns the result. Subsequent calls to thememoized `fn` with the same argument set will not result in an additionalcall to `fn`; instead, the cached result for that set of arguments will bereturned.
/// <para />
/// sig: (*... -> a) -> (*... -> a)
/// </summary>
/// <param name="fn">The function to memoize.</param>
/// <returns>Memoized version of `fn`.</returns>
public static dynamic Memoize(RamdaPlaceholder fn = null)
{
return(Currying.Memoize(fn));
}
/// <summary>
/// Returns the result of "setting" the portion of the given data structurefocused by the given lens to the given value.
/// <para />
/// sig: Lens s a -> a -> s -> s
/// </summary>
/// <param name="lens">first</param>
/// <param name="v">second</param>
/// <param name="x">third</param>
/// <returns>*</returns>
/// <see cref="R.Prop"/>
/// <see cref="R.LensIndex"/>
/// <see cref="R.LensProp"/>
public static dynamic Set(dynamic lens, RamdaPlaceholder v = null, RamdaPlaceholder x = null)
{
return(Currying.Set(Delegate(lens), v, x));
}