Point-free Functions

While it can seem natural to work with all these containers in a fluent fashion, it can get cumbersome and hard to get a lot of reuse out of. A way to really get the most out of re-usability in JavaScript is to take what is called a point-free approach. Below is a small code same to contrast the difference between the two calling styles:

Source

Runkit

import map from "crocks/pointfree/map";

import compose from "crocks/helpers/compose";

import isInteger from "crocks/predicates/isInteger";

import safe from "crocks/Maybe/safe";

// isEven :: Integer -> Boolean

const isEven = (x) => x % 2 === 0;

// maybeInt :: a -> Maybe Integer

const maybeInt = safe(isInteger);

// fluentIsEven :: a -> Maybe Boolean

const fluentIsEven = (data) => maybeInt(data).map(isEven);

// pointfreeIsEven :: a -> Maybe Boolean

const pointfreeIsEven = compose(map(isEven), maybeInt);

fluentIsEven(5);

//=> Just false

fluentIsEven("number");

//=> Nothing

fluentIsEven(6);

//=> Just true

pointfreeIsEven(5);

//=> Just false

pointfreeIsEven("not even");

//=> Nothing

pointfreeIsEven(6);

//=> Just true

These functions provide a very clean way to build out very simple functions and compose them all together to compose a more complicated flow. Each point-free function provided in crocks is "auto-curried" and follows a "data-last" pattern in the order of how it receives it's arguments. Typically the most stable of the arguments comes first, moving all the way to the least stable argument (which usually is the data flowing through your composition). Below lists the provided functions and the data types they work with (m refers to an accepted Datatype):

Signatures

Function	Signature	Location
alt	m a -> m a -> m a	crocks/pointfree
ap	m a -> m (a -> b) -> m b	crocks/pointfree
bichain	(a -> m c d) -> (b -> m c d) -> m a b -> m c d	crocks/pointfree
bimap	(a -> c) -> (b -> d) -> m a b -> m c d	crocks/pointfree
both	m (a -> b) -> m (Pair a a -> Pair b b)	crocks/pointfree
chain	(a -> m b) -> m a -> m b	crocks/pointfree
coalesce	(a -> c) -> (b -> c) -> m a b -> m _ c	crocks/pointfree
compareWith	a -> a -> m a -> b	crocks/pointfree
concat	m a -> m a -> m a	crocks/pointfree
cons	a -> m a -> m a	crocks/pointfree
contramap	(b -> a) -> m a -> m b	crocks/pointfree
either	(a -> c) -> (b -> c) -> m a b -> c	crocks/pointfree
empty	m -> m	crocks/pointfree
equals	m -> m -> Boolean	crocks/pointfree
evalWith	s -> m -> a	crocks/State
execWith	s -> m -> s	crocks/State
extend	(m a -> b) -> m a -> m b	crocks/pointfree
filter	((a -> Boolean) | Pred a) -> m a -> m a	crocks/pointfree
first	m (a -> b) -> m (Pair a c -> Pair b c)	crocks/pointfree
fold	Semigroup s => m s -> s	crocks/pointfree
foldMap	Semigroup s => (a -> s) -> m a -> s	crocks/pointfree
fst	m a b -> a	crocks/Pair
head	m a -> Maybe a	crocks/pointfree
init	m a -> Maybe (m a)	crocks/pointfree
last	m a -> Maybe a	crocks/pointfree
log	m a b -> a	crocks/Writer
map	(a -> b) -> m a -> m b	crocks/pointfree
merge	(a -> b -> c) -> m a b -> c	crocks/pointfree
nmap	Integer -> ...(* -> *) m ...* -> m ...*	crocks/Tuple
option	a -> m a -> a	crocks/pointfree
project	Integer -> m ...* -> a	crocks/Tuple
promap	(c -> a) -> (b -> d) -> m a b -> m c d	crocks/pointfree
race	m e a -> m e a -> m e a	crocks/Async
read	m a b -> Pair a b	crocks/Writer
reduce	(b -> a -> b) -> b -> m a -> b	crocks/pointfree
reduceRight	(b -> a -> b) -> b -> m a -> b	crocks/pointfree
reject	((a -> Boolean) | Pred a) -> m a -> m a	crocks/pointfree
run	m a -> b	crocks/pointfree
runWith	a -> m -> b	crocks/pointfree
second	m (a -> b) -> m (Pair c a -> Pair c b)	crocks/pointfree
sequence	Applicative TypeRep t, Apply f => (t | (b -> f b)) -> m (f a) -> f (m a)	crocks/pointfree
snd	m a b -> b	crocks/Pair
swap	(c -> d) -> (a -> b) -> m c a -> m b d	crocks/pointfree
tail	m a -> Maybe (m a)	crocks/pointfree
traverse	Applicative TypeRep t, Apply f => (t | (c -> f c)) -> (a -> f b) -> m (f a) -> f (m b)	crocks/pointfree
valueOf	m a -> a	crocks/pointfree

Datatypes

Function	Datatypes
alt	Async, Either, Maybe, Result
ap	Array, Async, Const, Either, Identity, IO, List, Maybe, Pair, Reader, Result, State, Unit, Writer
bichain	Async, Either, Maybe, Result
bimap	Async, Either, Pair, Result
both	Arrow, Function, Star
chain	Array, Async, Const, Either, Identity, IO, List, Maybe, Pair, Reader, Result, State, Unit, Writer
coalesce	Async, Either, Maybe, Result
compareWith	Equiv
concat	All, Any, Array, Assign, Const, Either, Endo, Equiv, First, Identity, Last, List, Max, Maybe, Min, Pair, Pred, Prod, Result, String, Sum, Tuple, Unit
cons	Array, List
contramap	Arrow, Equiv, Pred, Star
either	Either, Maybe, Result
empty	All, Any, Array, Assign, Endo, Equiv, First, Last, List, Max, Min, Object, Pred, Prod, String, Sum, Unit
equals	All, Any, Array, Assign, Boolean, Const, Either, First, Last, List, Max, Maybe, Min, Number, Object, Pair, Prod, Result, String, Sum, Tuple, Unit, Writer
evalWith	State
execWith	State
extend	Pair
filter	Array, List, Object
first	Arrow, Function, Star
fold	Array, List
foldMap	Array, List
fst	Pair
head	Array, List, String
init	Array, List, String
last	Array, List, String
log	Writer
map	Async, Array, Arrow, Const, Either, Function, Identity, IO, List, Maybe, Object, Pair, Reader, Result, Star, State, Tuple, Unit, Writer
merge	Pair, Tuple
option	First, Last, Maybe
promap	Arrow, Star
race	Async
read	Writer
reduce	Array, List
reduceRight	Array, List
reject	Array, List, Object
run	IO
runWith	Arrow, Endo, Pred, Reader, Star, State
second	Arrow, Function, Star
sequence	Array, Either, Identity, List, Maybe, Pair, Result
snd	Pair
swap	Async, Either, Pair, Result
tail	Array, List, String
traverse	Array, Either, Identity, List, Maybe, Pair, Result
valueOf	All, Any, Assign, Const, Endo, Equiv, First, Identity, Last, Max, Min, Pred, Prod, Sum, Unit, Writer