@types/underscore

method cancel

cancel: () => void;

call signature

(element: T, key: CollectionKey<V>, collection: V): TResult;

property source

source: string;

call signature

(data?: any): string;

index signature

[index: string]: T;

property length

length: number;

index signature

[index: number]: T;

call signature

(prev: TResult, curr: T, key: CollectionKey<V>, collection: V): TResult;

call signature

(value: T): boolean;

property escape

escape?: RegExp | undefined;

• Default value is '/<%-([\s\S]+?)%>/g'.

property evaluate

evaluate?: RegExp | undefined;

• Default value is '/<%([\s\S]+?)%>/g'.

property interpolate

interpolate?: RegExp | undefined;

• Default value is '/<%=([\s\S]+?)%>/g'.

property variable

variable?: string | undefined;

• By default, 'template()' places the values from your data in the local scope via the 'with' statement. However, you can specify a single variable name with this setting.

property leading

leading?: boolean | undefined;

• If you'd like to disable the leading-edge call, pass this as false.

property trailing

trailing?: boolean | undefined;

• If you'd like to disable the execution on the trailing-edge, pass false.

property all

all: Underscore<T, V>['every'];

• See Also

  • every

property any

any: Underscore<T, V>['some'];

• See Also

  • some

property collect

collect: Underscore<T, V>['map'];

• See Also

  • map

property detect

detect: Underscore<T, V>['find'];

• See Also

  • find

property drop

drop: Underscore<T, V>['rest'];

• See Also

  • rest

property foldl

foldl: Underscore<T, V>['reduce'];

• See Also

  • reduce

property foldr

foldr: Underscore<T, V>['reduceRight'];

• See Also

  • reduceRight

property forEach

forEach: Underscore<T, V>['each'];

• See Also

  • each

property head

head: Underscore<T, V>['first'];

• See Also

  • first

property include

include: Underscore<T, V>['contains'];

• See Also

  • contains

property includes

includes: Underscore<T, V>['contains'];

• See Also

  • contains

property inject

inject: Underscore<T, V>['reduce'];

• See Also

  • reduce

property select

select: Underscore<T, V>['filter'];

• See Also

  • filter

property tail

tail: Underscore<T, V>['rest'];

• See Also

  • rest

property take

take: Underscore<T, V>['first'];

• See Also

  • first

property unique

unique: Underscore<T, V>['uniq'];

• See Also

  • uniq

method after

after: (fn: Function) => Function;

• Wrapped type number.

  See Also

  • _.after

method allKeys

allKeys: () => string[];

• Wrapped type object.

  See Also

  • _.allKeys

method before

before: (fn: Function) => Function;

• Wrapped type number.

  See Also

  • _.before

method bind

bind: (object: any, ...args: any[]) => Function;

• Wrapped type Function.

  See Also

  • _.bind

method bindAll

bindAll: (...methodNames: string[]) => any;

• Wrapped type object.

  See Also

  • _.bindAll

method chain

chain: () => _Chain<T, V>;

• Returns a wrapped object. Calling methods on this object will continue to return wrapped objects until value() is used.

  Returns

  An underscore chain wrapper around the wrapped value.

method chunk

chunk: (length: number) => T[][];

• Chunks the wrapped list into multiple arrays, each containing length or fewer items.

  Parameter length

  The maximum size of the chunks.

  Returns

  The contents of the wrapped list in chunks no greater than length in size.

method clone

clone: () => T;

• Wrapped type any[].

  See Also

  • _.clone

method compact

compact: () => Array<Truthy<T>>;

• Returns a copy of the wrapped list with all falsy values removed. In JavaScript, false, null, 0, "", undefined and NaN are all falsy.

  Returns

  An array containing the elements of the wrapped list without falsy values.

method compose

compose: (...functions: Function[]) => Function;

• Wrapped type Function[].

  See Also

  • _.compose

method constant

constant: () => () => T;

• Wrapped type any.

  See Also

  • _.constant

method contains

contains: (value: any, fromIndex?: number) => boolean;

• Returns true if the value is present in the wrapped collection. Uses indexOf internally, if the wrapped collection is a List. Use fromIndex to start your search at a given index.

  Parameter value

  The value to check the wrapped collection for.

  Parameter fromIndex

  The index to start searching from, optional, default = 0, only used when the wrapped collection is a List.

  Returns

  True if value is present in the wrapped collection after fromIndex, otherwise false.

method countBy

countBy: (
    iteratee?: Iteratee<V, string | number>,
    context?: any
) => Dictionary<number>;

• Sorts the wrapped collection into groups and returns a count for the number of objects in each group. Similar to groupBy, but instead of returning a list of values, returns a count for the number of values in that group.

  Parameter iteratee

  An iteratee that provides the value to count by for each item in the wrapped collection.

  Parameter context

  this object in iteratee, optional.

  Returns

  A dictionary with the group names provided by iteratee as properties where each property contains the count of the grouped elements from the wrapped collection.

method create

create: (props?: object) => any;

• Wrapped type any.

  See Also

  • _.create

method debounce

debounce: (wait: number, immediate?: boolean) => Function & _.Cancelable;

• Wrapped type Function.

  See Also

  • _.debounce

method defaults

defaults: (...defaults: any[]) => any;

• Wrapped type object.

  See Also

  • _.defaults

method defer

defer: (...args: any[]) => void;

• Wrapped type Function.

  See Also

  • _.defer

method delay

delay: { (wait: number, ...args: any[]): any; (...args: any[]): any };

• Wrapped type Function.

  See Also

  • _.delay

• See Also

  • _.delay

method difference

difference: (...others: Array<List<T>>) => T[];

• Similar to without, but returns the values from the wrapped list that are not present in others.

  Parameter list

  The starting list.

  Parameter others

  The lists of values to exclude from the wrapped list.

  Returns

  The contents of the wrapped list without the values in others.

method each

each: (
    iteratee: CollectionIterator<TypeOfCollection<V>, void, V>,
    context?: any
) => V;

• Iterates over the wrapped collection of elements, yielding each in turn to an iteratee. The iteratee is bound to the context object, if one is passed.

  Parameter iteratee

  The iteratee to call for each element in the wrapped collection.

  Parameter context

  'this' object in iteratee, optional.

  Returns

  The originally wrapped collection.

method escape

escape: () => string;

• Wrapped type string.

  See Also

  • _.escape

method every

every: (iteratee?: Iteratee<V, boolean>, context?: any) => boolean;

• Returns true if all of the values in the wrapped collection pass the iteratee truth test. Short-circuits and stops traversing the wrapped collection if a false element is found.

  Parameter iteratee

  The truth test to apply.

  Parameter context

  this object in iteratee, optional.

  Returns

  True if all elements pass the truth test, otherwise false.

method extend

extend: (...sources: any[]) => any;

• Wrapped type object.

  See Also

  • _.extend

method filter

filter: (iteratee?: Iteratee<V, boolean>, context?: any) => T[];

• Looks through each value in the wrapped collection, returning an array of all the values that pass a truth test (iteratee).

  Parameter iteratee

  The truth test to apply.

  Parameter context

  this object in iteratee, optional.

  Returns

  The set of values that pass the truth test.

method find

find: (iteratee?: Iteratee<V, boolean>, context?: any) => T | undefined;

• Looks through each value in the wrapped collection, returning the first one that passes a truth test (iteratee), or undefined if no value passes the test. The function returns as soon as it finds an acceptable element, and doesn't traverse the entire collection.

  Parameter iteratee

  The truth test to apply.

  Parameter context

  this object in iteratee, optional.

  Returns

  The first element in the wrapped collection that passes the truth test or undefined if no elements pass.

method findIndex

findIndex: (iteratee?: Iteratee<V, boolean>, context?: any) => number;

• Returns the first index of an element in the wrapped list where the iteratee truth test passes, otherwise returns -1.

  Parameter iteratee

  The truth test to apply.

  Parameter context

  this object in iteratee, optional.

  Returns

  The index of the first element in the wrapped list where the truth test passes or -1 if no elements pass.

method findKey

findKey: (
    iteratee?: Iteratee<V, boolean, TypeOfCollection<V, any>>,
    context?: any
) => Extract<keyof V, string> | undefined;

• Similar to findIndex but for keys in objects. Returns the key where the iteratee truth test passes or undefined.

  Parameter iteratee

  The truth test to apply.

  Parameter context

  this object in iteratee, optional.

  Returns

  The first element in the wrapped object that passes the truth test or undefined if no elements pass.

method findLastIndex

findLastIndex: (iteratee?: Iteratee<V, boolean>, context?: any) => number;

• Returns the last index of an element in the wrapped list where the iteratee truth test passes, otherwise returns -1.

  Parameter iteratee

  The truth test to apply.

  Parameter context

  this object in iteratee, optional.

  Returns

  The index of the last element in the wrapped list where the truth test passes or -1 if no elements pass.

method findWhere

findWhere: (properties: Partial<T>) => T | undefined;

• Looks through the wrapped collection and returns the first value that matches all of the key-value pairs listed in properties. If no match is found, or if list is empty, undefined will be returned.

  Parameter properties

  The properties to check for on the elements within the wrapped collection.

  Returns

  The first element in the wrapped collection that matches properties or undefined if no match is found.

method first

first: { (): T | undefined; (n: number): T[] };

• Returns the first element of the wrapped list. Passing n will return the first n elements of the wrapped list.

  Parameter n

  The number of elements to retrieve, optional.

  Returns

  The first n elements of the wrapped list or the first element if n is omitted.

method flatten

flatten: {
    (depth: 1 | true): Array<ListItemOrSelf<T>>;
    (depth?: number | false): DeepestListItemOrSelf<T>[];
};

• Flattens a nested list (the nesting can be to any depth). If you pass depth, the wrapped list will only be flattened a single level.

  Parameter depth

  True to only flatten one level, optional, default = false.

  Returns

  The flattened list.

method functions

functions: () => string[];

• Wrapped type object.

  See Also

  • _.functions

method get

get: {
    (path: string): TypeOfCollection<V> | undefined;
    <U>(path: string, defaultValue?: U): TypeOfCollection<V, never> | U;
    <P extends (string | number)[], U = undefined>(
        path: [...P],
        defaultValue?: U
    ): U | DeepTypeOfCollection<V, P>;
};

• Wrapped type any.

  See Also

  • _.get

method groupBy

groupBy: (
    iteratee?: Iteratee<V, string | number>,
    context?: any
) => Dictionary<T[]>;

• Splits the warpped collection into sets that are grouped by the result of running each value through iteratee.

  Parameter iteratee

  An iteratee that provides the value to group by for each item in the wrapped collection.

  Parameter context

  this object in iteratee, optional.

  Returns

  A dictionary with the group names provided by iteratee as properties where each property contains the grouped elements from the wrapped collection.

method has

has: (key: string) => boolean;

• Wrapped type object.

  See Also

  • _.has

method identity

identity: () => any;

• Wrapped type any.

  See Also

  • _.identity

method indexBy

indexBy: (
    iteratee?: Iteratee<V, string | number>,
    context?: any
) => Dictionary<T>;

• Given the warpped collection and an iteratee function that returns a key for each element in the wrapped collection, returns an object that acts as an index of each item. Just like groupBy, but for when you know your keys are unique.

  Parameter iteratee

  An iteratee that provides the value to index by for each item in the wrapped collection.

  Parameter context

  this object in iteratee, optional.

  Returns

  A dictionary where each item in the wrapped collection is assigned to the property designated by iteratee.

method indexOf

indexOf: (value: T, isSortedOrFromIndex?: boolean | number) => number;

• Returns the index at which value can be found in the wrapped list, or -1 if value is not present. If you're working with a large list and you know that the list is already sorted, pass true for isSortedOrFromIndex to use a faster binary search...or, pass a number in order to look for the first matching value in the list after the given index.

  Parameter value

  The value to search for within the wrapped list.

  Parameter isSortedOrFromIndex

  True if the wrapped list is already sorted OR the starting index for the search, optional.

  Returns

  The index of the first occurrence of value within the wrapped list or -1 if value is not found.

method initial

initial: (n?: number) => T[];

• Returns everything but the last entry of the wrapped list. Especially useful on the arguments object. Pass n to exclude the last n elements from the result.

  Parameter n

  The number of elements from the end of the wrapped list to omit, optional, default = 1.

  Returns

  The elements of the wrapped list with the last n items omitted.

method intersection

intersection: (...lists: Array<List<T>>) => T[];

• Computes the list of values that are the intersection of the wrapped list and the passed-in lists. Each value in the result is present in each of the lists.

  Parameter lists

  The lists (along with the wrapped list) to compute the intersection of.

  Returns

  The intersection of elements within the the wrapped list and lists.

method invert

invert: () => any;

• Wrapped type object.

  See Also

  • _.invert

method invoke

invoke: (methodName: string, ...args: any[]) => any[];

• Calls the method named by methodName on each value in the wrapped collection. Any extra arguments passed to invoke will be forwarded on to the method invocation.

  Parameter methodName

  The name of the method to call on each element in the wrapped collection.

  Parameter args

  Additional arguments to pass to method methodName.

  Returns

  An array containing the result of the method call for each item in the wrapped collection.

method isArguments

isArguments: () => boolean;

• Returns true if the wrapped object is an Arguments object.

  Returns

  True if the wrapped object is an Arguments object, otherwise false.

method isArray

isArray: () => boolean;

• Returns true if the wrapped object is an Array.

  Returns

  True if the wrapped object is an Array, otherwise false.

method isArrayBuffer

isArrayBuffer: () => boolean;

• Returns true if the wrapped object is an ArrayBuffer.

  Returns

  True if the wrapped object is an ArrayBuffer, otherwise false.

method isBoolean

isBoolean: () => boolean;

• Returns true if the wrapped object is a Boolean.

  Returns

  True if the wrapped object is a Boolean, otherwise false.

method isDataView

isDataView: () => boolean;

• Returns true if the wrapped object is a DataView.

  Returns

  True if the wrapped object is a DataView, otherwise false.

method isDate

isDate: () => boolean;

• Returns true if the wrapped object is a Date.

  Returns

  True if the wrapped object is a Date, otherwise false.

method isElement

isElement: () => boolean;

• Returns true if the wrapped object is a DOM element.

  Returns

  True if the wrapped object is a DOM element, otherwise false.

method isEmpty

isEmpty: () => boolean;

• Returns true if the wrapped collection contains no values. For strings and array-like objects checks if the length property is 0.

  Returns

  True if the wrapped collection has no elements.

method isEqual

isEqual: (other: any) => boolean;

• Performs an optimized deep comparison between the wrapped object and other to determine if they should be considered equal.

  Parameter other

  Compare to the wrapped object.

  Returns

  True if the wrapped object should be considered equal to other.

method isError

isError: () => boolean;

• Returns true if the wrapped object is a Error.

  Returns

  True if the wrapped object is a Error, otherwise false.

method isFinite

isFinite: () => boolean;

• Returns true if the wrapped object is a finite Number.

  Returns

  True if the wrapped object is a finite Number.

method isFunction

isFunction: () => boolean;

• Returns true if the wrapped object is a Function.

  Returns

  True if the wrapped object is a Function, otherwise false.

method isMatch

isMatch: (properties: any) => boolean;

• Returns true if the keys and values in properties are contained in the wrapped object.

  Parameter properties

  The properties to check for in the wrapped object.

  Returns

  True if all keys and values in properties are also in the wrapped object.

method isNaN

isNaN: () => boolean;

• Returns true if the wrapped object is NaN. Note: this is not the same as the native isNaN function, which will also return true if the variable is undefined.

  Returns

  True if the wrapped object is NaN, otherwise false.

method isNull

isNull: () => boolean;

• Returns true if the wrapped object is null.

  Returns

  True if the wrapped object is null, otherwise false.

method isNumber

isNumber: () => boolean;

• Returns true if the wrapped object is a Number (including NaN).

  Returns

  True if the wrapped object is a Number, otherwise false.

method isObject

isObject: () => boolean;

• Returns true if the wrapped object is an Object. Note that JavaScript arrays and functions are objects, while (normal) strings and numbers are not.

  Returns

  True if the wrapped object is an Object, otherwise false.

method isRegExp

isRegExp: () => boolean;

• Returns true if the wrapped object is a RegExp.

  Returns

  True if the wrapped object is a RegExp, otherwise false.

method isString

isString: () => boolean;

• Returns true if the wrapped object is a String.

  Returns

  True if the wrapped object is a String, otherwise false.

method isSymbol

isSymbol: () => boolean;

• Returns true if the wrapped object is a Symbol.

  Returns

  True if the wrapped object is a Symbol, otherwise false.

method isTypedArray

isTypedArray: () => boolean;

• Returns true if the wrapped object is a TypedArray.

  Returns

  True if the wrapped object is a TypedArray, otherwise false.

method isUndefined

isUndefined: () => boolean;

• Returns true if the wrapped object is undefined.

  Returns

  True if the wrapped object is undefined, otherwise false.

method iteratee

iteratee: (context?: any) => Function;

• Wrapped type string|Function|Object.

  See Also

  • _.iteratee

method keys

keys: () => string[];

• Wrapped type object.

  See Also

  • _.keys

method last

last: { (): T | undefined; (n: number): T[] };

• Returns the last element of the wrapped list. Passing n will return the last n elements of the wrapped list.

  Parameter n

  The number of elements to retrieve, optional.

  Returns

  The last n elements of the wrapped list or the last element if n is omitted.

method lastIndexOf

lastIndexOf: (value: T, fromIndex?: number) => number;

• Returns the index of the last occurrence of value in the wrapped list, or -1 if value is not present. Pass fromIndex to start your search at a given index.

  Parameter value

  The value to search for within the wrapped list.

  Parameter fromIndex

  The starting index for the search, optional.

  Returns

  The index of the last occurrence of value within the wrapped list or -1 if value is not found.

method map

map: <I extends Iteratee<V, any, TypeOfCollection<V, never>>>(
    iteratee: I,
    context?: any
) => Array<IterateeResult<I, T>>;

• Produces a new array of values by mapping each value in the wrapped collection through a transformation iteratee.

  Parameter iteratee

  The iteratee to use to transform each item in the wrapped collection.

  Parameter context

  this object in iteratee, optional.

  Returns

  The mapped result.

method mapObject

mapObject: <I extends Iteratee<V, any, TypeOfCollection<V, any>>>(
    iteratee: I,
    context?: any
) => { [K in keyof V]: IterateeResult<I, V[K]> };

• Like map, but for objects. Transform the value of each property in turn.

  Parameter iteratee

  The iteratee to use to transform property values.

  Parameter context

  this object in iteratee, optional.

  Returns

  A new object with all of the wrapped object's property values transformed through iteratee.

method matcher

matcher: () => _.ListIterator<T, boolean>;

• Wrapped type any[].

  See Also

  • _.matcher

method matches

matches: () => _.ListIterator<T, boolean>;

• Wrapped type any[].

  See Also

  • _.matches

method max

max: (iteratee?: Iteratee<V, any>, context?: any) => T | number;

• Returns the maximum value in the wrapped collection. If an iteratee is provided, it will be used on each element to generate the criterion by which the element is ranked. -Infinity is returned if list is empty. Non-numerical values returned by iteratee will be ignored.

  Parameter iteratee

  The iteratee that provides the criterion by which each element is ranked, optional if evaluating a collection of numbers.

  Parameter context

  this object in iteratee, optional.

  Returns

  The maximum element within the wrapped collection or -Infinity if the wrapped collection is empty.

method memoize

memoize: (hashFn?: (n: any) => string) => Function;

• Wrapped type Function.

  See Also

  • _.memoize

method methods

methods: () => string[];

• See Also

  • _.functions

method min

min: (iteratee?: Iteratee<V, any>, context?: any) => T | number;

• Returns the minimum value in the wrapped collection. If an iteratee is provided, it will be used on each element to generate the criterion by which the element is ranked. Infinity is returned if list is empty. Non-numerical values returned by iteratee will be ignored.

  Parameter iteratee

  The iteratee that provides the criterion by which each element is ranked, optional if evaluating a collection of numbers.

  Parameter context

  this object in iteratee, optional.

  Returns

  The minimum element within the wrapped collection or Infinity if the wrapped collection is empty.

method mixin

mixin: () => void;

• Wrapped type object.

  See Also

  • _.mixin

method negate

negate: () => (...args: any[]) => boolean;

• Wrapped type Function.

  See Also

  • _.negate

method noop

noop: () => void;

• Wrapped type any.

  See Also

  • _.noop

method object

object: {
    <TValue>(values: List<TValue>): Dictionary<TValue | undefined>;
    (): Dictionary<PairValue<T>>;
};

• Converts lists into objects. Call on either a wrapped list of [key, value] pairs, or a wrapped list of keys and a list of values. Passing by pairs is the reverse of pairs. If duplicate keys exist, the last value wins.

  Parameter values

  If the wrapped list is a list of keys, a list of values corresponding to those keys.

  Returns

  An object comprised of the provided keys and values.

method omit

omit: {
    <K extends string>(...keys: Array<K | K[]>): _Omit<V, K>;
    (iterator: ObjectIterator<TypeOfDictionary<V, any>, boolean, V>): Partial<V>;
};

• Return a copy of the wrapped object that is filtered to omit the disallowed keys (or array of keys).

  Parameter keys

  The keys to omit from the wrapped object.

  Returns

  A copy of the wrapped object without the keys properties.

• Return a copy of the wrapped object that is filtered to not have values for the keys selected by a truth test.

  Parameter iterator

  A truth test that selects the keys to omit from the wrapped object.

  Returns

  A copy of the wrapped object without the keys selected by iterator.

method once

once: () => Function;

• Wrapped type Function.

  See Also

  • _.once

method pairs

pairs: () => Array<[Extract<keyof V, string>, TypeOfCollection<V, any>]>;

• Convert the wrapped object into a list of [key, value] pairs. The opposite of the single-argument signature of _.object.

  Returns

  The list of [key, value] pairs from the wrapped object.

method partial

partial: (...args: any[]) => Function;

• Wrapped type Function.

  See Also

  • _.partial

method partition

partition: (iteratee?: Iteratee<V, boolean>, context?: any) => [T[], T[]];

• Splits the wrapped collection into two arrays: one whose elements all satisfy iteratee and one whose elements all do not satisfy iteratee.

  Parameter iteratee

  The iteratee that defines the partitioning scheme for each element in the wrapped collection.

  Parameter context

  this object in iteratee, optional.

  Returns

  An array composed of two elements, where the first element contains the elements in the wrapped collection that satisfied the predicate and the second element contains the elements that did not.

method pick

pick: {
    <K extends string>(...keys: Array<K | K[]>): _Pick<V, K>;
    (iterator: ObjectIterator<TypeOfDictionary<V, any>, boolean, V>): Partial<V>;
};

• Return a copy of the wrapped object that is filtered to only have values for the allowed keys (or array of keys).

  Parameter keys

  The keys to keep on the wrapped object.

  Returns

  A copy of the wrapped object with only the keys properties.

• Return a copy of the wrapped object that is filtered to only have values for the keys selected by a truth test.

  Parameter iterator

  A truth test that selects the keys to keep on the wrapped object.

  Returns

  A copy of the wrapped object with only the keys selected by iterator.

method pluck

pluck: <K extends string | number>(
    propertyName: K
) => Array<PropertyTypeOrAny<T, K>>;

• A convenient version of what is perhaps the most common use-case for map: extracting a list of property values.

  Parameter propertyName

  The name of a specific property to retrieve from all items in the wrapped collection.

  Returns

  The set of values for the specified propertyName for each item in the wrapped collection.

method property

property: () => (object: any) => any;

• Wrapped type string.

  See Also

  • _.property

method propertyOf

propertyOf: () => (key: string) => any;

• Wrapped type object.

  See Also

  • _.propertyOf

method random

random: { (): number; (max: number): number };

• Wrapped type number.

  See Also

  • _.random

method range

range: (stop?: number, step?: number) => number[];

• A function to create flexibly-numbered lists of integers, handy for each and map loops. Returns a list of integers from the wrapped value (inclusive) to stop (exclusive), incremented (or decremented) by step. Note that ranges that stop before they start are considered to be zero-length instead of negative - if you'd like a negative range, use a negative step.

  If stop is not specified, the wrapped value will be the number to stop at and the default start of 0 will be used.

  Parameter stop

  The number to stop at.

  Parameter step

  The number to count up by each iteration, optional, default = 1.

  Returns

  An array of numbers from start to stop with increments of step.

method reduce

reduce: {
    <TResult>(
        iteratee: MemoCollectionIterator<TypeOfCollection<V>, TResult, V>,
        memo: TResult,
        context?: any
    ): TResult;
    <TResult = TypeOfCollection<V, never>>(
        iteratee: MemoCollectionIterator<
            TypeOfCollection<V, never>,
            TypeOfCollection<V, never> | TResult,
            V
        >
    ): TypeOfCollection<V, never> | TResult;
};

• Also known as inject and foldl, reduce boils down the wrapped collection of values into a single value. memo is the initial state of the reduction, and each successive step of it should be returned by iteratee.

  If no memo is passed to the initial invocation of reduce, iteratee is not invoked on the first element of the wrapped collection. The first element is instead passed as the memo in the invocation of iteratee on the next element in the wrapped collection.

  Parameter iteratee

  The function to call on each iteration to reduce the collection.

  Parameter memo

  The initial reduce state or undefined to use the first item in collection as initial state.

  Parameter context

  this object in iteratee, optional.

  Returns

  The reduced result.

method reduceRight

reduceRight: {
    <TResult>(
        iteratee: MemoCollectionIterator<TypeOfCollection<V>, TResult, V>,
        memo: TResult,
        context?: any
    ): TResult;
    <TResult = TypeOfCollection<V, never>>(
        iteratee: MemoCollectionIterator<
            TypeOfCollection<V, never>,
            TypeOfCollection<V, never> | TResult,
            V
        >
    ): TypeOfCollection<V, never> | TResult;
};

• The right-associative version of reduce.

  This is not as useful in JavaScript as it would be in a language with lazy evaluation.

  Parameter iteratee

  The function to call on each iteration to reduce the collection.

  Parameter memo

  The initial reduce state or undefined to use the first item in collection as the initial state.

  Parameter context

  this object in iteratee, optional.

  Returns

  The reduced result.

method reject

reject: (iteratee?: Iteratee<V, boolean>, context?: any) => T[];

• Returns the values in the wrapped collection without the elements that pass a truth test (iteratee). The opposite of filter.

  Parameter iteratee

  The truth test to apply.

  Parameter context

  this object in iteratee, optional.

  Returns

  The set of values that fail the truth test.

method rest

rest: (n?: number) => T[];

• Returns the rest of the elements in the wrapped list. Pass an index to return the values of the list from that index onward.

  Parameter index

  The index to start retrieving elements from, optional, default = 1.

  Returns

  The elements of the wrapped list from index to the end of the list.

method restArgs

restArgs: (starIndex?: number) => Function;

• Wrapped type Function.

  See Also

  • _.once

method result

result: (property: string, defaultValue?: any) => any;

• Wrapped type object.

  See Also

  • _.result

method sample

sample: { (n: number): T[]; (): T };

• Produce a random sample from the wrapped collection. Pass a number to return n random elements from the wrapped collection. Otherwise a single random item will be returned.

  Parameter n

  The number of elements to sample from the wrapped collection.

  Returns

  A random sample of n elements from the wrapped collection or a single element if n is not specified.

method shuffle

shuffle: () => T[];

• Returns a shuffled copy of the wrapped collection, using a version of the Fisher-Yates shuffle.

  Returns

  A shuffled copy of the wrapped collection.

method size

size: () => number;

• Determines the number of values in the wrapped collection.

  Returns

  The number of values in the wrapped collection.

method some

some: (iteratee?: Iteratee<V, boolean>, context?: any) => boolean;

• Returns true if any of the values in the wrapped collection pass the iteratee truth test. Short-circuits and stops traversing the wrapped collection if a true element is found.

  Parameter iteratee

  The truth test to apply.

  Parameter context

  this object in iteratee, optional.

  Returns

  True if any element passed the truth test, otherwise false.

method sortBy

sortBy: (iteratee?: Iteratee<V, any>, context?: any) => T[];

• Returns a (stably) sorted copy of the wrapped collection, ranked in ascending order by the results of running each value through iteratee.

  Parameter iteratee

  An iteratee that provides the value to sort by for each item in the wrapped collection.

  Parameter context

  this object in iteratee, optional.

  Returns

  A sorted copy of the wrapped collection.

method sortedIndex

sortedIndex: (
    value: T,
    iteratee?: Iteratee<V | undefined, any>,
    context?: any
) => number;

• Uses a binary search to determine the lowest index at which the value should be inserted into the wrapped list in order to maintain the wrapped list's sorted order. If an iteratee is provided, it will be used to compute the sort ranking of each value, including the value you pass.

  Parameter value

  The value to determine an insert index for to mainain the sorting in the wrapped list.

  Parameter iteratee

  Iteratee to compute the sort ranking of each element including value, optional.

  Parameter context

  this object in iteratee, optional.

  Returns

  The index where value should be inserted into the wrapped list.

method tap

tap: (interceptor: (...as: any[]) => any) => any;

• Wrapped type object.

  See Also

  • _.tap

method template

template: (settings?: _.TemplateSettings) => CompiledTemplate;

• Wrapped type string.

  See Also

  • _.template

method throttle

throttle: (
    wait: number,
    options?: _.ThrottleSettings
) => Function & _.Cancelable;

• Wrapped type Function.

  See Also

  • _.throttle

method times

times: <TResult>(iterator: (n: number) => TResult, context?: any) => TResult[];

• Wrapped type number.

  See Also

  • _.times

method toArray

toArray: () => T[];

• Creates a real Array from the wrapped collection (anything that can be iterated over). Useful for transmuting the arguments object.

  Returns

  An array containing the elements of the wrapped collection.

method transpose

transpose: () => T extends [infer A, infer B, infer C]
    ? [A[], B[], C[]]
    : T extends [infer A, infer B]
    ? [A[], B[]]
    : T extends [infer A]
    ? [A[]]
    : T extends List<infer A>
    ? A[][]
    : [];

method unescape

unescape: () => string;

• Wrapped type string.

  See Also

  • _.unescape

method union

union: (...lists: Array<List<T>>) => T[];

• Computes the union of the wrapped list and the passed-in lists: the list of unique items, examined in order from first list to last list, that are present in one or more of the lists.

  Parameter lists

  The lists (along with the wrapped list) to compute the union of.

  Returns

  The union of elements within the wrapped list and lists.

method uniq

uniq: {
    (isSorted?: boolean, iteratee?: Iteratee<V, any>, cotext?: any): T[];
    (
        iteratee?: Iteratee<V, any, TypeOfCollection<V, never>>,
        context?: any
    ): T[];
};

• Produces a duplicate-free version of the wrapped list, using === to test object equality. If you know in advance that the wrapped list is sorted, passing true for isSorted will run a much faster algorithm. If you want to compute unique items based on a transformation, pass an iteratee function.

  Parameter isSorted

  True if the wrapped list is already sorted, optional, default = false.

  Parameter iteratee

  Transform the elements of the wrapped list before comparisons for uniqueness.

  Parameter context

  'this' object in iteratee, optional.

  Returns

  An array containing only the unique elements in the wrapped list.

method uniqueId

uniqueId: () => string;

• Wrapped type string.

  See Also

  • _.uniqueId

method unzip

unzip: () => T extends [infer A, infer B, infer C]
    ? [A[], B[], C[]]
    : T extends [infer A, infer B]
    ? [A[], B[]]
    : T extends [infer A]
    ? [A[]]
    : T extends List<infer A>
    ? A[][]
    : [];