cowboyd

import { Operation, Channel, resource, Subscription, createChannel } from "./mod.ts";

export function createBufferedChannel<T, TDone>(max: number): Operation<Channel<T,TDone>> {
  return resource(function* (provide) {
    // the unbuffered channel. 
    let input = createChannel<T, TDone>();

    // this channel is used to send whenever a working slot becomes available    
    let available = createChannel<void, never>();

cowboyd

/**
 * Given the following definition of sleep(), how long will this program take to
 * run? 
 * 
 * Try it out with:
 *
 * ```
 * node how-long.js
 * ```
 */

cowboyd

import { main } from "npm:effection@3.0.3";
import { useEventStream } from "./use-event-stream.ts";


// consume the server as an interable.
await main(function* () {
  let source = yield* useEventStream<number, string>("http://localhost:8000");

  let next = yield* source.next();

cowboyd

import { createSignal, resource, type Stream } from "./mod.ts";

/**
 * Consume RAF's as a Stream.
 *
 * ## Example
 *
 * for (let timestamp of yield* each(requestAnimationFrames)) {
 *  // do work
 *  yield* each.next();

cowboyd

import { run, type Operation } from "effection";

export interface TestScope {
  /**
   * Call from your runner's "beforeEach" or equivalent 
   */
  addSetup(op: () => Operation<void>): void;
  
  /**
   * Call from runner's `it()` or equivalent;

cowboyd

// deno-lint-ignore-file no-explicit-any
import { createContext, type Operation } from "./mod.ts";


export interface Console {
  // Logging
  assert(condition?: boolean, ...data: any[]): Operation<void>;
  clear(): Operation<void>;
  debug(...data: any[]): Operation<void>;
  error(...data: any[]): Operation<void>;

cowboyd

import {
  createChannel,
  each,
  Operation,
  resource,
  spawn,
  Task,
} from "effection";

export function useRestartable<TArgs extends unknown[]>(

cowboyd

import { call } from "effection";

function* getUser2(id: number) {
  if (cachedUser) return cachedUser;

  let response = yield* call(fetch(`/users/${id}`));
  return yield* call(response.json());
}

cowboyd

import { createSignal, call, first, each, spawn, sleep, type Operation } from "effection";
import { render } from "$revolution";

export default function* TimerIsland(): Operation<void> {
  let reset = createSignal<void>();
  let start = createSignal<void>();
  let stop = createSignal<void>();

  let elapsed = 0;
  let t0 = performance.now();

cowboyd

import { describe, it } from "https://deno.land/std@0.206.0/testing/bdd.ts"
import { launch } from "https://deno.land/x/astral@0.3.1/mod.ts";

describe("browser", () => {
  it("launches, sleeps, and closes", async () => {
    let browser = await launch();
    await new Promise((resolve) => setTimeout(resolve, 2000));
    browser.close();
  });
});