custom adapter about iterrr HOT 11 CLOSED

I'm working on Zoom's idea presented in: zero-functional/zero-functional#74

the idea is to convert defined iterator to macros

iterator flatten[T](row: openArray[T]): T {.adapter.} =
  block wrapper: ...
  block before:     ...
  block after:    ...
  
  block reducer:  
     for it in row:
        yield it

# generated code --------------------------------

# type checking stuff - 
iterator flattenType[T](row: openArray[T]): T = discard

macro flattenReducer(row, accFnIdent): untyped =
  result = quote:
    for n in `row`:
      yield n

  const yieldPaths = @[
    @[0, 4, 0],
  ]

  result.replaceYieldsWrapperBody yieldPaths, accFnIdent

macro flattenBefore(): untyped = ... [same as flattenBody but in different context]
macro flattenAfter(): untyped = ...
template flattenWrapper(bodt): untyped = body

the pattern is gonna be:

def states
wrapper:
    before
    loop it:
      reducer it
    after

from iterrr.

I have thought about it for some time, IMO the performant and extensible solution doesn't exist.

For example, think of cycle. How would you implement that with regular code? OK then how would you convert it to extensible pattern, in a way that pattern also works with take or repeat?

And if you could find that pattern, is it performent?

from iterrr.

Use nested loops mate. You have more control

from iterrr.

maybe there are some hopes

from iterrr.

the current implementation, detects the result type by tracking maps.

implementing repeat & cycle is possible, but transformers like flatten & zip requires CORE re-implementation.

from iterrr.

well, I have an idea to implement this.

var s: seq[string] # let's assume that it has some value

s.items |> filter(it.len > 3) |> flatten().map[ch]($ch).filter(it != "0")

you can apply a transformer by |>.

with different syntax (compared to filter & map), it's easy to track data transformation.

from iterrr.

actually I'm trying to figure out a way to easily extend iterrr like mangle.

see how easy it is with closure iterators!
https://github.com/baabelfish/mangle/blob/master/mangle.nim#L143-L149

from iterrr.

I didn't want to use a global variable to store custom adapters, the downside is you loose private/public access control, but there is no other choice [at least I can't think of it at the time - that's what zero_functional does too]

initial states - for now take a look at:

these examples actually work:

result:

@[[1, 2, 3], [4, 5, 6], [7, 8, 9], [1, 2, 3], [4, 5, 6]]
@[1, 2, 3, 4, 5, 6, 7, 8, 9]
@[@[1, 2], @[3, 4], @[5, 6], @[7, 8], @[9, 1]]
@[1, 2, 3, 4, 5, 6, 7, 8, 9, 1]
@[@[[1, 2, 3], [4, 5, 6]]]
@[@[[1, 2, 3], [4, 5, 6]], @[[7, 8, 9]]]

from iterrr.

there are issues with adapters overloading. you can't overload a adapter with the same arity for sure, but there might be solution for overloading with different arity[number of arguments].

from iterrr.

Don't forget about group tails.

iterator group(loop: T; `every`, `wow`: int = 1): seq[T] {.adapter.} =
  var `gacc` = newSeqOfCap[T](`every`)
  for it in loop:
    `gacc`.add it
    if `gacc`.len == `every`:
      yield `gacc`
      `gacc`.setLen(0)
  if `gacc`.len > 0:
    yield `gacc`

from iterrr.

Don't forget about group tails.

thanks. I've added inComplete paramter.

UPDATE

from iterrr.