Should "infinite" results be built on generators?

[borkdude]

E.g. (range), (repeat :foo), (cycle [1 2 3]) etc. They could be built on iterators, but the surprise lies in the fact that they can be only iterated once. Can and should we do something about that?

/cc @lilactown

[borkdude]

Perhaps we should have a separate clava.generators namespace, similar to clava.transducers where we put the generator based variants?

(ns foo (:require [clava.generators :as gen]))

(take 10 (gen/range))

[lilactown]

I think a way we can do this is create a custom type that is iterable. So something like

class Range {
  constructor(begin, end) {
    this.begin = begin || 0;
    this.end = end;
  }

  *[Symbol.iterator]() {
    let i = this.begin;
    while (i !== this.end) {
      yield i++;
    }
  }
}

function range(begin, end) {
  return new Range(begin, end);
}

The Range type will return a new iterator any time it's passed to map, filter, et al. The difference between this and the way it works in Clojure is that map and filter are not lazy, so if you pass an infinite range you will create an infinite loop. Users can work around this by first calling take (and variants) or transducers that limit the range.

(take 10 (range))

(into [] (comp (filter even?) (map inc) (take 10)) (range))

We can also have Repeat, Cycle, etc. Or a single Iterable type that we pass a generator function to on construction. It could be useful to be able to disambiguate in the future, I'm not sure, I just know that CLJS does.

[brandonstubbs]

Isn't that already achievable? Really happy to help on this at all if you want me to.

class Range {
  constructor(...args) {
    switch (args.length) {
      case 0:
        this.start = 0;
        this.end = Infinity;
        this.step = 1;
        break;
      case 1:
        this.start = 0;
        this.end = args[0];
        this.step = 1;
        break;
      case 2:
        this.start = args[1];
        this.end = args[0];
        this.step = 1;
        break;
      case 2:
        this.start = args[1];
        this.end = args[0];
        this.step = args[2];
        break;
    }
    if (this.step == 0) throw new Error("step cannot be 0");
  }

  *[Symbol.iterator]() {
    let start = this.start;
    while (start < this.end) {
      yield start;
      start += this.step;
    }
  }
}

class Map {
  constructor(f) {
    this.f = f;
  }

  *[Symbol.iterator](...[c1, ...cols]) {
    if (c1 !== null || c1 !== undefined) {
      for (const it of c1[Symbol.iterator]()) yield this.f(it);
    } else {
      // multi cols not imp for demo
    }
  }
}

class TakeWhile {
  constructor(pred) {
    this.pred = pred;
  }

  *[Symbol.iterator](coll) {
    for (const it of coll) {
      if (!this.pred(it)) break;
      yield it;
    }
  }
}

class Take {
  constructor(n) {
    this.n = n;
  }

  *[Symbol.iterator](coll) {
    let counter = 0;
    let pred = () => counter++ < this.n;
    for (const it of coll) {
      if (!pred(it)) break;
      yield it;
    }
  }
}

class Filter {
  constructor(pred) {
    this.pred = pred;
  }

  *[Symbol.iterator](coll) {
    for (const it of coll) if (this.pred(it)) yield it;
  }
}

function __GT_(...fns) {
  return (x) => fns.reduce((y, f) => f[Symbol.iterator](y), x);
}

const example1 = __GT_(new Map((v) => ++v), new Take(10));
console.log([...example1(new Range())]);

const example2 = __GT_(
  new Map((v) => ++v),
  new Filter((v) => v % 2 == 0),
  new Take(10)
);
console.log([...example2(new Range())]);

[lilactown]

I'm not sure what to take from the code you posted @brandonstubbs. What is already possible?

[brandonstubbs]

@lilactown I think I have a misunderstanding, did you mention the 'cons' approach to try and make a lazy seq? Or what did you mean by it?

[lilactown]

I meant that we could add a generic class that would allow us to make lazy infinite sequences that you can add things to the beginning of.

(take 3 (cons "a" (range)))
;; => "a" 0 1

[lilactown]

It could probably look something like

class Cons {
  constructor(x, iter) {
    this.x = x;
    this.iter = iter;
  }

  *[Symbol.iterate]() {
    yield this.x;
    yield* this.iter;
  }
}

function cons(x, coll) {
  return new Cons(x, iterable(coll));
}