Generator[S; T] = Reader[S, T]

Loop[S; T] = object
  scope: LoopScope[S]
  generator: Generator[S, T]

proc mapSteps[SA; SB; T](self: Loop[SA, T]; extractor: SB -> SA;
                      stepperMapper: Stepper[SA] -> Stepper[SB]): Loop[SB, T]

proc mapSteps[SA; SB; T](self: Loop[SA, T]; extractor: SB -> SA; wrapper: SA -> SB): Loop[SB, T]

proc run[S](self: Loop[S, Unit]; initial: S): S

proc runOnce[S; T](self: Loop[S, T]; start: S): RunOnceResult[S, T]

func generator[S; T](g: Reader[S, T]): Generator[S, T]

func generating[S; T](scope: LoopScope[S]; generator: Generator[S, T]): Loop[S, T]

func scope[S; T](X: typedesc[Loop[S, T]]): Lens[X, LoopScope[S]]

func generator[S; A](X: typedesc[Loop[S, A]]; B: typedesc): PLens[X, Generator[S, A],
    Generator[S, B], Loop[S, B]]

func generator[S; T](X: typedesc[Loop[S, T]]): Lens[X, Generator[S, T]]

func condition[S; T](X: typedesc[Loop[S, T]]): Lens[X, Condition[S]]

func stepper[S; T](X: typedesc[Loop[S, T]]): Lens[X, Stepper[S]]

func merge[SA; A; SB; B](self: Loop[SA, A]; other: Loop[SB, B]): Loop[Pair[SA, SB],
    Pair[A, B]]

func emptyLoop(S: typedesc; T: typedesc): Loop[S, T]

func infiniteLoop[S; T](stepper: Stepper[S]; generator: Generator[S, T]): Loop[S, T]

func infiniteLoop[S; T](stepper: S -> S; generator: Generator[S, T]): Loop[S, T]

func asReader[S](self: Loop[S, Unit]): Reader[S, S]

func map[S; A; B](self: Loop[S, A]; f: A -> B): Loop[S, B]

func dropWhile[S; T](self: Loop[S, T]; predicate: Predicate[T]): Reader[S, S]

template stepType[S; T; ](X: typedesc[Loop[S, T]]): typedesc[S]

template stepType[S; T; ](self: Loop[S, T]): typedesc[S]

template itemType[S; T; ](X: typedesc[Loop[S, T]]): typedesc[T]

template itemType[S; T; ](self: Loop[S, T]): typedesc[T]