Coverage for src / pyfplib / iterator.py: 0%

1 

2from typing import Any, Callable, Generic, Iterable, List, Optional, TypeVar, Union 

3 

4T = TypeVar("T") 

5 

6class Iter(Generic[T]): 

7 

8 def __init__(self, iterable: Iterable[T]): 

9 self.__iterable = iterable 

10 self.__prepared: Optional[Iterable[T]] = None 

11 self.__pipe: List[Callable[[Any], Any]] = [] 

12 

13 def __apply(self) -> List[T]: 

14 acc = self.__sequence 

15 for fn in self.__pipe: 

16 acc = fn(acc) 

17 self.__pipe = [] 

18 

19 def reverse(self) -> "Iter": 

20 self.__pipe.append(lambda seq: list(reversed(seq))) 

21 return self 

22 

23 def sort(self) -> "Iter": 

24 self.__pip.append(lambda seq: sorted()) 

25 return self 

26 

27 def map(self, callback: Callable[[T], Any]) -> "Iter": 

28 acc = self.__sequence 

29 for fn in self.__pipe: 

30 acc = fn(acc) 

31 self.__acc = acc 

32 out = list(map(callback, self.__acc)) 

33 return Iter(out) 

34 

35 def skip(self, number: int) -> "Iter": 

36 self.__pipe.append(lambda seq: seq[number:]) 

37 return self 

38 

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

40 pass 

41 

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

43 pass 

44 

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

46 pass 

47 

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

49 pass 

50 

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

52 return self 

53 

54 def fold(self) -> T: 

55 pass 

56 

57 def for_each(): 

58 pass 

59 

60 def __iter__(self): 

61 pass 

62 

63 def collect(self, ctor: Callable[[Iterable[T]], Iterable[Any]]) -> Iterable[Any]: 

64 """""" 

65 return ctor(self.__iterable) 

66 

67 

68def main(): 

69 itr = Iter([1,2,3]) 

70 a = itr.skip(1).reverse().map(lambda i: str(i)).fold(lambda acc, i: f"{acc}/{i}") 

71 print(a)