npm package discovery and stats viewer.

Discover Tips

  • General search

    [free text search, go nuts!]

  • Package details

    pkg:[package-name]

  • User packages

    @[username]

Sponsor

Optimize Toolset

I’ve always been into building performant and accessible sites, but lately I’ve been taking it extremely seriously. So much so that I’ve been building a tool to help me optimize and monitor the sites that I build to make sure that I’m making an attempt to offer the best experience to those who visit them. If you’re into performant, accessible and SEO friendly sites, you might like it too! You can check it out at Optimize Toolset.

About

Hi, 👋, I’m Ryan Hefner  and I built this site for me, and you! The goal of this site was to provide an easy way for me to check the stats on my npm packages, both for prioritizing issues and updates, and to give me a little kick in the pants to keep up on stuff.

As I was building it, I realized that I was actually using the tool to build the tool, and figured I might as well put this out there and hopefully others will find it to be a fast and useful way to search and browse npm packages as I have.

If you’re interested in other things I’m working on, follow me on Twitter or check out the open source projects I’ve been publishing on GitHub.

I am also working on a Twitter bot for this site to tweet the most popular, newest, random packages from npm. Please follow that account now and it will start sending out packages soon–ish.

Open Software & Tools

This site wouldn’t be possible without the immense generosity and tireless efforts from the people who make contributions to the world and share their work via open source initiatives. Thank you 🙏

© 2024 – Pkg Stats / Ryan Hefner

enjoy-core

v1.2.0

Published

The core of enjoy.js, a functional JavaScript library

Downloads

32

Readme

enjoy-core

Minimal version of the enjoy.js library. Contains probably all of the stuff to meet your daily functional programming needs. Treats arrays and objects in the same way whenever possible. Shuns the dreaded this. Makes composition and partial application as easy as it gets. And yes, it also has object-less versions of commonly used methods and turns most operators into functions.

Installation

npm install --save enjoy-core

Fun with functions

apply(fn, args)

Calls fn using the values of args as arguments. No this.

auto(fn)

Wraps fn so that if it gets called with only one argument and that argument is a function, a partial application of fn is returned instead of calling fn.

bind(fn, arg1, ..., argN)

Binds any number of arguments to fn. No this.

call(fn, arg1, ..., argN)

Calls fn using the other arguments supplied to call.

compose(fn1, ..., fnN)

Composes all of the supplied functions so that if you call the resulting function with a value it does the same thing as pipe.

flip(fn)

Reverses fn's order of arguments.

free(method)

Frees a method from the shackles of object-orientation by making it a free function where the first argument is an object compatible with the method's original object.

partial(fn, arg1, ..., argN)

Binds all of the other non-undefined arguments to fn:

var forEachInCollection = partial(each, undefined, myCollection);

pipe(value, fn1, ..., fnN) [auto(2)]

Calls fn1 with value, then fn2 with the resulting value, then does the same for all of the supplied functions and returns the result.

pipe([3, 1, 2], sort, reverse); // [3, 2, 1]

Repeating stuff

loop(fn)

Calls fn again and again until it returns false.

repeat(fn, n) [auto]

Calls fn n times. If called with only fn, a partial application is returned.

Working with collections (arrays, array-likes, objects)

at(collection, key) [auto]

Retrieves the value at key from a collection.

contains(collection, item) [auto]

Checks whether item is contained in collection.

each(fn, collection) [auto]

Calls fn with each item in collection. The fn callback has this signature:

fn(item, key, collection)

expose(collection, key) [auto]

Turns an array of objects into an object where the keys are the values of a property of the objects contained within the original array.

Example:

[{name: "foo"},{name: "bar"}] => {foo: {name: "foo"}, bar: {name: "bar"}}

every(fn, collection) [auto]

Returns true if fn returns a truthy value for each item in collection. The execution is cut short when fn returns a falsy value for an item in the collection.

filter(fn, collection) [auto]

Returns an array containing only those items from collection that pass the test function fn.

find(fn, collection) [auto]

Returns the first item in collection that passes the test function fn.

getter(collection)

Creates a getter function that returns an item from collection given its key.

has(collection, key) [auto]

Checks if collection contains an item for key key.

join(collection[, glue]) [auto]

Creates a string containing every item in collection, separated by glue. If no glue is supplied, an empty string is used.

keys(collection)

Returns an array containing collection's keys.

map(fn, collection) [auto]

Returns an array where every item from collection has been modified using fn.

picker(key)

Creates a function that returns the item at key from a given collection.

any -> (collection -> any)

pluck(collection, key) [auto]

Returns an array containing all the items at key for every collection in collection.

collection -> string -> [any]
pluck([["foo", "bar"], [1, 2]], 1); // ["bar", 2]
pluck([{"foo": "bar"}, {"foo": "baz"}], "foo"); // ["bar", "baz"]

privatize(collection, key) [auto]

Turns an object into an array by putting its keys into the objects contained within the array.

Example:

{foo: {}, bar: {}} => [{name: "foo"},{name: "bar"}]

put(collection, key, value) [auto]

Sets collection's value of key to value or adds it if the key doesn't exist yet.

putter(key)

Creates a function that sets the value at key for a given collection and value:

any -> (collection -> any -> undefined)

reduce(fn, collection[, initialValue]) [auto]

Reduces collection to a single value using the fn function. Function fn has this signature:

fn(previousValue, currentValue, key, collection);

If no initial value is supplied, fn gets first called for the second item in the collection and the previous value is the value of the first item as-is.

some(fn, collection) [auto]

Returns true if at least one item in collection satisfies the testing function fn. Execution is cut short at the first item for which fn returns a truthy value.

setter(collection)

Creates a setter function for a collection that sets the value at some key or adds it. The returned function has this signature:

fn(key, value);

values(collection)

Returns an array containing all of collection's items.

Working with ordered collections (arrays, array-likes)

reverse(collection)

Reverses the order of items in the collection. Does not mutate the original like Array.prototype.reverse!

sort(collection[, fn])

Sorts collection using fn or, if no fn is supplied, the built-in sort function of Array.prototype.sort. Does not mutate the original!

String functions

split(s, separator)

Splits s into an array at each occurrence of separator.

Functionalized operators and statements

add(n1, ..., nLast) [auto(2)]

Adds all of its arguments together.

divide(n1, ..., nLast) [auto(2)]

Divides any number of arguments from left to right.

fallback(fn, instead) [auto]

A functional try-catch: If fn throws, execute instead.

mod(n1, ..., nLast) [auto(2)]

Reduces the arguments by applying the modulo ("%") operator to each and the next.

multiply(n1, ..., nLast) [auto(2)]

Multiplies its arguments.

not(a)

Applies the not operator ("!") to a.

subtract(n1, ..., nLast) [auto(2)]

Subtracts one or more numbers from n1.