FxJS is a functional programming library based on ECMAScript 6. Iterable, Iterator, Generator, Promise.
fx.js is a bundle of FxJS written in the ECMAScript Module as a single script file that can be run in a browser.
Note: fx.js uses the fx, _, L, and C properties of the window object as namespaces.
<script src="https://unpkg.com/fxjs/dist/fx.min.js"></script>
fx.es5.js is the build of FxJS as an IE11 browser target.
Note: Like fx.js, fx.es5.js also use the window object's fx, _, L, and C properties as namespace.
<script src="https://unpkg.com/fxjs/dist/fx.es5.min.js"></script>
FxJS is developed as ECMAScript Module.
However, the files published in the fxjs package are the CommonJS Module,
which is transpiled to support Node.js 6 version.
npm install fxjs
const FxJS = require("fxjs");
const _ = require("fxjs/Strict");
const L = require("fxjs/Lazy");
const C = require("fxjs/Concurrency");
// You can also import the functions individually.
const rangeLazy = require("fxjs/Lazy/rangeLazy");
_.go(
rangeLazy(1, 5),
L.filter(a => a % 2),
L.map(a => a * 10),
_.reduce(_.add),
_.log); // 40
FxJS publishes the fxjs2 package, which is written only with the native ECMAScript Module.
In the fxjs2 package, the type field is defined as module in the package.json file.
Development tools like mocha and jest do not yet support Native ESM, so be careful about using it.
npm install fxjs2
import { go, reduce, add, log, L } from "fxjs2";
go(
L.range(1, 5),
L.filter(a => a % 2),
L.map(a => a * 10),
reduce(add),
log); // 40
You can evaluate the iterator as a function of FxJS.
function *fibonacci() {
let a = 0, b = 1;
while (true) {
yield a;
[a, b] = [b, a + b];
}
}
const f = pipe(
fibonacci,
L.filter(n => n % 2 == 0),
L.takeWhile(n => n < 10));
const iterator = f();
console.log(iterator.next()); // { value: 0, done: false }
console.log(iterator.next()); // { value: 2, done: false }
console.log(iterator.next()); // { value: 8, done: false }
console.log(iterator.next()); // { value: undefined, done: true }
reduce((a, b) => a + b, f());
// 10
Any value can be used with FxJS if it has a [Symbol.iterator]() method.
const res = go(
[1, 2, 3, 4, 5],
filter(a => a % 2),
reduce(add));
log(res); // 9
You can do 'lazy evaluation' as a function of the L namespace.
const res = go(
L.range(Infinity),
L.filter(a => a % 2),
L.take(3),
reduce(add));
log(res); // 9
Reactive functional programming style.
go(
L.range(Infinity),
L.map(delay(1000)),
L.map(a => a + 10),
L.take(3),
each(log));
// After 1 second 10
// After 2 seconds 11
// After 3 seconds 12
Asynchronous control is easy.
// L.interval = time => L.map(delay(time), L.range(Infinity));
await go(
L.interval(1000),
L.map(a => a + 30),
L.takeUntil(a => a == 33),
each(log));
// After 1 second 30
// After 2 seconds 31
// After 3 seconds 32
// After 4 seconds 33
const res = await go(
L.interval(1000),
L.map(a => a + 20),
L.takeWhile(a => a < 23),
L.map(tap(log)),
reduce(add));
// After 5 seconds 20
// After 6 seconds 21
// After 7 seconds 22
log(res);
// 63
C functions can be evaluated concurrency.
await map(getPage, range(1, 5));
// After 4 seconds
// [page1, page2, page3, page4]
const pages = await C.map(getPage, range(1, 5));
// After 1 second
// [page1, page2, page3, page4]
Like Clojure Reducers, you can handle concurrency.
go(
range(1, 5),
map(getPage),
filter(page => page.line > 50),
map(getWords),
flat,
countBy(identity),
log);
// After 4 seconds
// { html: 78, css: 36, is: 192 ... }
go(
L.range(1, 5),
L.map(getPage),
L.filter(page => page.line > 50),
L.map(getWords),
C.takeAll, // All requests same time.
flat,
countBy(identity),
log);
// After 1 second
// { html: 78, css: 36, is: 192 ... }
go(
L.range(1, 5),
L.map(getPage),
L.filter(page => page.line > 50),
L.map(getWords),
C.takeAll(2), // 2 requests same time.
flat,
countBy(identity),
log);
// After 2 second
// { html: 78, css: 36, is: 192 ... }
You can use JavaScript standard error handling.
const b = go(
0,
a => a + 1,
a => a + 10,
a => a + 100);
console.log(b);
// 111
try {
const b = go(
0,
a => { throw { hi: 'ho' } },
a => a + 10,
a => a + 100);
console.log(b);
} catch (c) {
console.log(c);
}
// { hi: 'ho' }
You can use async/await and try/catch to handle asynchronous error handling.
const b = await go(
0,
a => Promise.resolve(a + 1),
a => a + 10,
a => a + 100);
console.log(b);
// 111
try {
const b = await go(
0,
a => Promise.resolve(a + 1),
a => Promise.reject({ hi: 'ho' }),
a => a + 100);
console.log(b);
} catch (c) {
console.log(c);
}
// { hi: 'ho' }
The above libraries are based on FxJS. FxSQL and FxDOM are libraries that can handle SQL and DOM through functional APIs,respectively. FxContrib is contributors' library for FxJS, FxSQL and FxDOM.
FAQs
Functional Extensions for modern Javascript
The npm package fxjs2 receives a total of 0 weekly downloads. As such, fxjs2 popularity was classified as not popular.
We found that fxjs2 demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 2 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
RubyGems.org has added a new "maintainer" role that allows for publishing new versions of gems. This new permission type is aimed at improving security for gem owners and the service overall.
Security News
Node.js will be enforcing stricter semver-major PR policies a month before major releases to enhance stability and ensure reliable release candidates.
Security News
Research
Socket's threat research team has detected five malicious npm packages targeting Roblox developers, deploying malware to steal credentials and personal data.