The kitchen sink of Python utility libraries for doing "stuff" in a functional way. Based on the Lo-Dash Javascript library.
pydash
|version| |build| |coveralls| |license|
The kitchen sink of Python utility libraries for doing "stuff" in a functional way. Based on the Lo-Dash <http://lodash.com/>_ Javascript library.
Looking for a library that is more memory efficient and better suited for large datasets? Check out fnc <https://github.com/dgilland/fnc>_! It's built around generators and iteration and has iteratee-first function signatures.
.. |version| image:: http://img.shields.io/pypi/v/pydash.svg?style=flat-square :target: https://pypi.python.org/pypi/pydash/
.. |build| image:: https://img.shields.io/github/workflow/status/dgilland/pydash/Main/master?style=flat-square :target: https://github.com/dgilland/pydash/actions
.. |coveralls| image:: http://img.shields.io/coveralls/dgilland/pydash/master.svg?style=flat-square :target: https://coveralls.io/r/dgilland/pydash
.. |license| image:: http://img.shields.io/pypi/l/pydash.svg?style=flat-square :target: https://pypi.python.org/pypi/pydash/
.. _changelog:
find_index and find_last_index by allowing predicate argument to be callback shorthand values. Thanks DeviousStoat_!typing-extensions version 4.6.0 from install requirements. Incompatibility was fixed in 4.6.1.difference_by, intersection_by, union_by, uniq_by, and xor_by by allowing iteratee argument to be Any. Thanks DeviousStoat_!pyright as a type checker with reportPrivateUsage=true would report errors that objects are not exported from pydash. Thanks DeviousStoat_!typing-extensions, for package.to_dict to not using dict() internally. Previous behavior would be for something like to_dict([["k", "v"], ["x", "y"]]) to return {"k": "v", "x": "y"} (equivalent to calling dict(...)) but to_dict([["k"], ["v"], ["x"], ["y"]]) would return {0: ["x"], 1: ["v"], 2: ["x"], 3: ["y"]}. The new behavior is to always return iterables as dictionaries with their indexes as keys like {0: ["k", "v"], 1: ["x", "y"]}. This is consistent with how iterable objects are iterated over and means that to_dict will have more reliable output. (breaking change)slugify to remove single-quotes from output. Instead of slugify("the cat's meow") == "the-cat's-meow", the new behavior is to return "the-cats-meow". (breaking change)get path keys. Thanks bl4ckst0ne_!__globals__ or __builtins__ instead of all dunder-methods for non-dict/list objects.get() for non-dict/list objects that used integer index references like "[0]".get() for non-dict/list objects. Attempting to access dunder-methods using get-path keys will raise a KeyError (e.g. get(SomeClass(), '__init__' will raise). Access to dict keys are unaffected (e.g. get({"__init__": True}, "__init__") will return True). (breaking change)exceptions argument in pydash.retry.pydash.delay where it could fail on certain environments.pydash.get in functions like pydash.find.pydash.py_ / pydash._ and typing.Protocol + typing.runtime_checkable that caused an exception to be raised for isinstance(py_, SomeRuntimeCheckableProtocol).merge_with that prevented custom iteratee from being used when recursively merging. Thanks weineel_!Drop support for Python 2.7. (breaking change)
Improve Unicode word splitting in string functions to be inline with Lodash. Thanks mervynlee94_! (breaking change)
camel_casehuman_casekebab_caselower_casepascal_caseseparator_caseslugifysnake_casestart_caseupper_caseOptimize regular expression constants used in pydash.strings by pre-compiling them to regular expression pattern objects.
v4.8.0 that caused merge and merge_with to raise an exception when passing None as the first argument.v4.9.1 that broke pydash.get for dictionaries and dot-delimited keys that reference integer dict-keys.get/has that caused defaultdict objects to get populated on key access.default_to_any. Thanks gonzalonaveira_!\. in set_, set_with, and update_with where the . was not treated as a literal value within the key name. Thanks zhaowb_!argparse.Namespace in set_, set_with, update, and update_with.order_by when None used as a sort key. Thanks elijose55_!pick_by to return the passed in argument when only one argument given. Previously, an empty dictionary was returned. Thanks elijose55_!Bug Fixes +++++++++
Sequence, Mapping, and namedtuple types in get so that their attributes aren't accessed during look-up. Thanks jwilson8767_!Bug Fixes +++++++++
clone_with and clone_deep_with when a customizer is used.find and find_last.Bug Fixes +++++++++
set_, set_with, update, and update_with when an object cannot be updated due to that object or one of its nested objects not being subscriptable.Bug Fixes +++++++++
spread where arguments were not being passed to wrapped function properly.New Features ++++++++++++
to_dict to first try to convert using dict() before falling back to using pydash.helpers.iterator().Misc ++++
Misc ++++
Misc ++++
Improve performance of the following functions for large datasets:
duplicatessorted_uniqsorted_uniq_byunionunion_byunion_withuniquniq_byuniq_withxorxor_byxor_withNew Features ++++++++++++
jitter argument to retry.New Features ++++++++++++
attempt argument to on_exception callback in retry. New function signature is on_exception(exc, attempt) (previously was on_exception(exc)). All arguments to on_exception callback are now optional.New Features ++++++++++++
retry decorator that will retry a function multiple times if the function raises an exception.Bug Fixes +++++++++
v4.3.2 introduced by the support added for callable class callbacks that changed the handling of callbacks that could not be inspected. Prior to v4.3.2, these callbacks would default to being passed a single callback argument, but with v4.3.2 these callbacks would be passed the full set of callback arguments which could result an exception being raised due to the callback not supporting that many arguments.Bug Fixes +++++++++
defaults_deep where sources with non-dict values would raise an exception due to assumption that object was always a dict.curry where too many arguments would be passed to the curried function when evaluating function if too many arguments used in last function call.Bug Fixes +++++++++
Fix set_with so that callable values are not called when being set. This bug also impacted the following functions by proxy:
pickpick_byset_transposezip_object_deepNew Features ++++++++++++
nest.to_list instead of raising an exception. Thanks efenka_!split_strings argument to to_list to control whether strings are coverted to a list (split_strings=True) or wrapped in a list (split_strings=False). Default is split_strings=True. Thanks efenka_!Bug Fixes +++++++++
to_path always returns a list.get to work with path values other than just strings, integers, and lists.New Features ++++++++++++
to_dict so non-iterators that expose an items(), iteritems(), or has __dict__ attributes will be converted using those methods.omit and omit_by. Thanks beck3905_!pick and pick_by. Thanks beck3905_!Bug Fixes +++++++++
cond.cond instead of just pairs as separate arguments.New Features ++++++++++++
properties function that returns list of path values for an object.replace_end.replace_start.iteratee support properties-style callback when a tuple is passed.replace accept from_start and from_end arguments to limit replacement to start and/or end of string.Bug Fixes +++++++++
New Features ++++++++++++
Bug Fixes +++++++++
get. Thanks shaunpatterson_!New Features ++++++++++++
Bug Fixes +++++++++
get where list and dict objects had attributes returned when a key was missing but the key corresponded to an attribute name. For example, pydash.get({}, 'update') would return {}.update() instead of None. Previous behavior was that only item-access was allowed for list and dict which has been restored.invoke/invoke_map where non-attributes could be invoked. For example, pydash.invoke({'items': lambda: 1}, 'items') would return 1 instead of dict_items([('a', 'items')]). Previous behavior was that only attribute methods could be invoked which has now been restored.New Features ++++++++++++
Bug Fixes +++++++++
intersection, intersection_by, and intersection_with introduced in v4.0.0 where the a single argument supplied to intersection should return the same argument value instead of an empty list.Backwards-Incompatibilities +++++++++++++++++++++++++++
New Features ++++++++++++
property_ work with deep path strings.Bug Fixes +++++++++
deep_pluck and rename to pluck. Previously, deep_pluck was removed and map_ was recommended as a replacement. However, deep_pluck (now defined as pluck) functionality is not supported by map_ so the removal pluck was reverted.Backwards-Incompatibilities +++++++++++++++++++++++++++
property_deep (use property_)... _changelog-v4.0.0:
New Features ++++++++++++
assign_with.clamp.clone_deep_with.clone_with.cond. Thanks bharadwajyarlagadda_!conforms.conforms_to.default_to. Thanks bharadwajyarlagadda_!difference_by.difference_with.divide. Thanks bharadwajyarlagadda_!eq. Thanks bharadwajyarlagadda_!flat_map.flat_map_deep.flat_map_depth.flatten_depth.flip. Thanks bharadwajyarlagadda_!from_pairs. Thanks bharadwajyarlagadda_!intersection_by.intersection_with.invert_by.invoke_map.is_equal_with. Thanks bharadwajyarlagadda_!is_match_with.is_set. Thanks bharadwajyarlagadda_!lower_case. Thanks bharadwajyarlagadda_!lower_first. Thanks bharadwajyarlagadda_!max_by.mean_by.merge_with.min_by.multiply. Thanks bharadwajyarlagadda_!nth. Thanks bharadwajyarlagadda_!nth_arg. Thanks bharadwajyarlagadda_!omit_by.over. Thanks bharadwajyarlagadda_!over_every. Thanks bharadwajyarlagadda_!over_some. Thanks bharadwajyarlagadda_!pick_by.pull_all. Thanks bharadwajyarlagadda_!pull_all_by.pull_all_with.range_right. Thanks bharadwajyarlagadda_!sample_size. Thanks bharadwajyarlagadda_!set_with.sorted_index_by.sorted_index_of. Thanks bharadwajyarlagadda_!sorted_last_index_by.sorted_last_index_of.sorted_uniq. Thanks bharadwajyarlagadda_!sorted_uniq_by.stub_list. Thanks bharadwajyarlagadda_!stub_dict. Thanks bharadwajyarlagadda_!stub_false. Thanks bharadwajyarlagadda_!stub_string. Thanks bharadwajyarlagadda_!stub_true. Thanks bharadwajyarlagadda_!subtract. Thanks bharadwajyarlagadda_!sum_by.to_integer.to_lower. Thanks bharadwajyarlagadda_!to_path. Thanks bharadwajyarlagadda_!to_upper. Thanks bharadwajyarlagadda_!unary.union_by. Thanks bharadwajyarlagadda_!union_with. Thanks bharadwajyarlagadda_!uniq_by.uniq_with.unset.update.update_with.upper_case. Thanks bharadwajyarlagadda_!upper_first. Thanks bharadwajyarlagadda_!xor_by.xor_with.zip_object_deep.constant ignore extra arguments when called.get support attribute access within path.iteratee treat an integer argument as a string path (i.e. iteratee(1) is equivalent to iteratee('1') for creating a path accessor function).intersection work with unhashable types.range_ support decrementing when start argument is greater than stop argument.xor maintain sort order of supplied arguments.Bug Fixes +++++++++
find_last_key so that it iterates over object in reverse.Backwards-Incompatibilities +++++++++++++++++++++++++++
Make add only support two argument addition. (breaking change)
Make difference return duplicate values from first argument and maintain sort order. (breaking change)
Make invoke work on objects instead of collections. Use invoke_map for collections. (breaking change)
Make set_ support mixed list/dict defaults within a single object based on whether key or index path substrings used. (breaking change)
Make set_ modify object in place. (breaking change)
Only use merge callback result if result is not None. Previously, result from callback (if provided) was used unconditionally. (breaking change)
Remove functions: (breaking change)
deep_pluck (no alternative) [UPDATE: deep_pluck functionality restored as pluck in v4.0.1]mapiter (no alternative)pluck (use map_)update_path (use update or update_with)set_path (use set_ or set_with)Remove aliases: (breaking change)
all_ (use every)any_ (use some)append (use push)average and avg (use mean or mean_by)callback (use iteratee)cat (use concat)collect (use map_)contains (use includes)curve (use round_)deep_get and get_path (use get)deep_has and has_path (use has)deep_prop (use property_deep)deep_set (use set_)detect and find_where (use find)each (use for_each)each_right (use for_each_right)escape_re (use escape_reg_exp)explode (use split)extend (use assign)first (use head)foldl (use reduce)foldr (use reduce_right)for_own (use for_each)for_own_right (use for_each_right)implode (use join)is_bool (use is_boolean)is_int (use is_integer)is_native (use is_builtin)is_num (use is_number)is_plain_object (use is_dict)is_re (use is_reg_exp)js_match (use reg_exp_js_match)js_replace (use reg_exp_js_replace)keys_in (use keys)moving_average and moving_avg (use moving_mean)object_ (use zip_object)pad_left (use pad_start)pad_right (use pad_end)pipe (use flow)pipe_right and compose (use flow_right)prop (use property_)prop_of (use property_of)pow_ (use power)re_replace (use reg_exp_replace)rest (use tail)select (use filter_)sigma (use std_deviation)sort_by_all and sort_by_order (use order_by)trim_left (use trim_start)trim_right (use trim_right)trunc (use truncate)underscore_case (use snake_case)unique (use uniq)values_in (use values)where (use filter_)Rename functions: (breaking change)
deep_map_values to map_values_deepdeep_property to property_deepinclude to includesindex_by to key_bymod_args to over_argsmoving_average to moving_meanpairs to to_pairsRemove callback argument from: (breaking change)
assign. Moved to assign_with.clone and clone_deep. Moved to clone_with and clone_deep_with.is_match. Moved to is_match_with.max_ and min_. Moved to max_by and min_by.omit. Moved to omit_by.pick. Moved to pick_by.sorted_index. Moved to sorted_index_by.sum_. Moved to sum_by.uniq/unique. Moved to uniq_by.Renamed callback argument to predicate: (breaking change)
drop_right_whiledrop_whileeveryfilter_findfind_keyfind_lastfind_indexfind_last_indexfind_last_keypartitionrejectremovesometake_right_whiletake_whileRenamed callback argument to iteratee: (breaking change)
count_byduplicatesfor_eachfor_each_rightfor_infor_in_rightgroup_bykey_bymap_map_keysmap_valuesmap_values_deepmapcatmedianreduce_reduce_rightreductionsreductions_rightsort_bytimestransformunzip_withzip_withzscoreRename comparison argument in sort to comparator.
Rename index and how_many arguments in splice to start and count.
Remove multivalue argument from invert. Feature moved to invert_by. (breaking change)
get where an iterable default was iterated over instead of being returned when an object path wasn't found. Thanks urbnjamesmi1_!get where casting a string key to integer resulted in an uncaught exception instead of the default value being returned instead. Thanks urbnjamesmi1_!default parameter to min_ and max_ functions that is used when provided iterable is empty.is_match where comparison between an empty source argument returned None instead of True.assign/extend instead of deep copying.copy.deepcopy in merge instead of the more resource intensive clone_deep.foo[0][1].bar instead of foo.[0].[1].bar. Both formats are now supported.start_case where capitalized characters after the first character of a word where mistakenly cast to lower case.py_ chaining object when doctest run on pydash.__init__.py.Optimize callback system for performance.
pydash generated callbacks where the arg count is known. This avoids the costly inspect.getargspec call.guess_builtin_argcount which parsed docstrings, and instead only ever pass a single argument to a builtin callback function.Optimize get/set so that regex parsing is only done when special characters are contained in the path key whereas before, all string paths were parsed.
Optimize is_builtin by checking for BuiltinFunctionType instance and then using dict look up table instead of a list look up.
Optimize is_match by replacing call to has with a try/except block.
Optimize push/append by using a native loop instead of callback mapping.
ceil.defaults_deep.floor.get.gt.gte.is_iterable.lt.lte.map_keys.method.method_of.mod_args.set_.unzip_with.zip_with.add support adding two numbers if passed in positionally.get main definition and get_path its alias.set_ main definition and deep_set its alias.AttributeError in helpers.get_item and return default value if set.reduce_right where collection was not reversed correctly.sort_by_order as alias of sort_by_all.is_match to not compare obj and source types using type and instead use isinstance comparisons exclusively.sort_by_all accept an orders argument for specifying the sort order of each key via boolean True (for ascending) and False (for descending).words accept a pattern argument to override the default regex used for splitting words.words handle single character words better.fill.in_range.matches_property.spread.start_case.matches_property style as [key, value] or (key, value).property style callbacks as [key] or (key,)... _changelog-v3.0.0:
Add ary.
Add chars.
Add chop.
Add chop_right.
Add clean.
Add commit method to chain that returns a new chain with the computed chain.value() as the initial value of the chain.
Add count_substr.
Add decapitalize.
Add duplicates.
Add has_substr.
Add human_case.
Add insert_substr.
Add is_blank.
Add is_bool as alias of is_boolean.
Add is_builtin, is_native.
Add is_dict as alias of is_plain_object.
Add is_int as alias of is_integer.
Add is_match.
Add is_num as alias of is_number.
Add is_tuple.
Add join as alias of implode.
Add lines.
Add number_format.
Add pascal_case.
Add plant method to chain that returns a cloned chain with a new initial value.
Add predecessor.
Add property_of, prop_of.
Add prune.
Add re_replace.
Add rearg.
Add replace.
Add run as alias of chain.value.
Add separator_case.
Add series_phrase.
Add series_phrase_serial.
Add slugify.
Add sort_by_all.
Add strip_tags.
Add substr_left.
Add substr_left_end.
Add substr_right.
Add substr_right_end.
Add successor.
Add swap_case.
Add title_case.
Add truncate as alias of trunc.
Add to_boolean.
Add to_dict, to_plain_object.
Add to_number.
Add underscore_case as alias of snake_case.
Add unquote.
Fix deep_has to return False when ValueError raised during path checking.
Fix pad so that it doesn't over pad beyond provided length.
Fix trunc/truncate so that they handle texts shorter than the max string length correctly.
Make the following functions work with empty strings and None: (breaking change) Thanks k7sleeper_!
camel_casecapitalizecharschopchop_rightclass_casecleancount_substrdecapitalizeends_withjoinjs_replacekebab_caselinesquotere_replacereplaceseries_phraseseries_phrase_serialstarts_withsurroundMake callback invocation have better support for builtin functions and methods. Previously, if one wanted to pass a builtin function or method as a callback, it had to be wrapped in a lambda which limited the number of arguments that would be passed it. For example, _.each([1, 2, 3], array.append) would fail and would need to be converted to _.each([1, 2, 3], lambda item: array.append(item). That is no longer the case as the non-wrapped method is now supported.
Make capitalize accept strict argument to control whether to convert the rest of the string to lower case or not. Defaults to True.
Make chain support late passing of initial value argument.
Make chain not store computed value(). (breaking change)
Make drop, drop_right, take, and take_right have default n=1.
Make is_indexed return True for tuples.
Make partial and partial_right accept keyword arguments.
Make pluck style callbacks support deep paths. (breaking change)
Make re_replace accept non-string arguments.
Make sort_by accept reverse parameter.
Make splice work with strings.
Make to_string convert None to empty string. (breaking change)
Move arrays.join to strings.join. (breaking change)
Rename join/implode's second parameter from delimiter to separator. (breaking change)
Rename split/explode's second parameter from delimiter to separator. (breaking change)
Reorder function arguments for after from (n, func) to (func, n). (breaking change)
Reorder function arguments for before from (n, func) to (func, n). (breaking change)
Reorder function arguments for times from (n, callback) to (callback, n). (breaking change)
Reorder function arguments for js_match from (reg_exp, text) to (text, reg_exp). (breaking change)
Reorder function arguments for js_replace from (reg_exp, text, repl) to (text, reg_exp, repl). (breaking change)
Support iteration over class instance properties for non-list, non-dict, and non-iterable objects.
remove so that array is modified after callback iteration.kebab_case so that it casts string to lower case.ensure_ends_with. Thanks k7sleeper_!ensure_starts_with. Thanks k7sleeper_!quote. Thanks k7sleeper_!surround. Thanks k7sleeper_!merge and assign/extend so they apply clone_deep to source values before assigning to destination object.merge accept a callback as a positional argument if it is last.pipe and pipe_right as aliases of flow and flow_right.merge so that trailing {} or [] don't overwrite previous source values.py_ an alias for _.type callbacks (e.g. int, float, str, etc.) by only passing a single callback argument when invoking the callback.append.deep_get.deep_has.deep_map_values.deep_set.deep_pluck.deep_property.join.pop.push.reverse.shift.sort.splice.unshift.url.snake_case that resulted in returned string not being converted to lower case._ instance alias method access to methods with a trailing underscore in their name. For example, _.map() becomes an alias for map_().deep_prop an alias of deep_property.has work with deep paths.has_path an alias of deep_has.get_path handle escaping the . delimiter for string keys.get_path handle list indexing using strings such as '0.1.2' to access 'value' in [[0, [0, 0, 'value']]].concat an alias of cat.add, sum_.average, avg, mean.mapiter.median.moving_average, moving_avg.power, pow_.round_, curve.scale.slope.std_deviation, sigma.transpose.variance.zscore... _changelog-v2.0.0:
_ instance that supports both method chaining and module method calling.cat.conjoin.deburr.disjoin.explode.flatten_deep.flow.flow_right.get_path.has_path.implode.intercalate.interleave.intersperse.is_associative.is_even.is_float.is_decreasing.is_increasing.is_indexed.is_instance_of.is_integer.is_json.is_monotone.is_negative.is_odd.is_positive.is_strictly_decreasing.is_strictly_increasing.is_zero.iterated.js_match.js_replace.juxtapose.mapcat.reductions.reductions_right.rename_keys.set_path.split_at.thru.to_string.update_path.words.(item, index, obj) but the passed in callback only supports (item), then only item will be passed in when callback is invoked. Previously, callbacks had to support all arguments or implement star-args.chain lazy and only compute the final value when value called.compose an alias of flow_right.flatten shallow by default, remove callback option, and add is_deep option. (breaking change)is_number return False for boolean True and False. (breaking change)invert accept multivalue argument.result accept default argument.slice_ accept optional start and end arguments.pydash/api/ to pydash/. (breaking change)pydash.api.objects to pydash.api.predicates. (breaking change)create_callback to iteratee. (breaking change)functions to callables in order to allow functions.py to exist at the root of the pydash module folder. (breaking change)_iter_callback to itercallback. (breaking change)_iter_list_callback to iterlist_callback. (breaking change)_iter_dict_callback to iterdict_callback. (breaking change)_iterate to iterator. (breaking change)_iter_dict to iterdict. (breaking change)_iter_list to iterlist. (breaking change)_iter_unique to iterunique. (breaking change)_get_item to getitem. (breaking change)_set_item to setitem. (breaking change)_deprecated to deprecated. (breaking change)tail and make alias of rest.attempt.before.camel_case.capitalize.chunk.curry_right.drop_right.drop_right_while.drop_while.ends_with.escape_reg_exp and escape_re.is_error.is_reg_exp and is_re.kebab_case.keys_in as alias of keys.negate.pad.pad_left.pad_right.partition.pull_at.repeat.slice_.snake_case.sorted_last_index.starts_with.take_right.take_right_while.take_while.trim.trim_left.trim_right.trunc.values_in as alias of values.pydash.api.strings module.tail.drop to accept n argument and remove as alias of rest.take to accept n argument and remove as alias of first.escape and unescape from pydash.api.utilities to pydash.api.strings. (breaking change)range_ from pydash.api.arrays to pydash.api.utilities. (breaking change).. _changelog-v1.0.0:
after.assign and extend. Thanks nathancahill_!callback and create_callback.chain.clone.clone_deep.compose.constant.count_by. Thanks nathancahill_!curry.debounce.defaults. Thanks nathancahill_!delay.escape.find_key. Thanks nathancahill_!find_last. Thanks nathancahill_!find_last_index. Thanks nathancahill_!find_last_key. Thanks nathancahill_!for_each. Thanks nathancahill_!for_each_right. Thanks nathancahill_!for_in. Thanks nathancahill_!for_in_right. Thanks nathancahill_!for_own. Thanks nathancahill_!for_own_right. Thanks nathancahill_!functions_ and methods. Thanks nathancahill_!group_by. Thanks nathancahill_!has. Thanks nathancahill_!index_by. Thanks nathancahill_!identity.inject.invert.invoke. Thanks nathancahill_!is_list. Thanks nathancahill_!is_boolean. Thanks nathancahill_!is_empty. Thanks nathancahill_!is_equal.is_function. Thanks nathancahill_!is_none. Thanks nathancahill_!is_number. Thanks nathancahill_!is_object.is_plain_object.is_string. Thanks nathancahill_!keys.map_values.matches.max_. Thanks nathancahill_!memoize.merge.min_. Thanks nathancahill_!noop.now.omit.once.pairs.parse_int.partial.partial_right.pick.property_ and prop.pull. Thanks nathancahill_!random.reduce_ and foldl.reduce_right and foldr.reject. Thanks nathancahill_!remove.result.sample.shuffle.size.sort_by. Thanks nathancahill_!tap.throttle.times.transform.to_list. Thanks nathancahill_!unescape.unique_id.values.wrap.xor... _changelog-v0.0.0:
all_.any_.at.bisect_left.collect.collections.compact.contains.detect.difference.drop.each.each_right.every.filter_.find.find_index.find_where.first.flatten.head.include.index_of.initial.intersection.last.last_index_of.map_.object_.pluck.range_.rest.select.some.sorted_index.tail.take.union.uniq.unique.unzip.where.without.zip_.zip_object... _nathancahill: https://github.com/nathancahill .. _k7sleeper: https://github.com/k7sleeper .. _bharadwajyarlagadda: https://github.com/bharadwajyarlagadda .. _urbnjamesmi1: https://github.com/urbnjamesmi1 .. _tgriesser: https://github.com/tgriesser .. _shaunpatterson: https://github.com/shaunpatterson .. _beck3905: https://github.com/beck3905 .. _efenka: https://github.com/efenka .. _jwilson8767: https://github.com/jwilson8767 .. _elijose55: https://github.com/elijose55 .. _gonzalonaveira: https://github.com/gonzalonaveira .. _zhaowb: https://github.com/zhaowb .. _mervynlee94: https://github.com/mervynlee94 .. _weineel: https://github.com/weineel .. _bl4ckst0ne: https://github.com/bl4ckst0ne .. _DeviousStoat: https://github.com/DeviousStoat
MIT License
Copyright (c) 2020 Derrick Gilland
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.