/common/index.ts | rimbu@1.0.5

import * as rimbu from "https://deno.land/x/rimbu@1.0.5/common/index.ts";

Namespaces

N AsyncOptLazy
N AsyncReducer
N CollectFun
N Comp
N Eq
N ErrBase
N IndexRange
N Range
N Reducer

Classes

c AsyncReducer.Base	A base class that can be used to easily create `AsyncReducer` instances.
c ErrBase.CustomError abstract	A custom error instance.
c ErrBase.ForcedError
c Reducer.Base	A base class that can be used to easily create `Reducer` instances.

Variables

v AsyncReducer.and	Returns an `AsyncReducer` that takes boolean values and outputs true if all input values are true, and false otherwise.
v AsyncReducer.average	A `Reducer` that calculates the average of all given numberic input values.
v AsyncReducer.count	Returns an `AsyncReducer` that remembers the amount of input items provided.
v AsyncReducer.first	Returns an `AsyncReducer` that remembers the first input value.
v AsyncReducer.firstWhere	Returns an `AsyncReducer` that remembers the first input value for which the given `pred` function returns true.
v AsyncReducer.isEmpty	Returns an `AsyncReducer` that outputs true if no input values are received, false otherwise.
v AsyncReducer.last	Returns an `AsyncReducer` that remembers the last input value.
v AsyncReducer.lastWhere	Returns an `AsyncReducer` that remembers the last input value for which the given `pred` function returns true.
v AsyncReducer.max	Returns a `Reducer` that remembers the maximum value of the numberic inputs.
v AsyncReducer.maxBy	Returns a `Reducer` that remembers the maximum value of the inputs using the given `compFun` to compare input values
v AsyncReducer.min	Returns a `Reducer` that remembers the minimum value of the numberic inputs.
v AsyncReducer.minBy	Returns a `Reducer` that remembers the minimum value of the inputs using the given `compFun` to compare input values
v AsyncReducer.nonEmpty	Returns an `AsyncReducer` that outputs true if one or more input values are received, false otherwise.
v AsyncReducer.or	Returns an `AsyncReducer` that takes boolean values and outputs true if one or more input values are true, and false otherwise.
v AsyncReducer.product	A `Reducer` that calculates the product of all given numeric input values.
v AsyncReducer.sum	A `Reducer` that sums all given numeric input values.
v CollectFun.Skip	Indicates, when returned from a collect function, to skip the value.
v Eq.objectIs	An Eq instance that uses `Object.is` to determine if two objects are equal.
v Reducer.and	Returns a `Reducer` that takes boolean values and outputs true if all input values are true, and false otherwise.
v Reducer.average	A `Reducer` that calculates the average of all given numberic input values.
v Reducer.count	Returns a `Reducer` that remembers the amount of input items provided.
v Reducer.first	Returns a `Reducer` that remembers the first input value.
v Reducer.firstWhere	Returns a `Reducer` that remembers the first input value for which the given `pred` function returns true.
v Reducer.isEmpty	Returns a `Reducer` that outputs true if no input values are received, false otherwise.
v Reducer.last	Returns a `Reducer` that remembers the last input value.
v Reducer.lastWhere	Returns a `Reducer` that remembers the last input value for which the given `pred` function returns true.
v Reducer.max	Returns a `Reducer` that remembers the maximum value of the numberic inputs.
v Reducer.maxBy	Returns a `Reducer` that remembers the maximum value of the inputs using the given `compFun` to compare input values
v Reducer.min	Returns a `Reducer` that remembers the minimum value of the numberic inputs.
v Reducer.minBy	Returns a `Reducer` that remembers the minimum value of the inputs using the given `compFun` to compare input values
v Reducer.nonEmpty	Returns a `Reducer` that outputs true if one or more input values are received, false otherwise.
v Reducer.or	Returns a `Reducer` that takes boolean values and outputs true if one or more input values are true, and false otherwise.
v Reducer.product	A `Reducer` that calculates the product of all given numeric input values.
v Reducer.sum	A `Reducer` that sums all given numeric input values.

Functions

f AsyncOptLazy.toMaybePromise	Returns the value or promised value contained in an `AsyncOptLazy` instance of type T.
f AsyncOptLazy.toPromise	Returns the value contained in an `AsyncOptLazy` instance of type T as a promise.
f AsyncReducer.combineArr	Returns an `AsyncReducer` that combines multiple input `reducers` by providing input values to all of them and collecting the outputs in an array.
f AsyncReducer.combineObj	Returns an `AsyncReducer` that combines multiple input `reducers` by providing input values to all of them and collecting the outputs in the shape of the given object.
f AsyncReducer.contains	Returns an `AsyncReducer` that outputs false as long as the given `elem` has not been encountered in the input values, true otherwise.
f AsyncReducer.create	Returns an `AsyncReducer` with the given options:
f AsyncReducer.createMono	Returns an `AsyncReducer` of which the input, state, and output types are the same.
f AsyncReducer.createOutput	Returns an `AsyncReducer` of which the state and output types are the same.
f AsyncReducer.every	Returns an `AsyncReducer` that ouputs true as long as all input values satisfy the given `pred`, false otherwise.
f AsyncReducer.from
f AsyncReducer.join	Returns a `Reducer` that joins the given input values into a string using the given options.
f AsyncReducer.some	Returns a `Reducer` that ouputs false as long as no input value satisfies given `pred`, true otherwise.
f AsyncReducer.toArray	Returns an `AsyncReducer` that collects received input values in an array, and returns a copy of that array as an output value when requested.
f AsyncReducer.toJSMap	Returns a `AsyncReducer` that collects received input tuples into a mutable JS Map, and returns a copy of that map when output is requested.
f AsyncReducer.toJSObject	Returns an `AsyncReducer` that collects 2-tuples containing keys and values into a plain JS object, and returns a copy of that object when output is requested.
f AsyncReducer.toJSSet	Returns an `AsyncReducer` that collects received input values into a mutable JS Set, and returns a copy of that map when output is requested.
f Comp.anyDeepComp	Returns a Comp instance that compares any value using default comparison functions. For Iterables and objects, their elements are compared recursively.
f Comp.anyFlatComp	Returns a Comp instance that compares any value using default comparison functions, but never recursively compares Iterables or objects. In those cases, it will use the stringComp instance.
f Comp.anyShallowComp	Returns a Comp instance that compares any value using default comparison functions. For Iterables and objects, their elements are compared only one level deep for performance and to avoid infinite recursion.
f Comp.anyStringJSONComp	Returns a Comp instance converts values to string with JSON.stringify, and orders the resulting string naturally.
f Comp.anyToStringComp	Returns a any Comp instance that orders any according to their toString values.
f Comp.bigIntComp	Returns a default bigint Comp instance that orders bigint numbers naturally.
f Comp.booleanComp	Returns a default boolean Comp instance that orders booleans according to false < true.
f Comp.createValueOfComp	Returns a Comp instance that orders objects with a `valueOf` method according to the given `valueComp` instance for the valueOf values.
f Comp.dateComp	Returns a Date Comp instance that orders Dates according to their `.valueOf` value.
f Comp.defaultComp	Returns the default Comp instance, which is the Comp.anyDeepComp() instance.
f Comp.invert	Returns a Comp instance the reverses the order of the given `comp` instance.
f Comp.iterableComp	Returns a Comp instance for Iterable objects that orders the Iterables by comparing the elements with the given `itemComp` Comp instance.
f Comp.numberComp	Returns a default number Comp instance that orders numbers naturally.
f Comp.objectComp	Returns a Comp instance for objects that orders the object keys according to the given `keyComp`, and then compares the corresponding values using the given `valueComp`. Objects are then compared as follows: starting with the smallest key of either object: if only one of the objects has the key, the object with the key is considered to be larger than the other if both objects have the key, the values are compared with `valueComp`. If the values are not equal, this result is returned.
f Comp.stringCaseInsensitiveComp	Returns a `Comp` instance that compares strings in a case-insensitive way.
f Comp.stringCharCodeComp	Returns a string Comp instance that orders strings according to their indexed char codes.
f Comp.stringComp	Returns a `Comp` instance that compares strings based on the string's `localeCompare` method.
f Comp.toEq	Returns an `Eq` equality instance thet will return true when the given `comp` comparable instance returns 0.
f Comp.withNull	Returns a Comp instance that extends the given `comp` instance with the capability to handle `null` values, where null is considered to be smaller than any other value, and equal to another null.
f Comp.withUndefined	Returns a Comp instance that extends the given `comp` instance with the capability to handle `undefined` values, where undefined is considered to be smaller than any other value, and equal to another undefined.
f Eq.anyDeepEq	Returns an Eq instance that checks equality of any values. For composed values (objects and iterables) it will recursively compare the contained values.
f Eq.anyFlatEq	Returns an Eq instance that checks equality of any values. For composed values (objects and iterables) it will compare with Object.is.
f Eq.anyJsonEq	Returns an Eq instance that considers values equal their JSON.stringify values are equal.
f Eq.anyShallowEq	Returns an Eq instance that checks equality of any values. For composed values (objects and iterables) it will enter 1 level, and if again compound values are found, they are compared with Object.is.
f Eq.anyToStringEq
f Eq.convertAnyToString
f Eq.createStringCollatorEq	Returns an Eq instance that considers strings equal taking the given or default locale into account.
f Eq.dateEq	Returns an Eq instance that compares Date objects according to their `valueOf` value.
f Eq.defaultEq	Returns the default Eq instance, which is the Eq.anyDeepEq() instance.
f Eq.iterableEq	Returns an Eq instance that compares Iterables by comparing their elements with the given `itemEq` Eq instance.
f Eq.objectEq	Returns an Eq instance that checks equality of objects containing property values of type V by iteratively applying given `valueEq` to each of the object's property values.
f Eq.stringCaseInsentitiveEq	Returns an Eq instance that considers strings equal regardless of their case.
f Eq.stringCharCodeEq	Returns an Eq instance that considers strings equal when all their charcodes are equal.
f Eq.tupleSymmetric	Returns an `Eq` instance for tuples that considers two tuples [A, B] and [C, D] equal if [A, B] equals [C, D], or if [A, B] equals [D, C]
f Eq.valueOfEq	Returns an Eq instance for objects that have a `valueOf` method. It returns true if the `.valueOf` values of both given objects are equal.
f Err	Throws an `Err.ForcedError` error when called.
f ErrBase.msg	Returns a function that, when called, throws an `Err.ForcedError` with the given `message` string.
f IndexRange.getIndexRangeIndices	Returns, given the `range` `IndexRange`, a normalized tuple containing the start index, and optionally an end index.
f IndexRange.getIndicesFor	Returns, given the `range` `IndexRange`, and a target maximum `length`, the actual index range. This can be one of three options: 'empty': there are no elements within the range 'all': all elements are within the range [start: number, end: number]: an inclusive range of element indices within the given range
f OptLazy	Returns the value contained in an `OptLazy` instance of type T.
f OptLazyOr	Returns the value contained in an `OptLazyOr` instance of type T, or the given `otherValue` if the lazy function returns it.
f Range.getNormalizedRange	Simplifies a given `range` `Range` input for easier processing, by returning optional start and end ranges including whether they are inclusive or exclusive
f Reducer.combineArr	Returns a `Reducer` that combines multiple input `reducers` by providing input values to all of them and collecting the outputs in an array.
f Reducer.combineObj	Returns a `Reducer` that combines multiple input `reducers` by providing input values to all of them and collecting the outputs in the shape of the given object.
f Reducer.contains	Returns a `Reducer` that outputs false as long as the given `elem` has not been encountered in the input values, true otherwise.
f Reducer.create	Returns a `Reducer` with the given options:
f Reducer.createMono	Returns a `Reducer` of which the input, state, and output types are the same.
f Reducer.createOutput	Returns a `Reducer` of which the state and output types are the same.
f Reducer.every	Returns a `Reducer` that ouputs true as long as all input values satisfy the given `pred`, false otherwise.
f Reducer.join	Returns a `Reducer` that joins the given input values into a string using the given options.
f Reducer.some	Returns a `Reducer` that ouputs false as long as no input value satisfies given `pred`, true otherwise.
f Reducer.toArray	Returns a `Reducer` that collects received input values in an array, and returns a copy of that array as an output value when requested.
f Reducer.toJSMap	Returns a `Reducer` that collects received input tuples into a mutable JS Map, and returns a copy of that map when output is requested.
f Reducer.toJSObject	Returns a `Reducer` that collects 2-tuples containing keys and values into a plain JS object, and returns a copy of that object when output is requested.
f Reducer.toJSSet	Returns a `Reducer` that collects received input values into a mutable JS Set, and returns a copy of that map when output is requested.
f TraverseState	Returns a new `TraverseState` instance, using optionally given `startIndex` as a start index value.
f Update	Returns the result of given `update` parameter, where it can either directly give a new value, or it is a function receiving the given `value`, and returns a new value.

Interfaces

I AsyncReducer.Impl
I Comp	An object providing methods to compare two values of type `K`.
I Reducer.Impl	The Implementation interface for a `Reducer`, which also exposes the internal state type.
I ToJSON	Utility type to convert some object to a JSON serializable format.
I TraverseState	An object used to track the state of a traversal, e.g. a `forEach`.

Type Aliases

T ArrayNonEmpty	Accepts all arrays with at least one element.
T AsyncCollectFun	A potentially asynchronous function used in `collect` methods to collect values from a collection. This is basically a single-pass map and filter.
T AsyncOptLazy	A potentially lazy and/or asynchronous value of type T.
T AsyncReducer	An `AsyncReducer` is a stand-alone asynchronous calculation that takes input values of type I, and, when requested, produces an output value of type O.
T CollectFun	A function used in `collect` methods to collect values from a collection. This is basically a single-pass map and filter.
T CollectFun.Skip	Indicates, when returned from a collect function, to skip the value.
T Eq	A function returning true if given `v1` and `v2` should be considered equal.
T IndexRange	A flexible range specification for numeric indices. If a start or end is defined, a tuple can be used where the second item is a boolean indicating whether that end is inclusive or exclusive. An IndexRange can have one of the following forms: { amount: number } { start: number } { start: number, amount: number } { start: number, end: number } { start: number, end: [number, boolean] } { start: [number, boolean] } { start: [number, boolean], amount: number } { start: [number, boolean], end: number } { start: [number, boolean], end: [number, boolean] } { end: number } { end: [number, boolean] }
T MaybePromise	A type that is either a value T or a promise yielding a value of type T.
T OptLazy	A potentially lazy value of type T.
T OptLazyOr	A potentially lazy value that, in case of a lazy function, received a default value that it can return.
T Range	A range definition for any type of (orderable) value. If a start or end is defined, a tuple can be used where the second item is a boolean indicating whether that end is inclusive (true) or exclusive (false). A Range of type T can have one of the following forms: { end: T } { end: [T, boolean] } { start: T } { start: T, end: T } { start: T, end: [T, boolean] } { start: [T, boolean] } { start: [T, boolean], end: T } { start: [T, boolean], end: [T, boolean] }
T Reducer	A `Reducer` is a stand-alone calculation that takes input values of type I, and, when requested, produces an output value of type O.
T RelatedTo	Accepts all types of T and U where T extends U or U extends T.
T StringNonEmpty	Accepts all strings with at least one character.
T SubOf	Accepts all types of T and S where S extends T, and results in the lower bound S.
T SuperOf	Accepts all types of T and U where T extends U, and result in the upper bound U.
T Update	A value of type T, or a function taking a value of type T and returning a new value of type T.