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

    crocks

    0.12.4 • Public • Published

    Build Status Coverage Status Join the chat at https://gitter.im/crocksjs/crocks NPM version

    crocks is a collection of popular Algebraic Data Types (ADTs) that are all the rage in functional programming. You have heard of things like Maybe and Either and heck maybe even IO, that is what these are. The main goal of crocks is to curate and provide not only a common interface between each type (where possible of course), but also provide all of the helper functions needed to hit the ground running.

    Table of Contents

    Installation

    crocks is available from npm and is just a shell command away. All you need to do is run the following to save it as a dependency in your current project folder:

    $ npm install crocks -S
    

    Usage

    There are many options to use crocks to suit the needs of your, projects. When used on the backend or in an environment where size is not a big concern, the entire lib can be brought in and the various elements can be either be plucked off of or referenced by the namespace.

    For those cases where size matters, like in the case of frontend bundle building, the individual entities can be brought in. This will ensure that your finished bundles include only what is needed for your application/program.

    For using the latter case, refer to the desired function's documentation to find the path in which it resides.

    Entire crocks library (CommonJS)

    // namespace entire suite to crocks variable
    const crocks = require('crocks')
     
    // pluck anything that does not require name-spacing
    const { safe, isNumber } = crocks
     
    // still requires entire object, but removes name-spacing
    const { and, liftA2 } = require('crocks')
     
    // divide :: Number -> Number
    const divide =
      x => y => x / y
     
    // safeNumber :: a -> Maybe Number
    const safeNumber =
      safe(isNumber)
     
    // notZero :: a -> Maybe Number
    const notZero = safe(
      and(isNumber, x => x !== 0)
    )
     
    // safeDivide:: a -> Maybe Number
    const safeDivide = crocks.curry(
      (x, y) => liftA2(divide, safeNumber(x), notZero(y))
    )
     
    safeDivide(20, 0)
    //=> Nothing
     
    safeDivide(20, 5)
    //=> Just 4
     
    safeDivide('number', 5)
    //=> Nothing

    Entire crocks library (JS Modules)

    // namespace entire suite to crocks variable
    import crocks from 'crocks'
     
    // still imports entire object, but removes name-spacing
    import { and, liftA2 }  from 'crocks'
     
    // pluck anything that does not require name-spacing
    const { safe, isNumber } = crocks
     
    // divide :: Number -> Number
    const divide =
      x => y => x / y
     
    // safeNumber :: a -> Maybe Number
    const safeNumber =
      safe(isNumber)
     
    // notZero :: a -> Maybe Number
    const notZero = safe(
      and(isNumber, x => x !== 0)
    )
     
    // safeDivide:: a -> Maybe Number
    const safeDivide = crocks.curry(
      (x, y) => liftA2(divide, safeNumber(x), notZero(y))
    )
     
    safeDivide(20, 0)
    //=> Nothing
     
    safeDivide(20, 5)
    //=> Just 4
     
    safeDivide('number', 5)
    //=> Nothing

    Single entities (CommonJS)

    // require in each entity directly
    const and = require('crocks/logic/and')
    const curry = require('crocks/helpers/curry')
    const isNumber = require('crocks/predicates/isNumber')
    const liftA2 = require('crocks/helpers/liftA2')
    const safe = require('crocks/Maybe/safe')
     
    // divide :: Number -> Number
    const divide =
      x => y => x / y
     
    // safeNumber :: a -> Maybe Number
    const safeNumber =
      safe(isNumber)
     
    // notZero :: a -> Maybe Number
    const notZero = safe(
      and(isNumber, x => x !== 0)
    )
     
    // safeDivide:: a -> Maybe Number
    const safeDivide = curry(
      (x, y) => liftA2(divide, safeNumber(x), notZero(y))
    )
     
    safeDivide(20, 0)
    //=> Nothing
     
    safeDivide(20, 5)
    //=> Just 4
     
    safeDivide('number', 5)
    //=> Nothing

    Single entities (JS Modules)

    // import in each entity directly
    import and from 'crocks/logic/and'
    import curry from 'crocks/helpers/curry'
    import isNumber from 'crocks/predicates/isNumber'
    import liftA2 from 'crocks/helpers/liftA2'
    import safe from 'crocks/Maybe/safe'
     
    // divide :: Number -> Number
    const divide =
      x => y => x / y
     
    // safeNumber :: a -> Maybe Number
    const safeNumber =
      safe(isNumber)
     
    // notZero :: a -> Maybe Number
    const notZero = safe(
      and(isNumber, x => x !== 0)
    )
     
    // safeDivide:: a -> Maybe Number
    const safeDivide = curry(
      (x, y) => liftA2(divide, safeNumber(x), notZero(y))
    )
     
    safeDivide(20, 0)
    //=> Nothing
     
    safeDivide(20, 5)
    //=> Just 4
     
    safeDivide('number', 5)
    //=> Nothing

    Documentation

    What is Included?

    There are (8) classifications of "things" included in this library:

    • Crocks: These are the ADTs that this library is centered around. They are all Functor based Data Types that provide different computational contexts for working in a more declarative, functional flow. For the most part, a majority of the other bits in crocks exist to serve these ADTs.

    • Monoids: These helpful ADTs are in a class of their own, not really Functors in their own right (although some can be), they are still very useful in our everyday programming needs. Ever need to sum a list of numbers or mix a mess of objects together? This is were you will find the ADTs you need to do that.

    • Combinators: A collection of functions that are used for working with other functions. These do things like compose (2) functions together, or flip arguments on a function. They typically either take a function, return a function or a bit a both. These are considered the glue that holds the mighty house of crocks together and a valuable aid in writing reusable code.

    • Helper Functions: All other support functions that are either convenient versions of combinators or not even combinators at all cover this group.

    • Logic Functions: A helpful collection of logic based functions. All of these functions work with either predicate functions or instances of Pred and let you combine them in some very interesting ways.

    • Predicate Functions: A helpful collection of predicate functions to get you started.

    • Point-free Functions: Wanna use these ADTs in a way that you never have to reference the actual data being worked on? Well here is where you will find all of these functions to do that. For every algebra available on both the Crocks and Monoids there is a function here.

    • Transformation Functions: All the functions found here are used to transform from one type to another, naturally. These come are handy in situations where you have functions that return one type (like an Either), but are working in a context of another (say Maybe). You would like to compose these, but in doing so will result in a nesting that you will need to account for for the rest of your flow.

    Contributors

    Thanks goes to these wonderful people (emoji key):

    Ian Hofmann-Hicks
    Ian Hofmann-Hicks

    💻 📖 📹
    Ryan
    Ryan

    💻 🐛 👀
    Andrew Van Slaars
    Andrew Van Slaars

    📖 📹
    Henrique Limas
    Henrique Limas

    💻 📖 👀
    Robert Pearce
    Robert Pearce

    🐛 💻 👀 📖
    Scott McCormack
    Scott McCormack

    🐛
    Fred Daoud
    Fred Daoud

    👀
    Karthik Iyengar
    Karthik Iyengar

    👀 💻 📖
    Jon Whelan
    Jon Whelan

    🐛 💻
    Benny Powers
    Benny Powers

    📖 💻 👀
    Dale Francis
    Dale Francis

    💻 👀
    Premith
    Premith

    📖
    Dipen Bagia
    Dipen Bagia

    💡
    Andrew Jones
    Andrew Jones

    📖
    W. K. Seymour III
    W. K. Seymour III

    📖
    Eliseu Benedito Codinhoto
    Eliseu Benedito Codinhoto

    📖
    NiallArkEnergy
    NiallArkEnergy

    💻 📖
    vidyu
    vidyu

    📖
    Michael Wolfenden
    Michael Wolfenden

    📖
    Johan Codinha
    Johan Codinha

    🐛
    Matt Ross
    Matt Ross

    💻
    Jasmina Jacquelina
    Jasmina Jacquelina

    📖 💻
    Denis Zolkin
    Denis Zolkin

    📖
    Zhentian Wan
    Zhentian Wan

    📖
    RichardForrester
    RichardForrester

    💻 📖 ⚠️
    Furkan Tunalı
    Furkan Tunalı

    📖 💡

    Course/Videos

    Video evilsoft

    Video avanslaars

    Tutorials

    Tutorial rpearce

    Examples

    Example dbagia

    Install

    npm i crocks

    DownloadsWeekly Downloads

    6,261

    Version

    0.12.4

    License

    ISC

    Unpacked Size

    704 kB

    Total Files

    298

    Homepage

    crocks.dev

    Last publish

    Collaborators

    • avatar