FunctionalJS
What
A functional JavaScript library to learn about functional programming.
Why
There are great libraries like Ramda and Folktale, but it's good to understand what's going on under the hood.
How
Using ES6 and Tape for testing.
Features:
Functions
ap :: Functor (a -> b) -> Functor a -> Functor b
apply :: (a... -> b) -> [a...] -> b
chain :: (a -> M b) -> M a -> M b
compose :: (f -> g, ..., a -> b) -> a -> g
curry :: ((a, b, ..., f) => g) => a => b => ... f => g
(up to arity of 6 uses curryN internally, then uses __curry)curryN :: ((a, b, ..., f) => g, n) => a => b => ... f => g
(up to arity of 6 - then uses __curry)either :: (a -> c) -> (b -> c) -> Either a b -> c
equals :: a -> b -> Boolean
every :: (a -> Boolean) -> [a] -> Boolean
flip :: (a, ... b -> c) -> (b..., a -> c)
(up to 6 arity, flipped function curried)handleError :: (e -> c) -> (a -> b) -> a -> (b | c)
identity :: a -> a
keys :: {String: *} -> [String]
liftA2 :: (a -> b -> c) -> Functor a -> Functor b -> Functor c
liftA3 :: (a -> b -> c -> d) -> Functor a -> Functor b -> Functor c -> Functor d
liftA4 :: (a -> b -> c -> d -> e) -> Functor a -> Functor b -> Functor c -> Functor d -> Functor e
liftA5 :: (a -> b -> c -> d -> e -> f) -> Functor a -> Functor b -> Functor c -> Functor d -> Functor e -> Functor f
map :: (a -> b) -> F a -> F b
maybe :: b -> (a -> b) -> Maybe a -> b
once :: (a... -> b) -> (a... -> b)
toPairs :: {String: *} -> [[String, *]]
trampoline :: (*... -> a) -> (*... -> a) - requires recursive call to be wrapped in a thunk trampoline.Thunk(() => [return value])
typeOf :: * -> String
values :: {String: *} -> [*]
zip :: {String: *} -> [[String, *]]
Data
Maybe
Static methods / properties
Maybe.of - a -> Just a
Maybe.Nothing -> Nothing
Instance methods
Maybe::ap - Maybe (a -> b) ~> Maybe a -> Maybe b
Maybe::chain - Maybe a ~> (a -> Maybe b) -> Maybe b
Maybe::equals - Maybe a ~> (Maybe b) -> Boolean
Maybe::isJust - Maybe a ~> () -> Boolean
Maybe::isNothing - Maybe a ~> () -> Boolean
Maybe::map - Maybe a ~> (a -> b) -> Maybe b
Either
Static methods
Either.of - b -> Right b
Either.Left - a -> Left a
Instance methods
Either::ap - Either a (b -> c) ~> Either b -> Either a c
Either::chain - Either a b ~> (b -> Either a c) -> Either a c
Either::map - Either a b ~> (b -> c) -> Either a c
Either::isLeft - Either a b ~> () -> Boolean
Either::isRight - Either a b ~> () -> Boolean
Future
Static methods
Future.of - a -> Future e a
Future.reject - e -> Future e
Instance methods
Future::fork - Future e a ~> (e -> (), a -> ()) -> ()
Future::map - Future e a ~> (a -> b) -> Future e b
Future::chain - Future e a ~> (a -> Future b) -> Future e b
Future::ap - Future e (a -> b) ~> Future e a -> Future e b