@koy/core NPM | npm.io

@koy/core

Functions' and Functors' library.

Why I write this library?

About javascript functional programming, we already have ramda.js、immutable.js、folktale and so on. I write this library is based on my view on javascript functional programming, since one hundred readers have one hundred Hamlett, I write this just for my functional programming style. Of course, If you'd like it, that would be a great happiness for me!

How do I design this library?

As you know, our mostly used data types are Number、String、Boolean、null、undefined、Array and Object. And since es6+ comes on, we may use Symbol、Set、map、ArrayBuffer and so on. So in this library, I just design this based on the first seven data types, and for the second data types, since we use rarely, if you'd like, you can design the function based on this by yourself.

About immutable data, I design not like immutable.js, although that costs less performance, But it designs data types By it's way, not simular to javascript data types, so we used Object.assign and Array.prototype.concat to realize it. I generate a new data based on old data to replace of mutable data.

About Functor, I encourage you use it more and design it based on yourself. Here, i just design four mostly used Functors -- Identity、Maybe、IO and Task.

All Functions

Here are functions that i design in this library.

I divide them into Function、Functor、List、Logic、Math、Object、Relation、String and Type.

Function

__:: functional parameter placeholder
always:: a -> (*... -> a)
applyTo:: a -> (a -> b) -> b
ascend:: Ord b => (a -> b) -> a -> a -> Number
binary:: (*... -> c) -> ((a, b) -> c)
comparator:: ((a, b) -> Boolean) -> ((a, b) -> Number)
compose:: ((y -> z) -> (x -> y) -> ... -> (a -> b)) -> (a -> z)
converge:: (x1, x2, ...) -> a, (x1, x2, ...) -> b, ..., (x1, x2, ...) -> m -> ((a, b, ..., m) -> n) -> ((x1, x2, ...) -> n)
curry:: ((a, b, c, ..., m) -> n) -> ((a, b, c, ..., m) -> n)
descend:: Ord b => (a -> b) -> a -> a -> Number
empty:: a -> a | undefined
flip:: ((a, b, ..., m) -> n) -> ((b, a, ..., m) -> n)
id:: a -> a
invoker:: Number -> String -> ((a, b, ..., m, Object) -> *)
juxt:: (a, b, ..., m) -> n -> ((a, b, ..., m) -> n)
nAry:: Number -> ((a, b, ..., m) -> n) -> ((a, b, ..., m) -> n)
o:: (b -> c) -> (a -> b) -> a -> c
sequence:: ((a, b, ..., m) -> () -> n) -> ((a, b, ..., m) -> n)
tap:: (a -> *) -> a -> a
unary:: (*... -> b) -> (a -> b)

Functor

Identity:: always use for containing a value in a box
IO:: always use for IO(input and output) and side effects
Maybe:: always use for dividing value for two typs(null type and no null type)
Task:: always use for asynchronous task and side effects
ap:: Functor f => f (a -> b) -> f a -> f b
chain:: Functor f => (a -> f b) -> f a -> f b
extract:: Functor f => f a -> a * :: a -> a
fork:: Task T => (a -> c) -> (a -> b) -> T a -> ()
identity:: Identity I => I a -> a
join:: Functor f => f (f a) -> f a
lift:: Functor f => ((a, b, ..., m) -> n) -> ((f a, f b, ..., f m) -> f n)
map:: Functor f => (a -> b) -> f a -> f b
maybe:: Maybe m => b -> (a -> b) -> m a -> b
of:: Functor f => f -> a -> f a
unsafePerformIO:: IO I => I a -> a

List

adjust:: Number -> (a -> a) -> a -> a
all:: (a -> Boolean) -> a -> Boolean
any:: (a -> Boolean) -> a -> Boolean
aperture:: Number -> a -> [a]
append:: a -> a -> a
contains:: a -> a -> Boolean
filter:: (a -> Boolean) -> a -> a
find:: (a -> Boolean) -> a -> a | undefined
findIndex:: (a -> Boolean) -> a -> Number
foldl:: ((a, b) -> a) -> a -> b -> a
foldr:: ((b, a) -> a) -> a -> b -> a
fromPairs:: [k, v] -> {k: v}
indexOf:: a -> a -> Number
insert:: Number -> a -> a -> a
insertAll:: Number -> a -> a -> a
intercalate:: String -> a -> String
none:: (a -> Boolean) -> a -> Boolean
pair:: b -> a -> a, b
prepend:: a -> a -> a
range:: Number -> Number -> Number
reject:: (a -> Boolean) -> a -> a
remove:: Number -> Number -> a -> a
sort:: ((a, a) -> Number) -> a -> a
transpose:: [a] -> [a]
uniq:: a -> a
update:: Number -> a -> a -> a
xprod:: b -> a -> [a, b]
zip:: b -> a -> [a, b]
zipWith:: ((b, a) -> c) -> b -> a -> c

Logic

allPass:: (a, b, ... m) -> Boolean -> ((a, b, ..., m) -> Boolean)
and:: b -> a -> a | b
anyPass:: (a, b, ..., m) -> Boolean -> ((a, b, ..., m) -> Boolean)
both:: ((a, b, ..., m) -> Boolean) -> ((a, b, ..., m) -> Boolean) -> ((a, b, ..., m) -> Boolean)
complement:: ((a, b, ..., m) -> n) -> ((a, b, ..., m) -> Boolean)
either:: ((a, b, ..., m) -> Boolean) -> ((a, b, ..., m) -> Boolean) -> ((a, b, ..., m) -> Boolean)
not:: * -> Boolean
or:: b -> a -> a | b

Math

add:: Number -> Number -> Number
dec:: Number -> Number
divide:: Number -> Number -> Number
inc:: Number -> Number
mean:: Number -> Number
median:: Number -> Number
mod:: Number -> Number -> Number
multiply:: Number -> Number -> Number
negate:: Number -> Number
subtract:: Number -> Number -> Number

Object

assoc:: k -> v -> {k: v} -> {k: v}
assocPath:: k -> v -> {k: v} -> {k: v}
dissoc:: k -> {k: v} -> {k: v}
dissocPath:: k -> {k: v} -> {k: v}
entries:: {k: v} -> [k, v]
has:: k -> {k: v} -> Boolean
keys:: {k: v} -> k
lens:: (s -> a) -> ((a, s) -> s) -> Lens s a * Lens s a = Functor f => (a -> f a) -> s -> f s
lensIndex:: Number -> Lens s a * Lens s a = Functor f => (a -> f a) -> s -> f s
lensPath:: k -> Lens s a * Lens s a = Functor f => (a -> f a) -> s -> f s
lensProp:: k -> Lens s a * Lens s a = Functor f => (a -> f a) -> s -> f s
merge:: {k: v} -> {k: v} -> {k: v}
omit:: k -> {k: v} -> {k: v}
omitBy:: ((v, k) -> Boolean) -> {k: v} -> {k: v}
over:: Lens s a -> (a -> a) -> s -> s * Lens s a = Functor f => (a -> f a) -> s -> f s
path:: k -> {k: v} -> v | undefined
pick:: k -> {k: v} -> {k: v}
pickBy:: ((v, k) -> Boolean) -> {k: v} -> {k: v}
project:: k -> {k: v} -> {k: v}
prop:: k -> {k: v} -> v | undefined
set:: Lens s a -> a -> s -> s * Lens s a = Functor f => (a -> f a) -> s -> f s
toPairs:: {k: v} -> [k, v]
values:: {k: v} -> v
view:: Lens s a -> s -> a * Lens s a = Functor f => (a -> f a) -> s -> f s

Relation

difference:: a -> a -> a
differenceBy:: (a -> String) -> a -> a -> a
equals:: a -> a -> Boolean
equalsBy:: (a -> b) -> a -> a -> Boolean
gt:: Ord a => a -> a -> Boolean
gte:: Ord a => a -> a -> Boolean
intersection:: a -> a -> a
intersectionBy:: (a -> String) -> a -> a -> a
lt:: Ord a => a -> a -> Boolean
lte:: Ord a => a -> a -> Boolean
max:: Ord a => a -> a -> a
maxBy:: Ord b => (a -> b) -> a -> a -> a
min:: Ord a => a -> a -> a
minBy:: Ord b => (a -> b) -> a -> a -> a
union:: a -> a -> a
unionBy:: (a -> String) -> a -> a -> a

String

match:: RegExp | String -> String -> String
replace:: RegExp | String -> String | (($0, $1, ..., index, String) -> String) -> String -> String
split:: String -> String -> String
test:: RegExp -> String -> Boolean
toLower:: String -> String
toString:: * -> String
toUpper:: String -> String
trim:: String -> String