cowboyd

import { fork, timeout, Sequence, Operation } from 'effection';
import { on } from '@effection/events';

import { createConnection } from 'net';

export function* waitConnect(host: string, port: number): Sequence {
  loop: {
    let socket = createConnection(port, host);

    let monitor = fork(function*() {

cowboyd

sudo launchctl unload /System/Library/LaunchDaemons/com.apple.racoon.plist 
sudo launchctl load /System/Library/LaunchDaemons/com.apple.racoon.plist

cowboyd

export function dump(fork: any, indent = '') {
  return `Fork {
  state: ${fork.state}
  operation: ${fork.operation.name}
  children:
${[...fork.children].map(child => dump(child, '  ' + indent)).join("\n")}
}`.split("\n").map(line => `${indent}${line}`).join("\n");

}

cowboyd

import child_process from 'child_process';

/**
 * Continue a process once an event is received:
 * ```ts
 * yield untilEvent(mocha, 'onTestStarted');
 *
 */ 
function untilEvent(emitter, eventName) {
  return execution => {

cowboyd

import { timeout } from 'effection';

/**
 * Run a process in a timebox. In other words, if the
 * process does not complete within the specified time
 * period, throw a timeout error.
 */
export function timebox(durationMillis, proc) {
  return function*() {
    // fork the process

cowboyd

import { execute, call } from 'effection';


// One of the things that struck me was that when I was doing the
// implementation for the `enqueue` function in the task constraining
// functions
// (https://gist.github.com/cowboyd/19122da0c59c674cdea86cf6d70e9c75),
// was the eventual form it took.
//
// Like the other task constructors, it returned a function. Let's

cowboyd

import { execute, timeout, call } from 'effection';


// Rather than shooting for some grandiose templating ability for
// concurrency (I still think we can get there, I just don't see how
// at the moment).  What if we take a smaller step: Given some
// generator, how can we use it to generate a single function that can
// be called over and over and that internally it will manage a set of
// tasks instances for us?
//

cowboyd

// implementation of Erlang genserver restart strategies on supervisor
// http://erlang.org/doc/design_principles/sup_princ.html#one_for_one
//
// For demonstration purposes, the maximum restart intesity logic has been
// omitted. However, it would be straightforward to check restart intesity
// inside each catch block and use it to determine if the error should be
// instead rethrown.

/**
 * one_for_one - If one child process terminates and is to be

cowboyd

let next = over(inventory.item.price, price => price.add(2).add(2).add(2));

cowboyd

❯❯❯❯ yarn clean                                                                                                        ~/C/N/exemplar 7327b0f
yarn run v1.13.0
$ rm -rf platforms *.aab *.ipa *.apk
✨  Done in 0.31s.
❯❯❯❯ rm -rf node_modules                                                                                               ~/C/N/exemplar 7327b0f
❯❯❯❯ yarn cache clean                                                                                                  ~/C/N/exemplar 7327b0f
yarn cache v1.13.0
success Cleared cache.
✨  Done in 5.66s.
❯❯❯❯ yarn                                                                                                              ~/C/N/exemplar 7327b0f