Nitrogenous Polymorphic Molecule
Have ideas to improve npm?Join in the discussion! »

@mutant-ws/m

2.9.0 • Public • Published

CircleCI npm version dev-badge Coverage Status

m

Point free style, functional library for Javascript

Experimental. Use Ramda.


"With" pattern

Most array 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.

import { find, findWith, filterWith, not, is } from "@mutant-ws/m"
 
const todos = [
  {id: 1, name: "lorem", tagId: 2,},
  {id: 2, name: "ipsum", tagId: null},
  {id: 3, name: "dolor", tagId: null},
]
/* Predicate fn */
find(
  item => item.id === 1
)(todos)
// => {id: 1, name: "lorem", tagId: 2}
 
/* Matching object */
findWith({
  "id": 1
})(todos)
// => {id: 1, name: "lorem", tagId: 2}
 
/* Matching object & predicate fn */
filterWith({
  "tagId": is // same as `tagId: source => is(source)`
})(todos)
// => [{id: 1, name: "lorem", tagId: 2}]
 
/* Syntactic sugar */
filterWith({
  "!tagId": is // same as `tagId: not(is)`
})(todos)
// => [
//  {id: 2, name: "ipsum", tagId: null},
//  {id: 3, name: "dolor", tagId: null}
// ]

|> 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:

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. The way is forward :godmode:.

const { sep } = require("path")
const { pipe, compose, join, push, dropLast, split } = require("@mutant-ws/m")
 
// Compose: g(f(x))
const renameFile = newName => filePath =>
  compose(
    join(sep), push(newName), dropLast, split(sep)
  )(filePath)
 
// Pipe: x -> f -> g
const renameFile = newName => filePath =>
  pipe(
    split(sep), dropLast, push(newName), join(sep)
  )(filePath)
 
// More expressive with pipeline operator
const renameFile = newName => filePath =>
  filePath |> split(sep) |> dropLast |> push(newName) |> join(sep)

Install

npm install @mutant-ws/m

Develop

git clone git@github.com:mutant-ws/m.git && \
  cd m && \
  npm run setup
 
# run tests (any `*.test.js`) once 
npm test
 
# watch `src` folder for changes and run test automatically 
npm run tdd

Use

import { pipe, trim, split, dropLast, push, join } from "@mutant-ws/m"
 
const removeTrailingSlash = source =>
  source[source.length - 1] === sep ? source.slice(0, -1) : source
 
const renameFile = newName => pipe(
  removeTrailingSlash,
  split(sep),
  dropLast,
  push(trim(sep)(newName)),
  join(sep)
)

Changelog

See the releases section for details.

Install

npm i @mutant-ws/m

DownloadsWeekly Downloads

1

Version

2.9.0

License

BSD-3-Clause

Unpacked Size

2.13 MB

Total Files

365

Last publish

Collaborators

  • avatar