Module `pyfplib.iterator`

Functions

def main()

Expand source code

def main():
    itr = Iter([1,2,3])
    a = itr.skip(1).reverse().map(lambda i: str(i)).fold(lambda acc, i: f"{acc}/{i}")
    print(a)

Classes

class Iter (iterable: Iterable[~T])

Expand source code

class Iter(Generic[T]):

    def __init__(self, iterable: Iterable[T]):
        self.__iterable = iterable
        self.__prepared: Optional[Iterable[T]] = None
        self.__pipe: List[Callable[[Any], Any]] = []

    def __apply(self) -> List[T]:
        acc = self.__sequence
        for fn in self.__pipe:
            acc = fn(acc)
        self.__pipe = []

    def reverse(self) -> "Iter":
        self.__pipe.append(lambda seq: list(reversed(seq)))
        return self

    def sort(self) -> "Iter":
        self.__pip.append(lambda seq: sorted())
        return self

    def map(self, callback: Callable[[T], Any]) -> "Iter":
        acc = self.__sequence
        for fn in self.__pipe:
            acc = fn(acc)
        self.__acc = acc
        out = list(map(callback, self.__acc))
        return Iter(out)

    def skip(self, number: int) -> "Iter":
        self.__pipe.append(lambda seq: seq[number:])
        return self

    def skip_while(self) -> "Iter":
        pass

    def step_by(self) -> "Iter":
        pass

    def take(self) -> "Iter":
        pass

    def zip(self) -> "Iter":
        pass

    def filter(self, callback: Callable[[T], None]) -> "Iter":
        return self

    def fold(self) -> T:
        pass

    def for_each():
        pass

    def __iter__(self):
        pass

    def collect(self, ctor: Callable[[Iterable[T]], Iterable[Any]]) -> Iterable[Any]:
        """"""
        return ctor(self.__iterable)

Abstract base class for generic types.

On Python 3.12 and newer, generic classes implicitly inherit from Generic when they declare a parameter list after the class's name::

class Mapping[KT, VT]:
    def __getitem__(self, key: KT) -> VT:
        ...
    # Etc.

On older versions of Python, however, generic classes have to explicitly inherit from Generic.

After a class has been declared to be generic, it can then be used as follows::

def lookup_name[KT, VT](mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
    try:
        return mapping[key]
    except KeyError:
        return default

Ancestors

typing.Generic

Methods

def collect(self, ctor: Callable[[Iterable[~T]], Iterable[Any]]) ‑> Iterable[Any]

Expand source code

def collect(self, ctor: Callable[[Iterable[T]], Iterable[Any]]) -> Iterable[Any]:
    """"""
    return ctor(self.__iterable)

def filter(self, callback: Callable[[~T], None]) ‑> Iter

Expand source code

def filter(self, callback: Callable[[T], None]) -> "Iter":
    return self

def fold(self) ‑> ~T

Expand source code

def fold(self) -> T:
    pass

def for_each()

Expand source code

def for_each():
    pass

def map(self, callback: Callable[[~T], Any]) ‑> Iter

Expand source code

def map(self, callback: Callable[[T], Any]) -> "Iter":
    acc = self.__sequence
    for fn in self.__pipe:
        acc = fn(acc)
    self.__acc = acc
    out = list(map(callback, self.__acc))
    return Iter(out)

def reverse(self) ‑> Iter

Expand source code

def reverse(self) -> "Iter":
    self.__pipe.append(lambda seq: list(reversed(seq)))
    return self

def skip(self, number: int) ‑> Iter

Expand source code

def skip(self, number: int) -> "Iter":
    self.__pipe.append(lambda seq: seq[number:])
    return self

def skip_while(self) ‑> Iter

Expand source code

def skip_while(self) -> "Iter":
    pass

def sort(self) ‑> Iter

Expand source code

def sort(self) -> "Iter":
    self.__pip.append(lambda seq: sorted())
    return self

def step_by(self) ‑> Iter

Expand source code

def step_by(self) -> "Iter":
    pass

def take(self) ‑> Iter

Expand source code

def take(self) -> "Iter":
    pass

def zip(self) ‑> Iter

Expand source code

def zip(self) -> "Iter":
    pass