Bottom

@higherkinded/bottom"">
@higherkinded/bottom"">

A set of easily pluggable and extremely touchy empty definitions.

Naming

The name is ripped off the Haskell community’s term for undefined. The idea
partially comes from there as well — a polymorphic value that can be put
anyplace to signify unimplemented functionality.

Motivation

I’ve had a lot of situations where I had to implement some large module and had
to write the bottom function myself just to plug something in place of
implementation for some time. What was also quite important to it is to fend off
any accidental uses by causing the bottom to throw exceptions. Being tired of
rewriting this multiple time and, surprisingly, seeing no alternative
implementations (at all), I’ve written this library. It covers use cases of both
TypeScript bottom-related needs and JavaScript bottom-related needs.

Getting a copy

The first couple of badges under the header both lead to the npm, essentially
giving that aspect away. But in case you want to copy-paste, here you go!

NPM:

npm i @higherkinded/bottom --save

Yarn:

yarn add @higherkinded/bottom

The type definitions are bundled with the library, so if you want some for
your TypeScript project, there’s no need to reach for the @types, got you
covered. The whole package (with definition file and comparedly thick source
map) is around 13 Kb, not to mention that the library itself targets development
versions only, so I suppose that there’s no problem in serving the whole bunch
at once.

How do I?

So how to use it? In case of TypeScript functions, it will be…

import { bottom, bottomFn } from 'bottom';
// ...like this:
const product: (...args: number[]) => number = bottom;
// Or like this:
const someComplexProcedure = <A, B, C, R>(a: A, b: B, c: C): R => {
  /* 
    ...
    Some partial implementation here
    ...
  */
  return bottom();
};
// Or perhaps you want to carry the name?
const namedFunction: <A, R>(a: A): R = bottomFn('namedFunction');
// Also OK in return statement:
const someNamedProcedure = <A, B, C, R>(a: A, b: B, c: C): R => {
  /* 
    ...
    Some partial implementation here
    ...
  */
  return bottomFn('someNamedProcedure')();
};

For classes, you have these options:

import { Bottom, bottomMethod } from 'bottom';
// Declared but unimplemented and uninstantiable class
class Foo extends Bottom {
  /* Bottom-ed method of a class, carrying the info about who they are and who
     owns them. */
  static someMethod = bottomMethod('someMethod', 'Foo');
}