https://github.com/maxhallinan/kontext
A higher-order function that proxies context to context-free functions.
https://github.com/maxhallinan/kontext
higher-order-function
Last synced: 10 months ago
JSON representation
A higher-order function that proxies context to context-free functions.
- Host: GitHub
- URL: https://github.com/maxhallinan/kontext
- Owner: maxhallinan
- License: mit
- Created: 2017-09-06T19:56:29.000Z (over 8 years ago)
- Default Branch: master
- Last Pushed: 2017-10-04T18:58:14.000Z (over 8 years ago)
- Last Synced: 2024-11-13T14:51:27.082Z (over 1 year ago)
- Topics: higher-order-function
- Language: JavaScript
- Size: 76.2 KB
- Stars: 6
- Watchers: 2
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: readme.md
- License: license
Awesome Lists containing this project
README
# kontext
[](https://travis-ci.org/maxhallinan/kontext)
[](https://coveralls.io/github/maxhallinan/kontext?branch=master)
A higher-order function that proxies context to context free functions.
## Install
```
$ yarn install kontext
```
## Usage
Provide context values to context-free functions.
```javascript
import kontext from 'kontext';
import { compose, log, prop, } from './util';
// define a generic function
const greet = compose(
log,
prop(`greeting`),
);
// define a context
function Greeter(opts = {}) {
this.greeting = opts.greeting;
}
// lift the generic function into the context
Greeter.prototype.greet = kontext([ `greeting`, ])(greet);
const dog = new Greeter({
greeting: `Hello. This is Dog.`,
});
dog.greet(); // 'Hello. This is Dog.'
```
Compose context-free functions with a context setter to mutate the context.
```javascript
import kontext from 'kontext';
import { add, compose, } from './util';
const count = prop(`count`);
const setCount = (count) => ({ count, });
const withCount = kontext([ `count`, ]);
function Counter(opts = {}) {
this.count = opts.init || 0;
}
// compose generic functions with the context setter to mutate the context
const inc = (ctx, setCtx) => compose(
setCtx,
setCount,
add(1),
count,
)(ctx);
Counter.prototype.inc = withCount(inc);
// create reusable logic that isn't coupled to `this`.
const skip = (n, ctx, setCtx) => compose(
setCtx,
setCount,
add(n),
count,
)(ctx);
Counter.prototype.skip = withCount(skip);
const counter = new Counter({ init: 1, });
counter.count; // 1
counter.inc();
counter.count; // 2
counter.skip(10);
counter.count; // 12
```
## API
### kontext(ctxKeys)(baseFunction)
Takes an array of keys and returns a higher-order function. Picks each key from
the context and provides the result to the base function.
#### ctxKeys
Type: `Array k`
An array of keys to pick from the function context.
#### baseFunction(...*, ctx, setCtx)
The function to lift into the context. The higher-order function appends `ctx`
and `setCtx` to the arguments list of `baseFunction`.
##### ctx
Type: `{k: *}`
The result of picking `ctxKeys` from the function context. The `ctx` object is a
collection of key/value pairs. Each `key` is an item in the `ctxKeys` array. Each
value is the value of that key on the function's context. The value of a key
that is not found on the function context is `undefined` on the `ctx` object.
`kontext` binds function values to the context.
##### setCtx(props)
Type: `({k: *}) -> {k: *}`
Updates the context with each of the provided key/value pairs. The values of
existing keys are overwritten. Any key in `props` which refers to an inherited
property will become an own property when updated with `setCtx`.
###### props
Type: `{k: *}`
A collection of key/value pairs where each key is a context property to update
and each value is the new value of that property.
## License
MIT © [Max Hallinan](https://github.com/maxhallinan)