PK!088another_linked_list/__init__.pyfrom .index import LinkedList __all__ = ["LinkedList"] PK!rb#another_linked_list/fns/__init__.pyfrom .isEmpty import isEmpty from .isLaden import isLaden from .joinWith import joinWith from .map_ import map_ from .passThrough import passThrough from .raise_ import raise_ __all__ = ["isEmpty", "isLaden", "joinWith", "map_", "passThrough", "raise_"] PK!.another_linked_list/fns/decorators/__init__.pyPK![`)gEE3another_linked_list/fns/decorators/argIsCallable.pyfrom inspect import signature import wrapt @wrapt.decorator def argIsCallable(fn, _instance, args, kwargs): if not callable(args[0]): argName = list(signature(fn).parameters)[0] fnName = fn.__name__ raise ValueError(f"{fnName} requires {argName} to be callable") return fn(*args, **kwargs) PK!waII0another_linked_list/fns/decorators/argIsClass.pyfrom inspect import isclass, signature import wrapt @wrapt.decorator def argIsClass(fn, _instance, args, kwargs): if not isclass(args[0]): argName = list(signature(fn).parameters)[0] fnName = fn.__name__ raise ValueError(f"{fnName} requires {argName} to be a class") return fn(*args, **kwargs) PK!5another_linked_list/fns/decorators/argIsListOfType.pyfrom ordered_set import OrderedSet import wrapt from ..internal.discardWhen import discardWhen from ..internal.get import get from ..internal.getArgName import getArgName from ..internal.isLaden import isLaden from ..internal.isType import isType from ..internal.joinWith import joinWith from ..internal.map_ import map_ from ..internal.passThrough import passThrough from ..internal.raise_ import raise_ from ..internal.sort import sort from ..internal.toType import toType def argIsListOfType(aType): @wrapt.decorator def wrapper(fn, _instance, args, kwargs): typePassed = type(args[0]) fnName = fn.__name__ typeName = aType.__name__ if typePassed is not list: argName = getArgName(fn) raise_( ValueError, f"""\ {fnName} requires {argName} to have the type list type passed: {typePassed.__name__} """, ) invalidTypes = discardWhen(isType(aType))(args[0]) if isLaden(invalidTypes): argName = getArgName(fn) invalidTypeNames = passThrough( invalidTypes, [ map_(toType), OrderedSet, list, map_(get("__name__")), sort, joinWith(", "), ], ) raise_( ValueError, f"""\ {fnName} requires {argName} to be a list of {typeName} invalid types passed: {invalidTypeNames} """, ) return fn(*args, **kwargs) return wrapper PK!)ʋ/another_linked_list/fns/decorators/argIsType.pyfrom inspect import signature from ..internal.raise_ import raise_ import wrapt def argIsType(aType): @wrapt.decorator def wrapper(fn, _instance, args, kwargs): typePassed = type(args[0]) if typePassed is not str: argName = list(signature(fn).parameters)[0] fnName = fn.__name__ typeName = aType.__name__ raise_( ValueError, f"""\ {fnName} requires {argName} to have the type {typeName} type passed: {typePassed.__name__} """, ) return fn(*args, **kwargs) return wrapper PK!,another_linked_list/fns/internal/__init__.pyPK!F/another_linked_list/fns/internal/discardWhen.py# ------- # # Imports # # ------- # from .getTypedResult import getTypedResult from .makeGenericCallFn import makeGenericCallFn from ..decorators.argIsCallable import argIsCallable # ---- # # Main # # ---- # @argIsCallable def discardWhen(predicate): fnName = discardWhen.__name__ shouldDiscard = makeGenericCallFn(predicate, 3, fnName) def discardWhen_inner(collection): typedDiscardWhen = getTypedResult(collection, typeToDiscardWhen, fnName) return typedDiscardWhen(shouldDiscard, collection) return discardWhen_inner # ------- # # Helpers # # ------- # def discardWhen_list(shouldDiscard, aList): result = [] for idx, el in enumerate(aList): if not shouldDiscard(el, idx, aList): result.append(el) return result def discardWhen_dict(shouldDiscard, aDict): result = {} for key, val in aDict.items(): if shouldDiscard(val, key, aDict): result[key] = val return result typeToDiscardWhen = {list: discardWhen_list, dict: discardWhen_dict} PK!ss'another_linked_list/fns/internal/get.pydef get(attrName): def get_inner(something): return getattr(something, attrName) return get_inner PK!)jj.another_linked_list/fns/internal/getArgName.pyfrom inspect import signature def getArgName(fn, idx=0): return list(signature(fn).parameters)[idx] PK!X2another_linked_list/fns/internal/getFnSignature.pyfrom inspect import signature from .raise_ import raise_ def getFnSignature(fn, callerName): try: return signature(fn) except Exception as e: raise_( ValueError, f"""\ '{callerName}' is unable to get the signature of the passed callable callable passed: {fn.__name__} one reason this could occur is the callable is written in c (e.g. the builtin 'str' callable). """, fromException=e, ) PK!k:another_linked_list/fns/internal/getNumPositionalParams.py# ------- # # Imports # # ------- # from inspect import Parameter from math import inf from .getFnSignature import getFnSignature from .iif import iif # ---- # # Init # # ---- # _nonVarPositionalParamKinds = { Parameter.POSITIONAL_ONLY, Parameter.POSITIONAL_OR_KEYWORD, } # ---- # # Main # # ---- # # # Returns a tuple # numRequired: number of required positional params # numAllowed: number of allowed positional params # def getNumPositionalParams(fn, callerName): sig = getFnSignature(fn, callerName) numAllowed = iif(_hasVarPositionalParam(sig), inf, 0) numRequired = 0 for p in sig.parameters.values(): if p.kind in _nonVarPositionalParamKinds: numAllowed += 1 if p.default is Parameter.empty: numRequired += 1 return (numRequired, numAllowed) # ------- # # Helpers # # ------- # def _hasVarPositionalParam(sig): for p in sig.parameters.values(): if p.kind is Parameter.VAR_POSITIONAL: return True PK!w<2another_linked_list/fns/internal/getTypedResult.py# # README # - I'm not sure what to call this. Its purpose is to centralize the type # validation, minimizing copy/paste. # # ------- # # Imports # # ------- # from .raise_ import raise_ from .get import get # ---- # # Init # # ---- # getName = get("__name__") # # we need a unique object here to ensure the 'typeToSomething' doesn't lead us # to a 'None' value # nothing = object() # ---- # # Main # # ---- # def getTypedResult(value, typeToSomething, fnName): valueType = type(value) result = typeToSomething.get(valueType, nothing) if _isSomething(result): return result supportedTypes = ", ".join(map(getName, typeToSomething.keys())) raise_( ValueError, f"""\ {fnName} doesn't support the type '{valueType.__name__}' supported types: {supportedTypes} """, ) # ------- # # Helpers # # ------- # def _isSomething(x): return x is not nothing PK!;||'another_linked_list/fns/internal/iif.pydef iif(condition, whenTruthy, whenFalsey): if condition: return whenTruthy else: return whenFalsey PK!ws{33+another_linked_list/fns/internal/isLaden.pydef isLaden(aList): return len(aList) is not 0 PK!Ȋ4another_linked_list/fns/internal/isOnlyWhitespace.pyimport re onlyWhitespaceRe = re.compile(r"\s*$") def isOnlyWhitespace(aString): return onlyWhitespaceRe.match(aString) is not None PK!f*another_linked_list/fns/internal/isType.pyfrom inspect import isclass def isType(aType): if not isclass(aType): raise ValueError("isType requires argument 'aType' to pass isclass") def isType_inner(something): return type(something) is aType return isType_inner PK!v_R*++,another_linked_list/fns/internal/joinWith.py# ------- # # Imports # # ------- # from ordered_set import OrderedSet from .getTypedResult import getTypedResult # ---- # # Main # # ---- # def joinWith(separator): def joinWith_inner(collection): typedJoinWith = getTypedResult(collection, typeToJoinWith, "joinWith") return typedJoinWith(separator, collection) return joinWith_inner # ------- # # Helpers # # ------- # def joinWith_iterable(separator, aList): return separator.join(aList) typeToJoinWith = {list: joinWith_iterable, OrderedSet: joinWith_iterable} PK!K.another_linked_list/fns/internal/makeCallFn.py# ------- # # Imports # # ------- # from math import inf from .returnFirstArgument import returnFirstArgument as identity from .getNumPositionalParams import getNumPositionalParams # ---- # # Main # # ---- # def makeCallFn(fn, callerName, *, modifyResult=identity): (_, allowed) = getNumPositionalParams(fn, callerName) if allowed is inf: return lambda *args, **kwargs: modifyResult(fn(*args, **kwargs)) else: return lambda *args, **kwargs: modifyResult( fn(*args[:allowed], **kwargs) ) PK!T-5another_linked_list/fns/internal/makeGenericCallFn.py# ------- # # Imports # # ------- # from math import inf from .getNumPositionalParams import getNumPositionalParams from .raise_ import raise_ # ---- # # Main # # ---- # def makeGenericCallFn(fn, maxParams, callerName): required, allowed = getNumPositionalParams(fn, callerName) if allowed is inf: allowed = maxParams if required > maxParams: raise_( ValueError, f""" {callerName} can only take functions with up to {maxParams} positional params. The function '{fn.__name__}' requires {required} """, ) return lambda *args, **kwargs: fn(*args[:allowed], **kwargs) PK!G~(another_linked_list/fns/internal/map_.py# ------- # # Imports # # ------- # from .makeGenericCallFn import makeGenericCallFn from .getTypedResult import getTypedResult from ..decorators.argIsCallable import argIsCallable # ---- # # Main # # ---- # @argIsCallable def map_(mapperFn): fnName = map_.__name__ callMapperFn = makeGenericCallFn(mapperFn, 3, fnName) def map_inner(collection): typedMap = getTypedResult(collection, typeToMap, fnName) return typedMap(callMapperFn, collection) return map_inner # ------- # # Helpers # # ------- # def map_list(callMapperFn, aList): result = [] for idx, el in enumerate(aList): result.append(callMapperFn(el, idx, aList)) return result typeToMap = {list: map_list} PK!yy/another_linked_list/fns/internal/passThrough.pyfrom .reduce import reduce def passThrough(arg, fnList): return reduce(lambda result, fn: fn(result), arg)(fnList) PK!W*another_linked_list/fns/internal/raise_.pyfrom tedent import tedent from .isOnlyWhitespace import isOnlyWhitespace import os def raise_(errorClass, message, *, fromException=None): allLines = message.split(os.linesep) if isOnlyWhitespace(allLines[0]) and isOnlyWhitespace(allLines[-1]): message = tedent(message) err = errorClass(message) if fromException is None: raise err else: raise err from fromException PK!Et*another_linked_list/fns/internal/reduce.py# ------- # # Imports # # ------- # from .makeGenericCallFn import makeGenericCallFn from .getTypedResult import getTypedResult from ..decorators.argIsCallable import argIsCallable # ---- # # Main # # ---- # @argIsCallable def reduce(fn, initial): reducerFn = makeGenericCallFn(fn, 4, "reduce") def reduce_inner(collection): typedReduce = getTypedResult(collection, typeToReduce, "reduce") return typedReduce(reducerFn, initial, collection) return reduce_inner # ------- # # Helpers # # ------- # def reduce_list(reducerFn, initial, aList): result = initial for idx, el in enumerate(aList): result = reducerFn(result, el, idx, aList) return result typeToReduce = {list: reduce_list} PK!pjj7another_linked_list/fns/internal/returnFirstArgument.pyfrom .iif import iif def returnFirstArgument(*args, **kwargs): return iif(len(args), args[0], None) PK!\xx3another_linked_list/fns/internal/sanitizeAscDesc.pyfrom .raise_ import raise_ ascDescSet = {"asc", "desc"} def sanitizeAscDesc(ascOrDesc): sanitized = ascOrDesc.lower() if sanitized not in ascDescSet: raise_( ValueError, f""" ascOrDesc must be either 'asc' or 'desc' (case insensitive) value given: {ascOrDesc} """, ) return sanitized PK!0oo(another_linked_list/fns/internal/sort.py# ------- # # Imports # # ------- # from .getTypedResult import getTypedResult # ---- # # Main # # ---- # def sort(collection): typedSort = getTypedResult(collection, typeToSort, "sort") return typedSort(collection) # ------- # # Helpers # # ------- # def sort_viaSorted(something): return sorted(something) typeToSort = {list: sort_viaSorted} PK!V;22*another_linked_list/fns/internal/toType.pydef toType(something): return type(something) PK!¢["another_linked_list/fns/isEmpty.pyfrom types import SimpleNamespace # TODO: make 'isEmpty' generic like the other utils def isEmpty(lenAble): if isinstance(lenAble, SimpleNamespace): return len(lenAble.__dict__) is 0 else: return len(lenAble) is 0 PK!X33"another_linked_list/fns/isLaden.pyfrom .internal.isLaden import isLaden # noqa f401 PK!955#another_linked_list/fns/joinWith.pyfrom .internal.joinWith import joinWith # noqa f401 PK!}--another_linked_list/fns/map_.pyfrom .internal.map_ import map_ # noqa f401 PK!F;;&another_linked_list/fns/passThrough.pyfrom .internal.passThrough import passThrough # noqa f401 PK!(11!another_linked_list/fns/raise_.pyfrom .internal.raise_ import raise_ # noqa f401 PK!:==another_linked_list/index.py# ------- # # Imports # # ------- # from all_purpose_set import ApSet from types import SimpleNamespace as o from .fns import isEmpty, isLaden, raise_ # ---- # # Init # # ---- # nodeAttrs = ["element", "next_", "previous"] # ---- # # Main # # ---- # class LinkedList: def __init__(self, aList=[]): validateInput(aList) self._setOfNodes = ApSet() if isLaden(aList): self._populateData(aList) else: self.firstNode = None self.lastNode = None def _populateData(self, aList): self.firstNode = self.lastNode = tmpNode = node(aList[0]) self._setOfNodes.add(self.firstNode) for element in aList[1:]: tmpNode = self.lastNode self.lastNode = node(element, previous=tmpNode) self._setOfNodes.add(self.lastNode) tmpNode.next_ = self.lastNode def _addInitialNode(self, element): initialNode = node(element) self._setOfNodes.add(initialNode) self.firstNode = initialNode self.lastNode = initialNode return self def __copy__(self): result = LinkedList() for el in self: result.append(el) return result def __iter__(self): return LinkedListIterator(self.firstNode) def __len__(self): return len(self._setOfNodes) def __reversed__(self): return LinkedListReverseIterator(self.lastNode) def append(self, element): if isEmpty(self._setOfNodes): return self._addInitialNode(element) newLastNode = node(element, previous=self.lastNode) self._setOfNodes.add(newLastNode) self.lastNode.next_ = newLastNode self.lastNode = newLastNode return self copy = __copy__ def appendAll(self, aList): validateList(aList) for el in aList: self.append(el) return self def findFirstNode(self, element): tmpNode = self.firstNode while tmpNode: if tmpNode.element == element: return tmpNode tmpNode = tmpNode.next_ raise_( ValueError, f""" The element passed does not exist in this linked list element: {element} """, ) def insertAfter(self, aNode, element): validateNode(self, aNode) tmpNode = node(element, next_=aNode.next_, previous=aNode) self._setOfNodes.add(tmpNode) if aNode.next_: aNode.next_.previous = tmpNode else: self.lastNode = tmpNode aNode.next_ = tmpNode return self def insertAllAfter(self, aNode, aList): validateNode(self, aNode) validateList(aList) nextNode = aNode.next_ if nextNode is None: return self.appendAll(aList) curNode = aNode for el in aList: nodeToInsert = node(el, previous=curNode) self._setOfNodes.add(nodeToInsert) curNode.next_ = nodeToInsert curNode = nodeToInsert curNode.next_ = nextNode nextNode.previous = curNode return self def insertAllBefore(self, aNode, aList): validateNode(self, aNode) validateList(aList) previousNode = aNode.previous if previousNode is None: return self.prependAll(aList) curNode = aNode for el in reversed(aList): nodeToInsert = node(el, next_=curNode) self._setOfNodes.add(nodeToInsert) curNode.previous = nodeToInsert curNode = nodeToInsert curNode.previous = previousNode previousNode.next_ = curNode return self def insertBefore(self, aNode, element): validateNode(self, aNode) tmpNode = node(element, next_=aNode, previous=aNode.previous) self._setOfNodes.add(tmpNode) if aNode.previous: aNode.previous.next_ = tmpNode else: self.firstNode = tmpNode aNode.previous = tmpNode return self def prepend(self, element): if isEmpty(self._setOfNodes): return self._addInitialNode(element) newFirstNode = node(element, next_=self.firstNode) self._setOfNodes.add(newFirstNode) self.firstNode.previous = newFirstNode self.firstNode = newFirstNode return self def prependAll(self, aList): validateList(aList) for el in reversed(aList): self.prepend(el) return self def removeFirstElement(self, element): self.removeNode(self.findFirstNode(element)) return self def removeNode(self, aNode): validateNode(self, aNode) self._setOfNodes.remove(aNode) prev = aNode.previous next_ = aNode.next_ if prev: prev.next_ = next_ if next_: next_.previous = prev return self class LinkedListIterator: def __init__(self, firstNode): self._curNode = firstNode def __iter__(self): return self def __next__(self): if self._curNode is None: raise StopIteration result = self._curNode.element self._curNode = self._curNode.next_ return result class LinkedListReverseIterator: def __init__(self, lastNode): self._curNode = lastNode def __iter__(self): return self def __next__(self): if self._curNode is None: raise StopIteration result = self._curNode.element self._curNode = self._curNode.previous return result def node(element, *, next_=None, previous=None): return o(element=element, next_=next_, previous=previous) # ------- # # Helpers # # ------- # def validateList(aList): if not (isinstance(aList, LinkedList) or isinstance(aList, list)): raise_( ValueError, f""" aList must be either a LinkedList or a list type given: {type(aList).__name__} """, ) def validateNode(self, aNode): for attr in nodeAttrs: validateNodeAttr(attr, aNode) if aNode not in self._setOfNodes: raise_( ValueError, """ The node given is not in this linked list, thus you cannot operate on it. """, ) def validateNodeAttr(attr, aNode): if not hasattr(aNode, attr): raise_( ValueError, f""" The node given is not valid which means it's been mutated outside this class! node has no attribute '{attr}' """, ) def validateInput(aList): if not isinstance(aList, list): raise_( ValueError, f""" aList is not an instance of list type given: {type(aList).__name__} """, ) PK!4 Everyone is permitted to copy and distribute verbatim or modified copies of this license document, and changing it is allowed as long as the name is changed. DO WHAT THE FUCK YOU WANT TO BUT IT'S NOT MY FAULT PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. You just DO WHAT THE FUCK YOU WANT TO. 1. Do not hold the author(s), creator(s), developer(s) or distributor(s) liable for anything that happens or goes wrong with your use of the work. PK!HڽTU)another_linked_list-0.1.0.dist-info/WHEEL A н#Z;/"d&F[xzw@Zpy3Fv]\fi4WZ^EgM_-]#0(q7PK!HE,0,another_linked_list-0.1.0.dist-info/METADATAXmo6_1XJ=ɝo"^?ABKFU );c~$r3oL~V$ŠRL#6: &#a2`#vF']]BF4&/E,E̦P'Qex$.di.JKr Vb/QϢX*7jϥ,&7?OqmSG1VoCY,Q" LK~\A'mY=L4&g3z {jQqUe]C̐@.mEehfqJaCY)JΕ.\ x?[t|;ewi!K Mo>PKa$=KYsǁG.aT-IxmGttyq5Wwtwazu3nz9dmszC>^a0Y.Iͩ  S?z%̄Z6/E !`g>ʰD s|{·&sl>T`&.Vk1Ftcku64ljI,[K)2 P<뗓*Mzt:jAH% Rtt3QUۘX1%YRv-7TJzU6UIR.S%ŸZ(uDQ۫vzS Z9>Ҷ38l&@mӑ8ь>C,b`63h6zt :H-r1/␥T鬴=>@܊;㟘 %^p/*OמC.:KhD5 Bcײ PQJr/%z @D UB4+c JTyg9 ʼnu8y Ģ6ߨ)NI (Odž4٢#Όl ]c ' 8ymk_3o#sB'ܘ@8OifIOF'\"h1 23rG+7-O7Wv3sYps@+c׾[nLqK CBA#mĨ&\K9&뜿<jBE~RPԋ[Q` ^orYn"m2qٴxСhG;]wO= Kpbmx;̝J f9۴n9>o̖q;7xx݇?Ʒ8Pbn[RȻmZy;۶=~67O4ҭkšPCs;0?38VZ;~>DX{K!j i~͵50oX6o擿 L%bپ] }c@aLa~Ŝ ~m},a߳෻NhkRTrm8MtpCOTJZL Ie~62/.DPK!H恠!*another_linked_list-0.1.0.dist-info/RECORDҢZYMA. 81Qـӷ]a`"ɕ+h\m:oB`8"ɞlؑ[OؤrX{Ir_-J2)@K-'ʇRNZ4Mq`z0K +וfMDrGU9ΊN>ajb5 ll׬ְ4{>8s 0犴O' `b|TQ5S ┓PR^mĮj7 =HY Xő>د?<\deˉte% A8`8G9'ܓCkz.l`蹋׵2co处fkxG[LoAsBVYtsL׮m{q>E %8Ժ(]?Mq?spxחB|xe 2+ގmsZ[3PPi.b~eoXȆnZMU8Wwŵ`y2[ (LPp^Mtk9޾?"9cG z=hZ@)8>%ا|ZFN0_^1Gv|Y<n4|CFŢ0QxBbWL*M#ؙR5g*>)6fg̟8.MS%\2[UY`G|2vznqw'JYV[ԹY@e klQ4gܱ !ɛ1I5n7oW˿m_N2jLk|0%*ڨnou![4ֳ^ $4ǒ5Rh@o-qJqoJ.{j|d[~xٝK~Pw[/0"*TEa pјćk72{UxS$x7{erv"t U֟ݘk?{0[^ٳ|dbZ1'Ŏ\iOhlRG5-xfzCWAT 3^F K=ƿQF^mݮ,0VJ8j.Y(lKWz[`l`_9iU@lԯC:sFA0sൔ'qB&搲h ّR钫+i[;YU#|B{)"͡Ң2WA'znIü̮>H9+c.)OQ,"ڭV(*~#]zRO}7~5. ܽkY(ئ.<`4쿤{kR5/|ygp5.MJ/b0hb ñ3%=CŎoݜSRHʌ6A9ʛ@J"e1cǧd]Ӽ]=GcŻ 3 Zh38I&˝~>BEIW͹+,na-N+!RglI}Q߲?6G6f$=zJN{.FĻj@>4ߙ"/N eU'éKl,lpi]Aא3'm~}Z@|Mq} PK!088another_linked_list/__init__.pyPK!rb#uanother_linked_list/fns/__init__.pyPK!.another_linked_list/fns/decorators/__init__.pyPK![`)gEE3another_linked_list/fns/decorators/argIsCallable.pyPK!waII0another_linked_list/fns/decorators/argIsClass.pyPK!5.another_linked_list/fns/decorators/argIsListOfType.pyPK!)ʋ/. another_linked_list/fns/decorators/argIsType.pyPK!,another_linked_list/fns/internal/__init__.pyPK!F/Panother_linked_list/fns/internal/discardWhen.pyPK!ss'another_linked_list/fns/internal/get.pyPK!)jj.qanother_linked_list/fns/internal/getArgName.pyPK!X2'another_linked_list/fns/internal/getFnSignature.pyPK!k:}another_linked_list/fns/internal/getNumPositionalParams.pyPK!w<2another_linked_list/fns/internal/getTypedResult.pyPK!;||'another_linked_list/fns/internal/iif.pyPK!ws{33+ another_linked_list/fns/internal/isLaden.pyPK!Ȋ4!another_linked_list/fns/internal/isOnlyWhitespace.pyPK!f*!another_linked_list/fns/internal/isType.pyPK!v_R*++,1#another_linked_list/fns/internal/joinWith.pyPK!K.%another_linked_list/fns/internal/makeCallFn.pyPK!T-5(another_linked_list/fns/internal/makeGenericCallFn.pyPK!G~(+another_linked_list/fns/internal/map_.pyPK!yy/&.another_linked_list/fns/internal/passThrough.pyPK!W*.another_linked_list/fns/internal/raise_.pyPK!Et*0another_linked_list/fns/internal/reduce.pyPK!pjj74another_linked_list/fns/internal/returnFirstArgument.pyPK!\xx34another_linked_list/fns/internal/sanitizeAscDesc.pyPK!0oo(6another_linked_list/fns/internal/sort.pyPK!V;22*B8another_linked_list/fns/internal/toType.pyPK!¢["8another_linked_list/fns/isEmpty.pyPK!X33"9another_linked_list/fns/isLaden.pyPK!955#a:another_linked_list/fns/joinWith.pyPK!}--:another_linked_list/fns/map_.pyPK!F;;&A;another_linked_list/fns/passThrough.pyPK!(11!;another_linked_list/fns/raise_.pyPK!:==0<another_linked_list/index.pyPK!4