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:

• Skypack
• JSPM
• jsDelivr

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

Computation :: Type

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.

Idle :: Computation a b

Represents a not running computation.

Pending :: Cancel -⁠> Computation a b

Represents a running computation which can be cancelled.

Canceled :: Future a b -⁠> Computation a b

Represents a computation that was cancelled and can be restarted.

Crashed :: Error -⁠> Computation a b

Represents a computation which encountered an exception while running.

Rejected :: a -⁠> Computation a b

Represents a computation which rejected with a reason.

Resolved :: b -⁠> Computation a b

Represents a computation which resolved with a value.

cata :: { Idle :: () -⁠> c, Pending :: Cancel -⁠> c, Canceled :: Future a b -⁠> c, Crashed :: Error -⁠> c, Rejected :: a -⁠> c, Resolved :: b -⁠> c } -⁠> Computation a b -⁠> c

Daggy's catamorphism as a curried function.

observe :: (Computation a b -⁠> Any) -⁠> Future a b -⁠> Undefined

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