/// <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));
 }
示例#2
0
 /// <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));
 }
示例#3
0
 /// <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));
 }
示例#4
0
 /// <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));
 }
示例#5
0
 /// <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));
 }
示例#6
0
 /// <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));
 }
示例#7
0
 /// <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));
 }
示例#8
0
 /// <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));
 }
示例#9
0
 /// <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));
 }
示例#10
0
 /// <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));
 }
示例#11
0
 /// <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));
 }
示例#12
0
 /// <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));
 }
示例#13
0
 /// <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));
 }
示例#14
0
 /// <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));
 }
示例#15
0
 /// <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));
 }
示例#16
0
 /// <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));
 }
示例#17
0
 /// <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));
 }
示例#18
0
 /// <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)));
 }
示例#19
0
 /// <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));
 }
示例#20
0
 /// <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));
 }
示例#21
0
 /// <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));
 }
示例#22
0
 /// <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)));
 }
示例#23
0
 /// <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));
 }
示例#24
0
 /// <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));
 }
示例#25
0
 /// <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));
 }
示例#26
0
 /// <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));
 }
示例#27
0
 /// <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));
 }
示例#28
0
 /// <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));
 }
示例#29
0
 /// <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));
 }
示例#30
0
 /// <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));
 }