m

Point free style, functional library for Javascript with focus on object arrays.

---

• Install
• Use
• "With" pattern
• |> pipe
• Develop
• Contributors
• Changelog

Install

1npm install @asd14/m

Use

1import { pipe, trim, split, dropLast, push, join } from "@asd14/m"
2
3const removeTrailingSlash = source =>
4  source[source.length - 1] === sep ? source.slice(0, -1) : source
5
6const renameFile = newName =>
7  pipe(
8    removeTrailingSlash,
9    split(sep),
10    dropLast,
11    push(trim(sep, newName)),
12    join(sep)
13  )

"With" pattern

Some functions have a *With variant. find has findWith, filter has filterWith etc. They allow for less boilerplate and more intuitive way of handling object arrays.

1import { find, findWith, filterWith, not, is } from "@asd14/m"
2
3const todos = [
4  { id: 1, name: "lorem", tagId: 2 },
5  { id: 2, name: "ipsum", tagId: null },
6  { id: 3, name: "dolor", tagId: null },
7]

1/* Predicate fn */
2find(item => item.id === 1, todos)
3// => {id: 1, name: "lorem", tagId: 2}
4
5/* Matching object */
6findWith(
7  {
8    id: 1,
9  },
10  todos
11)
12// => {id: 1, name: "lorem", tagId: 2}
13
14/* Matching object & predicate fn */
15filterWith(
16  {
17    tagId: is, // same as `tagId: source => is(source)`
18  },
19  todos
20)
21// => [{id: 1, name: "lorem", tagId: 2}]
22
23/* Syntactic sugar */
24filterWith(
25  {
26    "!tagId": is, // same as `tagId: not(is)`
27  },
28  todos
29)
30// => [
31//  {id: 2, name: "ipsum", tagId: null},
32//  {id: 3, name: "dolor", tagId: null}
33// ]

|> pipe

There is no structure difference between pipe and compose, both will use the same building blocks to get from A to B.

A series of transformations over an initial input can be written as x -> f -> g -> result, piping, or as result = g(f(x)), composing. The difference is only syntactic. Input is the same, transformations and order of application are the same, the result will be the same.

Given that:

• we read from left to right
• left/back is in the past, right/front is the future
• a lot of piping going on in your terminal

it makes sense to choose the syntax more aligned with our intuition and context. The transformations are applied in a certain order with time as a medium - input -> t0 -> t1 -> tn -> output.

1const { sep } = require("path")
2const { pipe, compose, join, push, dropLast, split } = require("@asd14/m")
3
4// Compose: g(f(x))
5const renameFile = newName => filePath =>
6  compose(join(sep), push(newName), dropLast, split(sep))(filePath)
7
8// Pipe: x -> f -> g
9const renameFile = newName => filePath =>
10  pipe(split(sep), dropLast, push(newName), join(sep))(filePath)
11
12// More expressive with pipeline operator
13const renameFile = newName => filePath =>
14  filePath |> split(sep) |> dropLast |> push(newName) |> join(sep)

Develop

1git clone git@github.com:asd14-xyz/m.git && \
2  cd m && \
3  npm run setup
4
5# run tests (any `*.test.js`) once
6npm test
7
8# watch `src` folder for changes and run test automatically
9npm run tdd

Contributors

Thank you for contributing your time and knowledge:

• David Gil

Changelog

See the releases section for details.