@lopatnov/callable

Abstract class Callable is abstraction for creating new instances of a class as functions, not objects.

Install

npm install @lopatnov/callable

Browser

<script src="//lopatnov.github.io/callable/dist/callable.min.js"></script>

Import package to the project

TypeScript package import

import {
  Callable,
  CallableByCallee,
  CallableByClosure,
  CallableByProxy,
} from "callable";

JavaScript package import

var module = require("callable");
var Callable = module.Callable,
  CallableByCallee = module.CallableByCallee,
  CallableByClosure = module.CallableByClosure,
  CallableByProxy = module.CallableByProxy;

How to use

TypeScript usage

import { Callable } from "callable";

class ChildCallable extends Callable<string> {
  _call(...args: any[]): string {
    return `Hello ${args[0]}`;
  }
}

let x = new ChildCallable(); // <-- returns function
let xc = x("World");

console.log(xc); //Hello World

JavaScript usage

var m = require("@lopatnov/callable");
var Callable = m.Callable;

class ChildCallable extends Callable {
  _call(...args) {
    return `Hello ${args[0]}`;
  }
}

let x = new ChildCallable(); // <-- returns function
let xc = x("World");

console.log(xc); //Hello World

Description of abstract class Callable<TResult> and it's variations

Abstract class Callable has different realizations. They have different plus side and minus side.

The parameter TResult is a result type of a function.

abstract class Callable<TResult>

This is the function bind way.

Plus side

• Doesn’t rely on deprecated or modern features.
• No need to modify prototypes.

Minus side

• Requires wrapping the function object in a bound function.

abstract class CallableByCallee<TResult>

Plus side

• Very simple.
• No need to modify prototypes.

Minus side

• arguments and arguments.callee are unavailable in ‘strict mode’, see MDN for more.

abstract class CallableByProxy<TResult>

Plus side

• Simple, native way to intercept calls and redirect them.
• No need to modify prototypes.

Minus side

• Requires wrapping objects created by Callable in a Proxy.
• A small performance penalty for using Proxy handlers.

abstract class CallableByClosure<TResult>

Plus side

• Requires no wrapping of the returned object with a Proxy or bind.

Minus side

• Requires modifying prototypes.
• Modifying prototypes is slow and has other side effects, see MDN.

Demo

See, how it's working: https://runkit.com/lopatnov/callable-demo

Test it with a runkit: https://npm.runkit.com/@lopatnov/callable

Changelog

Rights and Agreements

License Apache-2.0

Copyright 2019-2020 Oleksandr Lopatnov