Skip to content

fluture-js/fluture-observe

Repository files navigation

Fluture Observe

Consume a Fluture Future, observing changes to its state as the consumption is happening.

Usage

Node

$ npm install --save fluture-observe

On Node 12 and up, this module can be loaded directly with import or require. On Node versions below 12, require or the esm-loader can be used.

Deno and Modern Browsers

You can load the EcmaScript module from various content delivery networks:

Old Browsers and Code Pens

There's a UMD file included in the NPM package, also available via jsDelivr: https://cdn.jsdelivr.net/npm/[email protected]/dist/umd.js

This file adds flutureObserve to the global scope, or use CommonJS/AMD when available.

Usage Example

import {observe, cata} from 'fluture-observe/index.js';

const consume = observe (cata ({
  Idle: () => {
    console.log ('Computation is idle.');
  },
  Pending: cancel => {
    console.log ('Computation is pending. Send SIGINT to cancel it');
    process.once ('SIGINT', cancel);
  },
  Canceled: future => {
    console.log ('Computation was canceled. Send SIGINT to restart it');
    process.once ('SIGINT', () => consume (future));
  },
  Crashed: error => {
    console.error ('I am sorry to inform you:', error);
    process.exit (1);
  },
  Rejected: reason => {
    console.log ('The computation rejected with reason', reason);
  },
  Resolved: value => {
    console.log ('The computation resolved with value', value);
  }
}));

API

A Daggy tagged union type representing the state of the consumption of a Future. The Cancel and Future types below are imported types from Fluture.

data Computation a b = Idle
                     | Pending Cancel
                     | Cancelled (Future a b)
                     | Crashed Error
                     | Rejected a
                     | Resolved b

Constructor details are documented below.

Represents a not running computation.

Represents a running computation which can be cancelled.

Represents a computation that was cancelled and can be restarted.

Represents a computation which encountered an exception while running.

Represents a computation which rejected with a reason.

Represents a computation which resolved with a value.

Daggy's catamorphism as a curried function.

Consume a Future, observing changes to its state. See usage.

About

Consume a Future, observing changes to its state

Topics

Resources

License

Stars

Watchers

Forks

Packages

No packages published