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

    @asd14/m

    6.2.0 • Public • Published

    CircleCI npm version dev-badge Coverage Status

    m

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


    Install

    npm install @asd14/m

    Use

    import { pipe, trim, split, dropLast, push, join } from "@asd14/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)
    )

    "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.

    import { find, findWith, filterWith, not, is } from "@asd14/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.

    const { sep } = require("path")
    const { pipe, compose, join, push, dropLast, split } = require("@asd14/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)

    Develop

    git clone git@github.com:asd14-xyz/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

    Changelog

    See the releases section for details.

    Install

    npm i @asd14/m

    DownloadsWeekly Downloads

    91

    Version

    6.2.0

    License

    MIT

    Unpacked Size

    334 kB

    Total Files

    192

    Last publish

    Collaborators

    • avatar