Added two new functions, looking pretty sweet if you ask me:

export function partial(f, ...xs) {
  return function (...args) {
    return f(...xs, ...args);
  };
}

export function cycle(coll) {
  return new LazyIterable(function* () {
    while (true) yield* coll;
  });
}

looking great. I was looking at the implementation of take-while and curious if there is any particular reason to use manual iterator rather than using for..of

or is it just preference.

good point, probably not

@prabnz Changed it to:

export function take_while(pred, coll) {
  return new LazyIterable(function* () {
    for (const o of iterable(coll)) {
      if (pred(o)) yield val;
      else return;
    }
  });
}

wow, you are very fast. looks good.

also I am wondering if the minifiers actually minify code like new LazyIterable. If not then maybe wrap it in a function to reduce code size.

also simplified drop-while:

export function drop_while(pred, xs) {
  return new LazyIterable(function* () {
    let done_dropping = false;
    for (const o of iterable(xs)) {
      if (done_dropping) yield o;
      else if (!pred(o)) {
        yield o;
        done_dropping = true;
      }
    }
  });
}

@prabnz you mean a function lazy ?

sounds ok

yes, but I am not sure if it will help with minification. I will do some experimentation

well, it will help at least us do less typing ;)

yes, agree

@prabnz I made the lazy constructor function now

https://twitter.com/borkdude/status/1564282034486378498

Hmm, currently working on group-by and this makes me wonder if it should return an object or map, by default. lodash returns an object with the stringified key, which probably works best for interop with the rest of the stuff, rather than returning a Map by default

OTOH, this should probably work, as in CLJS, so Map would make sense:

$ ./node_cli.js -e '(prn (get (group-by odd? [1 2 3 4]) true))'
["0","1","2","3"]

Going with a map then, and if someone will change my mind, I'll be open to that!

Haha, wow, I got bitten by JS twice in the last half an hour:

const o in [1,2,3,4] vs const o of [1,2,3,4]

const update_fn = (fnil conj_BANG_ [])

but now it works as it should:

$ ./node_cli.js -e '(println (group-by odd? [1 2 3 4]))'
Map(2) { true => [ 1, 3 ], false => [ 2, 4 ] }

pushed