ó ËĢ,]c@sUddlmZmZmZddlmZmZdefd„ƒYZd„Z dS(iĸĸĸĸ(tgettertconstpluck(tteetstarmaptEqualityHashKeycBsVeZdZddgZdZd„Zd„Zd„Zd„Zd„Z d „Z RS( sī Create a hash key that uses equality comparisons between items. This may be used to create hash keys for otherwise unhashable types: >>> from toolz import curry >>> EqualityHashDefault = curry(EqualityHashKey, None) >>> set(map(EqualityHashDefault, [[], (), [1], [1]])) # doctest: +SKIP {=[]=, =()=, =[1]=} **Caution:** adding N ``EqualityHashKey`` items to a hash container may require O(N**2) operations, not O(N) as for typical hashable types. Therefore, a suitable key function such as ``tuple`` or ``frozenset`` is usually preferred over using ``EqualityHashKey`` if possible. The ``key`` argument to ``EqualityHashKey`` should be a function or index that returns a hashable object that effectively distinguishes unequal items. This helps avoid the poor scaling that occurs when using the default key. For example, the above example can be improved by using a key function that distinguishes items by length or type: >>> EqualityHashLen = curry(EqualityHashKey, len) >>> EqualityHashType = curry(EqualityHashKey, type) # this works too >>> set(map(EqualityHashLen, [[], (), [1], [1]])) # doctest: +SKIP {=[]=, =()=, =[1]=} ``EqualityHashKey`` is convenient to use when a suitable key function is complicated or unavailable. For example, the following returns all unique values based on equality: >>> from toolz import unique >>> vals = [[], [], (), [1], [1], [2], {}, {}, {}] >>> list(unique(vals, key=EqualityHashDefault)) [[], (), [1], [2], {}] **Warning:** don't change the equality value of an item already in a hash containter. Unhashable types are unhashable for a reason. For example: >>> L1 = [1] ; L2 = [2] >>> s = set(map(EqualityHashDefault, [L1, L2])) >>> s # doctest: +SKIP {=[1]=, =[2]=} >>> L1[0] = 2 # Don't do this! ``s`` now has duplicate items! >>> s # doctest: +SKIP {=[2]=, =[2]=} Although this may appear problematic, immutable data types is a common idiom in functional programming, and``EqualityHashKey`` easily allows the same idiom to be used by convention rather than strict requirement. See Also: identity titemtkeyt__default__hashkey__cCsO|dkr|j|_n't|ƒs9t|ƒ|_n ||_||_dS(N(tNonet_default_hashkeyRtcallableRR(tselfRR((s1lib/python2.7/site-packages/toolz/sandbox/core.pyt__init__@s    cCs:|j|jkr|j}n|j|jƒ}t|ƒS(N(RR Rthash(R tval((s1lib/python2.7/site-packages/toolz/sandbox/core.pyt__hash__Is cCs?y&|j|jko$|j|jkSWntk r:tSXdS(N(R RtAttributeErrortFalse(R tother((s1lib/python2.7/site-packages/toolz/sandbox/core.pyt__eq__Ps  cCs|j|ƒ S(N(R(R R((s1lib/python2.7/site-packages/toolz/sandbox/core.pyt__ne__WscCsdt|jƒS(Ns=%s=(tstrR(R ((s1lib/python2.7/site-packages/toolz/sandbox/core.pyt__str__ZscCsdt|jƒS(Ns=%s=(treprR(R ((s1lib/python2.7/site-packages/toolz/sandbox/core.pyt__repr__]s( t__name__t __module__t__doc__t __slots__R R RRRRR(((s1lib/python2.7/site-packages/toolz/sandbox/core.pyRs5     cCswt|ƒ}ytt|ƒƒ}Wntk r9tƒSXt|ƒ}tt||ƒ|ƒ}tttt |ƒƒƒS(sJInverse of ``zip`` >>> a, b = unzip([('a', 1), ('b', 2)]) >>> list(a) ['a', 'b'] >>> list(b) [1, 2] Unlike the naive implementation ``def unzip(seq): zip(*seq)`` this implementation can handle an infinite sequence ``seq``. Caveats: * The implementation uses ``tee``, and so can use a significant amount of auxiliary storage if the resulting iterators are consumed at different times. * The inner sequence cannot be infinite. In Python 3 ``zip(*seq)`` can be used if ``seq`` is a finite sequence of infinite sequences. ( titerttupletnextt StopIterationtlenRRRRt enumerate(tseqtfirsttniterstseqs((s1lib/python2.7/site-packages/toolz/sandbox/core.pytunzipbs   N( ttoolz.itertoolzRRRt itertoolsRRtobjectRR((((s1lib/python2.7/site-packages/toolz/sandbox/core.pyts[