@avalander/fun

    1.0.0-beta.4 • Public • Published

    This is a collection of functional primitives that I reuse across projects.

    Either

    import { Left, Right, tryCatch, conditional } from '@avalander/func/src/either'

    Either constructors

    Left :: a -> Left a

    It returns an instance of Left wrapping the given value.

    Right :: a -> Right a

    It returns an instance of Right wrapping the given value.

    tryCatch :: (...args -> a) throws fn => (fn, ...args) -> Either a

    tryCatch receives a function that may throw an exception and a list of arguments. It will apply the arguments to the function and return a Left if the function throws or a Right wrapping the result otherwise.

    const noOddsPlz = x => {
        if (% 2 === 0) return x
        throw new Error('It was odd')
    }
     
    tryCatch(noOddsPlz, 4) // -> Right(4)
    tryCatch(noOddsPlz, 3) // -> Left(Error(It was odd))

    conditional :: ((a -> bool), string?) -> a -> Either a

    conditional recieves a predicate function that takes a value and returns a boolean, and an optional string as a reason and returns a function that will take a value, apply the predicate function and return an instance of Right if the predicate returns true or an instance of Left with the reason if the predicate returns false.

    const isOdd = conditional(x => x % 2 != 0, 'It is even')
    isOdd(3) // -> Right(3)
    isOdd(4) // -> Left(It is even)

    Either methods

    map :: (a -> b) -> Either b

    It receives a function that will be applied to the wrapped value of a Right instance and returned wrapped in a new instance of Right or ignored in an instance of Left.

    Right(3).map(x => x * 2) // -> Right(6)
    Left(3).map(x => x * 2) // -> Left(3)

    chain :: (a -> Either b) -> Either b

    It receives a function that takes the wrapped value and returns a new instance of Either.

    An instance of Right will apply the function and return the result. An instance of Left will ignore the function and return the same instance.

    Right(3).map(x => Right(* 2)) // -> Right(6)
    Right(3).map(x => Left(- 1)) // -> Left(2)
    Left(3).map(x => Right(* 2)) // -> Left(3)

    fold :: ((a -> c), (b -> c)) -> c

    It receives a left function that will be applied to the wrapped value of a Left instance and a right function that will be applied to the wrapped value of a Right instance. In both cases, the result of the function will be returned.

    Right(3).fold(
        l => l
        r => r * 2
    ) // -> 6
    Left(3).fold(
        l => l
        r => r * 2
    ) // -> 3

    Maybe

    import { Just, Nothing, fromNullable, fromList } from '@avalander/func/src/maybe'

    Maybe constructors

    Just :: a -> Just a

    Returns an instance of Just wrapping a value.

    Nothing :: () -> Nothing

    Returns an instance of Nothing.

    fromNullable :: a -> Maybe a

    Returns an instance of Nothing if the given value is null or undefined and an instance of Just wrapping the value otherwise.

    fromNullable(null) // -> Nothing
    fromNullable('potato') // -> Just(potato)

    fromList :: [a] -> Maybe a

    Receives an array-like object. Returns an instance of Nothing if the object is empty and an instance of Just wrapping the object otherwise.

    fromList([]) // -> Nothing
    fromList([1, 2, 3]) // -> Just([1, 2, 3])

    Maybe methods

    map :: (a -> b) -> Maybe b

    Applies the function to the wrapped value of a Just and returns the result wrapped in a new Just, or returns Nothing.

    Just(3).map(x => x * 2) // -> Just(6)
    Nothing().map(x => x * 2) // -> Nothing

    chain :: (a -> Maybe b) -> Maybe b

    Applies the function to the wrapped value of a Just and returns the result or returns Nothing.

    It expects the result to be an instance of Maybe.

    Just(3).chain(x => Just(* 2)) // -> Just(6)
    Just(3).chain(x => Nothing()) // -> Nothing
    Just(3).chain(x => x * 2) // -> 'Error: fn in Maybe.chain(fn) must return an instance of either Just or Nothing.'
    Nothing().chain(x => Just(* 2)) // -> Nothing

    fold :: ((() -> b), (a -> b)) -> b

    Applies the left function if it is an instance of Nothing or the right function if it is an instance of Just to the wrapped value and returns the result.

    Just(3).fold(
        () => -1,
        x => x * 2
    ) // -> 6
    Nothing.fold(
        () => -1,
        x => x * 2
    ) // -> -1

    Keywords

    none

    Install

    npm i @avalander/fun

    DownloadsWeekly Downloads

    11

    Version

    1.0.0-beta.4

    License

    MIT

    Unpacked Size

    10.8 kB

    Total Files

    15

    Last publish

    Collaborators

    • avalander