Seqs & iterators about squint

[lilactown]

It looks like destructuring uses the iterable protocol, so we can easily do

export function first(coll) {
  // destructuring uses iterable protocol
  let [first] = coll;
  return first;
}

export function rest(coll) {
  let [_, ...rest] = coll;
  return rest;
}

and get the behavior we want, fast.

[borkdude]

@lilactown So far this makes a ton of sense to me :)

Perhaps add a bit to the README about differences to ClojureScript, basically what you said in your last comment

[lilactown]

I'm not sure yet how this relates to things like first, rest and cons. first could take an iterable, create an iterator and return the first, throwing away the iterator. rest could copy map and convert the iterable to an array before returning. 🤔

[lilactown]

A downside I've found in implementing & using this in tests is that objects (as created via {:a 1}) does not implement the Iterable protocol. So you cannot pass an object created via {:a 1} as a collection to map, reduce, etc.

You can get access to an iterator via functions like Object.keys, Object.values and Object.entries.

A thought I have: provide a helper function iterable which coerces the value passed to it as something iterable, very similar to seq. For arrays, sets, maps and anything else that already implements the Iterable method, it would pass through unchanged. If the value is an object, it will return Object.entries(o). This can be used internally in reduce, map, etc. to allow them to be used on objects without having to extend the iteratable protocol to them.

Thoughts?

[borkdude]

An internal function is always ok. Not sure if we should expose this. Perhaps we could expose it as seq, which would return nil if the iterator was empty, like in Clojure...?

[borkdude]

There's also a -iterator function in CLJS (which is a protocol method really) whose name we could re-use...

[lilactown]

Writing down some notes for posterity:

• Iterator: an object with the structure {next, done, value}. next() when called progresses the iterator, value is a property that contains the current value, and done is a property that signals the iterator is exhausted.
• Iterable: an object that has the Symbol.iterator method on it, which can be called to create a new Iterator object

The thing that makes this tricky is that the for...of comprehension and JS destructuring expect an Iterable, not an Iterator object. So working with a raw Iterator object is also not a complete replacement of ISeq.

Perhaps seq would make sense if it took an Iterable, checked to see if it's empty, and returned nil if so. It could also support nil punning. I'm starting to like that idea @borkdude.

[lilactown]

Hmmm but null is not iterable, so passing nil or an empty collection to any seq functions will throw in that case.

[borkdude]

Unless those explicitly support nil?

[lilactown]

@borkdude In the PR I just opened, I am trying the following:

• seq is the Clojure-like: takes a collection and returns an Iterable of that collection, or nil if it's empty
• iterable takes a collection and returns an Iterable of that collection, even if it's empty
• seqable? can be used to check if you can call either one

first, rest, map, reduce et al. use iterable to avoid having to do explicit nil checks, which they would need to do if they called seq.

[borkdude]

Alright, I think we could close this now, probably, since we pretty much locked down the seq + iterator behavior, unless you have something to add @lilactown ?

[lilactown]

I think the only thing left is to add the rest of the sequence functions, which I can create more issues for

[brandonstubbs]

@lilactown I am catching up on all of this, just leaving this here for thought Reading this and the transducers issue it's exactly your thoughts, let me know if you want any help with anything

function _first([x]) {
  return x;
}

function _toArray(iterable) {
  const array = [];
  for (const x of iterable) {
    array.push(x);
  }
  return array;
}

function* _map(iterable, f) {
  for (const x of iterable) {
    yield f(x); 
  }
}

function* _filter(iterable, pred) {
  for (const x of iterable) {
    if (pred(x)) {
      yield x;
    }
  }
}

function map(f, coll) {
  return _toArray(_map(coll, f));
}

function filter(pred, coll) {
  return _toArray(_filter(coll, pred))
}

console.log(map((v) => v + 1,new Array(1, 2)))
console.log(filter((v) => v === 2, new Array(1, 2)))

function transformer(iterable) {
  return {
    first: () => _first(iterable),
    map: f => transformer(_map(iterable, f)),
    filter: pred => transformer(_filter(iterable, pred)),
    toArray: () => _toArray(iterable),
    [Symbol.iterator]: () => iterable[Symbol.iterator](),
  }
}

console.log(
  transformer(new Array(1, 2))
    .map(v => v + 1)
    .filter(v => v == 2)
    .first()
);

console.log(
  transformer(new Array(1, 2))
    .map(v => v + 1)
    .filter(v => v == 2)
    .toArray()
);