Я хочу что бы семантику STOP пользователь библиотеки понимал, потому что это единственное, но очень мощное решение которое позволит делать очень много мощных штук.
STOP - это как встроенная монада, не требующая выделенного апи и работающая более прозрачно

Я согласен что с первого взгляда это вообще странная штука. Но взвесив все за и против, я думаю это лучший вариант.
Но, опять же, я не всезнающ, мб ошибаюсь, опыт покажет.

Собственно, вот, я замерил масштаб трагедии: https://twitter.com/_jin_nin_/status/1290240982886227969

Дим, ну давай ты туда какой-нибудь предикат с throw сунешь, в первую очередь?)

Смысл генераторов, алгебраических эффектов или выделенного апи в том что бы твой код засунуть в какой-то управляемый контейнер

Вот как этот контейнер на перф влияет и нужно мерить

Я очень-очень сильно подозреваю что генераторы будут эффективнее всего (а еще с ними DX лучше, потому что коллстак сохраняется).

Странно что асинки такие медленные, я недавно на jsperf мерил и там оверхеда практически не было…

Но сам их не взял.
Потому что, по моим наблюдениям, средний прогер в них не оч понимает, пока 🤷‍♂️

Ну, там синхронный тест, так что замерить пенальти в точках асинхронности не получится. Но их в приложении обычно не очень много, так что ими можно пренебречь. А вот весь остальной код приложения замедляется в 100 раз в худшем случае. Зависит от соотношения числа вызовов асинков/генераторов к сложности кода между их вызовами.

Так все синхронные мапинги ты, естественно, будешь описывать через простые функции, а не пихать во что-то.

В тесте, кстати, замеряется лишь синхронная часть асинков. Там ещё и асинхронная часть тяжёлая, но она не попадает в замер. Покажешь свои замеры?

Контейнер в виде фьючи / стора / евента / атома / вотевер нужен именно для описания связей

🤔🤔

const plusOne = (v) => v + 1;

function* g() {
  let v = 0;

  while (v < 1000) {
    v = yield [plusOne, v];
  }
  return [() => {}, v];
}
async function a() {
  let v = 0;

  while (v < 1000) {
    v = await callA([plusOne, v]);
  }
  await callA([() => {}, v]);
}

function callG(g) {
  const it = g();
  let {
    value: [fn, arg],
    done,
  } = it.next();
  while (!done)
    ({
      value: [fn, arg],
      done,
    } = it.next(fn(arg)));
}

async function callA([fn, arg]) {
  return fn(arg);
}

let i = 0;
while (i++ < 1000) {
  callG(g); //?.
  await a(); //?.
}

Там луп общий же, так что не важно

НО, важное замечание, перф мер у квоки НЕ по медиане, а по сред арифметической

Если сделать вот так, разницы вообще не видно

const plusOne = (v) => v + Math.random() * Math.random();

function f() {
 let v = 0;

 while (v < 1000) {
   v = callF([plusOne, v]);
 }
 callF([() => {}, v]);
}

^