async function* timer() {
  let i = 0;
  while (true) {
    yield new Promise((resolve) => setTimeout(() => resolve(++i), 1000));
  }
}
for await (const tick of timer()) {
  console.log(tick);
}
// 1 2 3 ...

function* concat<T>(...iterables: Iterable<T>[]) {
  for (const iter of iterables) {
    yield* iter;
  }
}
for (const i of concat([1, 2], [3, 4])) {
  console.log(i);
}
// 1 2 3 4

import { serve } from "https://deno.land/std@0.74.0/http/server.ts";
const server = serve({ port: 8080 });
console.log("Listening on 8080");
for await (const req of server) {
  req.respond({ status: 200, body: 'Hello, world!' });
}

type MiddlewarePayload = {
  url: URL;
  req: ServerRequest;
};
type MiddlewareFn = (options: MiddlewarePayload) => Promise<true | undefined>;
const combineProcessors = (...fns: MiddlewareFn[]) => async (options: MiddlewarePayload) => {
  for (const fn of fns) {
    const result = await fn(options);
    if (result) {
      return result;
    }
  }
}

const processors = combineProcessors(index, staticFiles, wsMiddleware);
const server = serve({ port: 8080 });
console.log("Listening on 8080");
// для нашей программы не важен host запроса,
// но он нужен для конструктора URL
const BASE = "http://localhost";
for await (const req of server) {
  const url = new URL(req.url, BASE);
  const result = await processors({ url, req });
  if (!result) {
    req.respond({ status: 404 });
  }
}

/** Streams **/
const stream = new Stream();
stream.subscribe(callback);
// где-то далее по коду
stream.emit(data);
/** Channels **/
const ch = new Channel();
// где-то далее по коду
ch.put(data)
// где-то далее по коду
const data = await ch.take();

class Channel {
  private takers: Array<(payload: string) => void> = [];
  private buffer: string[] = [];
  private callTakers() {
    while (this.takers.length > 0 && this.buffer.length > 0) {
      const taker = this.takers.shift()!;
      const payload = this.buffer.shift()!;
      taker(payload);
    }
  }
  take() {
    const p = new Promise<string>((resolve) => {
      this.takers.push(resolve);
    });
    this.callTakers();
    return p;
  }
  put(message: string) {
    this.buffer.push(message);
    this.callTakers();
  }
  async listen(sock: WebSocket) {
    for await (const event of sock) {
      if (typeof event === "string") {
        this.put(event);
      }
    }
  }
}

{
  type: string;
  [key: string]: any;
}

const newState = reducer(state, action)

while (true) {
  const { value: effect, done } = iter.next(current);
  // тут код обработки эффекта
  if (done) break;
}

export async function handleWs(sock: WebSocket) {
  const incoming = new Channel();
  incoming.listen(sock);
  let current: string = "";
  const iter = dialog();
  while (true) {
    const { value: effect, done } = iter.next(current);
    if (!effect) {
      break;
    }
    switch (effect.type) {
      case "say": {
        sock.send(effect.text);
        break;
      }
      case "listen": {
        current = await incoming.take();
         break;
      }
    }
    if (done) {
      break;
    }
  }
}

const say = (text: string) => ({ type: "say", text } as const);
const listen = () => ({ type: "listen" } as const)
function* dialog() {
  yield say('Welcome to "Do what I say BOT"');
  while (true) {
    const message: string = yield listen();
    if (message.toLowerCase().includes("time")) {
      yield say(`It is ${format(new Date(), "HH:mm:ss")}`);
    } else if (message.toLowerCase().includes("sum")) {
      yield* sumSubDialog();
    } else {
      yield say(`I don't know what to say!`);
    }
  }
}
function* sumSubDialog() {
  yield say("Okay, what numbers should we sum?");
  let result = 0;
  let message = yield listen();
  while (true) {
    const num = Number(message);
    if (isNaN(num)) {
      break;
    } else {
      result += num;
    }
    yield say("Got it!");
    message = yield listen();
  }
  yield say(`The result is: ${result}`);
}