white_cats

White Cats define Pure functions

!Node.js CI

Usage:

$3

``shell
npm i white_cats
`
and...

`javascript
const _ = require('white_cats');
`

$3


`html

`

contents:

$3

`javascript
_.id(57)
// 57
`

$3

is function pipe runner

`javascript
_.pipe(
v => v * 2,
v => v + 5,
v => v * 10
)(5)
// 150
`


$3

watch out on argument's first

`javascript
_.loop(
a => a.forEach(v => v),
a => a.forEach(v => v)
)(
[3, 5, 7]
)
// [3, 5, 7]
`

$3

is Object.create

`javascript
(() => {
const target = _.upto(Object.freeze({a: true, b: false}), {c: {value: false}});
target.c === false
})()
`

$3

is Object.assign

`javascript
() => {
const target = {a: 5, b: 3};
_.put(target, {c: 1, d: 2});
target.c === 1;
target.d === 2;
}
`

$3

is Object.defineProperty

`javascript
() => {
const target = {a: 5, b: 3};
_.defines(target, 'c', {value: 1});
target.c === 1;
}
`

$3

is Object.defineProperties

`javascript
() => {
const target = {a: 5, b: 3};
_.defines(target, {c: {value: 1}, d: {value: 2}});
target.c === 1;
target.d === 2;
}
`

$3

is Object.keys

`javascript
_.keys({a: 5, b: 6})
// ['a', 'b']
`

$3

is Object.values

`javascript
_.vals({a: 5, b: 6})
// [5, 6]
`

$3

is Object.entries

`javascript
_.entries({a: 5, b: 6})
// [['a', 5], ['b', 6]]
`

$3

is Object.is

`javascript
(() => {
_.equal('foo', 'foo'); // true
_.equal('foo', 'bar'); // false
_.equal([], []); // false

const foo = { a: 1 };
const bar = { a: 1 };
_.equal(foo, foo); // true
_.equal(foo, bar); // false

_.equal(null, null); // true

_.equal(0, -0); // false
_.equal(-0, -0); // true
_.equal(NaN, 0/0); // true
})()
`

$3

_.owns(target)

`javascript
// same of
Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target))
`

$3

is Object.getOwnPropertyDescriptors

`javascript
_.descripting({
a: 5,
b: 6
})
`

$3

assign arguments value in empty to left

`javascript
_.adapt(1, 2, 5)([,,3,4,,6])
// [1, 2, 3, 4, 5, 6]
`

$3

assign arguments value in empty to left

`javascript
_.adaptL(1, 2, 5)([,,3,4,,6])
// [1, 2, 3, 4, 5, 6]
`

$3

assign arguments value in empty to Right

`javascript
_.adaptR(1, 2, 5)([,,3,4,,6])
// [5, 2, 3, 4, 1, 6]
`

$3


omit voidly value
`javascript
_.less([,,null ,undefined ,3 ,4 ,5,,])
// [3, 4, 5]
`

$3

change empty to undefined

`javascript
_.sure([ , , ,0 , 3, 4, 5])
// [undefined, undefined, undefined, 0, 3, 4, 5]
`

$3

get's constructor

`javascript
_.by([])
// Array
`

$3

`javascript
// true
_.isObject({});
_.isObject([]);

// false
_.isObject(8);
`

$3

`javascript
// true
_.isArray([])

// false
_.isArray({})
`

$3

`javascript
[..._._(0, 8, 2)]
// [0, 2, 4, 6, 8]

[..._._(8, 0, -2)]
// [8, 6, 4, 2, 0]

[..._._(5)]
// [0, 1, 2, 3, 4, 5]
`

$3

create loop infinite iterator

`javascript
const r = _.spin([1, 2, 3]);
r.now // 1
r.now // 2
r.again // 2
r.now // 3
r.now // 1
`

$3

create Promise

`javascript
async () => await _.async(
r => setTimeout(t => r('done'), 3000)
)();
// 3sec after return 'done'
`

$3

is Promise.all

`javascript
async () => await _.asyncAll(
_.async(r => r(3)),
_.async(r => r(4)),
_.async(
r => setTimeout(t => r('done'), 3000)
)
)
// 3sec after return [3, 4, 5]
`

$3

return right first

`javascript
_(3).$_
// 3

_(3, 4).$_
// 4
`

$3

return left first

`javascript
_(3)._$
// 3

_(3, 4)._$
// 3

_(null, 4)._$
// 4
`

$3

swap starting and ending value

`javascript
_(3, 4).re
// it same at _(4, 3)
`

$3

has Kleisli Triple and function piping

`javascript
// left Identity
_({a: 5})
.flat(o => _({a: o.a * 3}))
._
(o => _({a: o.a * 3}))({a: 5})._

// Right Identity
_({a: 5})
.flat(_)
.flat(_)
._
// {a: 5}

// Associativity
_({a: 5})
.flat(o => _({a: o.a * 3}))
.flat(o => _({a: o.a + 5}))
._
_({a: 5})
.flat(
o => _({a: o.a * 3})
.flat(
o => _({a: o.a + 5})
)
)._
`

$3

function's pipeline runner

`javascript
_({a: 5})
.pipe(
o => ({a: o.a * 3}),
o => ({a: o.a + 5})
)
._.a
// 20
`

$3

is watch out on argument's first

`javascript
_([3, 4, 5])
.loop(
o => o.unshift(2, 3),
o => o.push(2, 3),
o => o.filter(v => v < 3)
)
._
// [2, 3. 3, 4, 5, 2, 3]
`

$3

is Object's method caller in call(self) and return result

`javascript
_([3, 4, 5]).call('push')(5, 6)._
// 5
`

$3

is Object's method caller in call(self) and callback recieve result and return self

`javascript
_([3, 4, 5]).s_r('push')(5, 6)(v => v === 5)._
// [3, 4, 5, 5, 6]
`


$3

is Object's method caller in call(self) and return self

`javascript
_([3, 4, 5]).call('push')(5, 6)._
// [3, 4, 5, 5, 6]
`

$3

is Chaining method calling in the way to take a Object

`javascript
_([3, 5, 7])
.Been
0((v, w) => w) // rewrite
1() // nothing to do
2((v, w) => v + w) // modify
.push(5, 6)(console.log) // 5
.push(4, 3)(console.log) // 7
.To
._
// [7, 5, 12, 5, 6, 4, 3]
`


$3

is Chaining method calling in the way to take a Object

`javascript
_([3, 5, 7])
.As
0 // refer
1 //
2 //
.push(5, 6) // 5
.push(4, 3) // 7
.As
._
// [3, 5, 7, 5, 6, 4, 3]
`

$3

is JSON.stringify

`javascript
_({a: 5, b: 6}).toJSON._ === JSON.stringify({a: 5, b: 6})
`

$3

is take generator's valuelist

`javascript
_((function* (x) {
while (true) {
yield x++;
}
})(0))
.take(5)
._
//[0, 1, 2, 3, 4]
`

$3

is Object.filter

`javascript
_({a: 5, b: 4, c: 3, d: 2, e : 1})
.filter(v => v < 4)
._
// {c: 3, d: 2, e : 1}
`

$3

is Object.entries.forEach

`javascript
_({
req: undefined,
res: undefined,
get (req, res) {
_.put(this, {req, res});
},
post (req, res) {
_.put(this, {res});
}
})
.each(
(k, v) => emitter.on(k, v)
)
`

$3

is Object.map

`javascript
_({a: 5, b: 4, c: 6}).map((v, k) => k + v)._
// {a: 'a5', b: 'b4', c: 'c6'}
`

$3

is getter about Object

`javascript
_({a: 3, b: {c: 4, d: {e: 6}}}).get('b.d.e')._
// 6

_({a: 3, b: {c: 4, d: {e: 6}}}).get('b.e.f')._
// undefined
`

$3

is setter about Object

`javascript
_({a: 3, b: {c: 4, d: {e: 6}}}).set('b.d.e')(3)._
// {a: 3, b: {c: 4, d: {e: 3}}}

_({a: 3, b: {c: 4, d: {e: 6}}}).set('b.c.f')(3)._
// {a: 3, b: {c: {f: 3}, d: {e: 6}}}
`

$3

is Object.assign

`javascript
_({a: 3, b: {c: 4, d: {e: 6}}}).get('b.d').put({f: 7}).$_
// {a: 3, b: {c: 4, d: {e: 6, f: 7}}}
`

$3

is delete property

`javascript
_({a: 3, b: {c: 4, d: {e: 6}}}).cut('b.d')._
// {a: 3, b: {c: 4}}

_({a: 3, b: {c: 4, d: {e: 6}}}).cut('b.e')._
// {a: 3, b: {c: 4, d: {e: 6}}}
`

$3

property referer callback

`javascript
_({a: 3, b: {c: 4, d: {e: 6}}})
.refer('b.d.e')(console.log)
._ // 6
// {a: 3, b: {c: 4, d: {e: 6}}}
`

$3

is refer property and get's more argument

`javascript
_({a: 3, b: {c: 4, d: {e: 6}}})
.gaze('b.d.e')(4, 5, 6)(console.log)
._
// {a: 3, b: {c: 4, d: {e: 6}}}
`

$3

is property modifier

`javascript
_({a: 3, b: {c: 4, d: {e: 6}}}).mend('b.d.e')(v => v * 3)._
// {a: 3, b: {c: 4, d: {e: 18}}}
`

$3

is modify property and get's more argument

`javascript
_({a: 3, b: {c: 4, d: {e: 6}}})
.modify('b.d.e')(4, 5, 6)(
(v, w, x, y) => (v - w) * x + y
)
._
// {a: 3, b: {c: 4, d: {e: 16}}}
`

$3

is deepAssigning Object more safely about Object.assign

!!!Carefuly!!!
give is take of the first argument Object
normaly use _({}).take

`javascript
_({a: 3, b: {c: 4, d: {e: 6}}})
.give(
{a: 4, b: {d: {f: 8}, g: {h: 9, i: 10}}},
{b: {d: {g: {j: 11, k: {l: 12}}}}},
{b: {g: {j: 13, k: {l: 14}}}}
)
._

/*
{
b : {
g : { j : 13, k : { l : 14 }, h : 9, i : 10 },
d : { g : { j : 11, k : { l : 12 } }, f : 8, e : 6 },
c : 4
}, a : 3
}
*/
`

$3

is deepAssigning Object more safely about Object.assign

`javascript
_({a: 3, b: {c: 4, d: {e: 6}}})
.take(
{a: 4, b: {d: {f: 8}, g: {h: 9, i: 10}}},
{b: {d: {g: {j: 11, k: {l: 12}}}}},
{b: {g: {j: 13, k: {l: 14}}}}
)
._

/*
{
a: 4, b: {
c: 4, d: {
e: 6, f: 8, g: {
j: 11, k: {l: 12}
}
},
g: {
h: 9, i: 10, j: 13, k: {l: 14}
}
}
}
*/
`

$3

is Object.defineProperties applying

`javascript
(() => {
const target = {a: 5, b: 3};
_(target).define({c: {value: 1}, d: {value: 2}})._;
// target like {a: 5, b: 3, c: 1, d: 2}
})
`

$3

is promoting prototype that Object.create

`javascript
_(Object.prototype).append({c: {value: false}})._;
// {c: false}
`

$3

is depending prototype that Object.create

`javascript
_({c: {value: false}}).depend(Object.prototype)._;
// {c: false}
`

$3

Object's deepPicker that distinate Query String

`javascript
_({
a: 4, b: {
c: 4, d: {
e: 6, f: 8, g: {
j: 11, k: {l: 12}
}
},
g: {
h: 9, i: 10, j: 13, k: {l: 14}
}
}
})
.pick('a, b[c, d[e, g.k], g[j, k]]') // parse to 'a, b.c, b.d.e, b.d.g.k, g.j, g.k'
._

/*
{
a: 4, b: {
c: 4, d: {
e: 6, g: {
k: {l: 12}
}
},
g: {
j: 13, k: {l: 14}
}
}
}
*/
`

$3

Object's deepDropper that distinate Query String

`javascript
_({
a: 4, b: {
c: 4, d: {
e: 6, f: 8, g: {
j: 11, k: {l: 12}
}
},
g: {
h: 9, i: 10, j: 13, k: {l: 14}
}
}
})
.drop('a, b[c, d[e, g.k], g[j, k]]') // parse to 'a, b.c, b.d.e, b.d.g.k, g.j, g.k'
._

/*
{
b: {
d: {
f: 8, g: {
j: 11
}
},
g: {
h: 9, i: 10,
}
}
}
*/
`

$3

get's Object.keys

`javascript
_({a: 5, b: 6}).keys._
// ['a', 'b']
`

$3

get's Object.values

`javascript
_({a: 5, b: 6}).vals._
// [5, 6]
`

$3

get's Object.entries

`javascript
_({a: 5, b: 6}).entries._
// [['a', 5], ['b', 6]]
`

$3

process from Date structure to Date Object

`javascript
_({
yr: 2020,
mo: 1,
dt: 1,
hr: 0,
min: 0,
sec: 0,
ms: 0
}).toDate._

//Data: 2020-1-1 that have Local TimeZone
`

$3

process from DateUTC structure to Date Object

`javascript
_({
yrUTC: 2020,
moUTC: 1,
dtUTC: 1,
hrUTC: 0,
minUTC: 0,
secUTC: 0,
}).toDateUTC._

//Data: 2020-1-1 that have UTC GMT
`

$3

constructor function's inheritance Other One's

`javascript
const MyEmitter = _(function (a, b) {
events.EventEmitter.call(this)
this.a = a;
this.b = b;
})
.delegate(events.EventEmitter)
._

const MyImage = _(function (src, alt) {
Image.call(this)
this.src = src;
this.alt = alt;
})
.delegate(Image)
._
`

$3

assign methods in this constructor

`javascript
const MyCtor = _(function (a, b) {
this.a = a;
this.b = b;
})
.prepends({
ad (x) {
this.a += x;
this.b += x;
return this;
},
mt (x) {
this.a *= x;
this.b *= x;
return this;
},
get result () {
return a + b;
}
})
._
`

$3

define methods in this constructor

`javascript
const MyCtor = _(function (a, b) {
this['@a'] = a;
this['@b'] = b;
})
.implements({
a: {
configurable: true,
get () {
return this['@a'];
}
},
b: {
configurable: true,
get () {
return this['@b'];
}
},
ad: {
configurable: true,
value (x) {
return new MyCtor(this.a + x, this.b + x);
}
},
mt: {
configurable: true,
value (x) {
return new MyCtor(this.a x, this.b x);
}
},
result: {
configurable: true,
get () {
return this.a + this.b;
}
}
})
._
`

$3

is partial applying and
what cut to overflow args and run once it

.of means args.push
.to means args.unshift


`javascript
_((...a) => a.reduce((p, c) => p + c))
.take([,,3,,,])
.to(1, 2)
.of(4, 5)
.to(3, 4)
.of(2, 3)
._
// 15
`

$3

is applying each value

`javascript
_(v => v * 3).each(3, 5, 7)._
// [9, 15, 21]
`

$3

is manageing onto delaying and forceing or applying

`javascript
_(v => v * 5)
.done(3) // apply it
.done(4) // no action
.done(5) // no action
._

// 15
`

$3

is promiseObj.then pipe chaining;

`javascript
_(_.async(r => r(3)))
.pipe(
v => v + 5,
v => v * 2
)
._

// {fullfilled, 16}
`

$3

is promiseObj.then pipe chaining;

`javascript
_(_.async(r => r(3)))
.loop(
console.log,
console.log
)
._

// {fullfilled, 3}
`


$3

is promiseObj.pipeline method chaining;

`javascript
// It is like to use wavy dot
// const data = await disk~.(...args)~.openDirectory('foo')~.openFile('bar.txt')~.read();
async () => {
const data = await _(getFileSystem())
.Will
.Be(...arg)
.openDirectory('foo')
.openFile('bar.txt')
.read()
.Done
._;
}
`

$3

to likely value array

`javascript
_([0, 1, 2, 3, 4, 5]).liken([1, 100, 2, 200, 3, 300])._
// [1, 2, 3]
`

$3

pick of same key value

`javascript
_([0, 1, 2, 3, 4, 5]).equaly([1, 1, 2, 3, 5, 8])._
// [1, 2, 3]
`

$3

exist value remove and unexist value add

`javascript
_([0, 1, 2, 3, 4, 5]).toggle(1, 3, 5, 8)._
// [0, 2, 4, 8]
`

$3

pick up exist values

`javascript
_([0, 1, 2, 3, 4, 5, 6, 7, 8]).pick(-1, 2 ,5 ,6)._
// [2, 5, 6]
`

$3

omit at exist values

`javascript
_([1, 2, 3, 4, 5]).drop(2, 4, 6)._
// [1, 3, 5]
`

$3

rewrap array in partial array

`javascript
_([0, 1, 2, 3, 4, 5]).chunk(2)._
// [[0, 1], [2, 3], [4, 5]]
`

### _([]).unique
is pick up different values

`javascript
_([1, 2, 3, 4, 5, 2, 6, 3]).unique._
// [1, 2, 3, 4, 5, 6]
`

$3

is concat other Array and pick up different values

`javascript
_([3, 4, 5, 6]).union([0, 1, 2, 3, 4])._
// [0, 1, 2, 3, 4, 5, 6]
`

$3

is replase other Array;

`javascript
_([3, 4, 5, 6, 7]).put([,,3,4,,,8,9])._
// [3, 4, 3, 4, 7]
`

$3

is apply Array.prototype.includes

`javascript
_([2, 8]).exist(8)._
// true

_([2, 8]).exist(3)._
// false
`

$3

is pick Array in Object can use _({}).pick 's query string

`javascript
_([
{a: 30, b: 40, c: 50},
{a: 31, b: 41, c: 51},
{a: 32, b: 42, c: 52},
{a: 33, b: 43, c: 53}
])
.pickKey('a, c')
._

/*
[
{a: 30, c: 50},
{a: 31, c: 51},
{a: 32, c: 52},
{a: 33, c: 53}
]
*/
`

$3

is drop Array in Object can use _({}).drop 's query string

`javascript
_([
{a: 30, b: 40, c: 50},
{a: 31, b: 41, c: 51},
{a: 32, b: 42, c: 52},
{a: 33, b: 43, c: 53}
])
.dropKey('a, c')
._
/*
[
{b: 40},
{b: 41},
{b: 42},
{b: 43}
]
*/
`

$3

`javascript
_([1, 2, 3]).pushL(-1, 0)._
// [-1, 0, 1, 2, 3]
`

$3

`javascript
_([1, 2, 3]).pushR(4, 5)._
// [1, 2, 3, 4, 5]
`

$3

`javascript
_([1, 2, 3]).popL._
// 1
`

$3

`javascript
_([1, 2, 3]).popR._
// 3
`

$3

`javascript
_([1, 2, 3]).omitL._
// [2, 3]
`

_([]).omitR

`javascript
_([1, 2, 3]).omitR._
// [1, 2]
`

$3

like for ...of iteration

`javascript
_([1, 2, 3, 4, 5]).each(console.log)._
`

$3

highly function recieve in this Array

`javascript
_([1 ,2 ,3 ,4 ,5])
.lift(
a => a
.map(v => v + 8)
.reduce((p, c) => p + c)
)._
// 55
`

$3

is reduceing to left

`javascript
_([1, 3, 5]).fold((p, c) => p - c)._
// -7
`

$3

is reduceing to left

`javascript
_([1, 3, 5]).foldL((p, c) => p - c)._
// -7
`

$3

is reduceing to Right

`javascript
_([1, 3, 5]).foldR((p, c) => p - c)._
// 1
`

$3

apply Array.prototype.filter

`javascript
_([1, 2, 3, 4, 5]).filter(v => v < 4)._
// [1, 2, 3]
`

$3

is transeform Array vector

`javascript
_([
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
])
.rotate
._

/*
[
[1, 4, 7],
[2, 5, 8],
[3, 6, 9],
]
*/
`

$3

via applicative map

`javascript
_([v => v + 5, v => v * 5])
.aMap([1, 2, 3, 4, 5])
._

/*
[
[6, 7, 8, 9, 10],
[5, 10, 15, 20, 25]
]
*/

_([1, 2, 3, 4, 5])
.aMap([v => v + 5, v => v * 5])
._
/*
[
[6, 5],
[7, 10],
[8, 15],
[9, 20],
[10, 25]
]
*/
`

$3

is map to other Array

`javascript
_([1, 2, 3, 4, 5])
.map(
v => v * 5,
v => v + 3,
)
._
// [8, 13, 18, 23, 28]
`

$3

is Array flatMap

`javascript
_([1, 2, 3, 4, 5])
.fMap(
v => [v * 5],
v => [v + 3],
)
._
// [8, 13, 18, 23, 28]
`

$3

is map to other Array it apply deep Array

`javascript
_([1, [2, [3, [4, [5]]]]])
.map(
v => v * 5,
v => v + 3,
)
._
// [8, [13, [18, [23, [28]]]]]
`

$3

is Array flatten

`javascript
_([[1, 2], 3, [4, [5]]]).flatten(2)._
// [ 1, 2, 3, 4, 5 ]
`

$3

apply Array .prototype.reverce
!!!Not Pure!!!

`javascript
_([1, 2, 3, 4, 5]).back._
// [5, 4, 3, 2, 1]
`

$3

assign empty place at left

`javascript
_([ , ,3 , , ,]).adapt(1, 2, 4, 5)._
// [1, 2, 3, 4, 5]
`

$3

assign empty place at left

`javascript
_([ , ,3 , , ,]).adaptL(1, 2, 4, 5)._
// [1, 2, 3, 4, 5]
`

$3

assign empty place at right

`javascript
_([ , ,3 , , ,]).adaptR(1, 2, 4, 5)._
// [5, 4, 3, 2, 1]
`

$3

marge Array

`javascript
_([1, 2, 3, 4, 5]).concat([6, 7, 8])._
// [1, 2, 3, 4, 5, 6, 7, 8]
`

$3

is Array replacement
!!!Not Pure!!!

`javascript
_([1, 2, 3, 4, 5]).replace(2, 2, 6)._
// [1, 2, 6, 5]
`

$3

call Array.prototype.splice
!!!Not Pure!!!

`javascript
_([1, 2, 3, 4, 5]).splice(2, 2, 6)._
// [3, 4]
`

$3

call Array.prototype.slice

`javascript
_([1, 2, 3, 4, 5]).slice(2, 2)._
// [3, 4]
`

$3

apply Array.prototype.sort

`javascript
_([4, 2, 5, 1, 3]).sort()._
// [1, 2, 3, 4, 5]
`

$3

via indexOf

`javascript
_([1, 2, 3, 2, 5]).indexL(2)._
// 1
`

$3

via lastIndexOf

`javascript
_([1, 2, 3, 2, 5]).indexR(2)._
// 3
`

$3

via Array.prototype.some

`javascript
_([1, 2, 3, 2, 5]).any(v => v > 4)._
// true
`

$3

via Array.prototype.every

`javascript
_([1, 2, 3, 2, 5]).all(v => v > 4)._
// [1, 2, 3, 4, 5].every(v => v > 4)
`

$3

spread and apply to function

`javascript
_([1, 2, 3]).unite((a, b, c) => (a + b) * c)._
// 9
`

$3

add all value

`javascript
_([1, 2, 3, 4, 5]).sum._
// 15
`

$3

product all value

`javascript
_([1, 2, 3, 4, 5]).pi._
// 120
`

$3

get average value

`javascript
_([1,1,5,3,8,8,9,10,12,12,13,13,13,14]).average._
// 8.71...
`

$3

get max value

`javascript
_([1,2,3,4,5,3,8,2]).max._
// 8
`

$3

get min value

`javascript
_([1,2,3,4,-3,3,8,2]).min._
// -3
`

$3

get median value

`javascript
_([3, 4, 2, 7, 6, 5, 1]).mid._
// 4
`

$3

omit voidly value

`javascript
_([ , ,3 ,4 , , ,5 , ,]).less._
// [3, 4, 5]
`

$3

replase from empty to undefined

`javascript
_([ , ,3 ,4 , , ,5 , ,]).sure._
// [undefined ,undefined ,3 ,4 ,undefined ,undefined ,5 ,undefined]
`

$3

from Array to Object

`javascript
_([1, 2, 3, 4, 5]).admix(...'abcde')._
/*
{
a: 1,
b: 2,
c: 3,
d: 4,
e: 5
}
*/
`

$3

not exist voidly value

`javascript
// false
_([,2,3]).fullen._
_([1,,3]).fullen._
_([1,2,,]).fullen._
_([null, 2, 3]).fullen._
_([1, null, 3]).fullen._
_([1, 2, null]).fullen._
_([void 0, 2, 3]).fullen._
_([1, void 0, 3]).fullen._
_([1, 2, void 0]).fullen._
_({a: null, b: 2, c: 3}).fullen._
_({a: 1, b: null, c: 3}).fullen._
_({a: 1, b: 2, c: null}).fullen._
_({a: void 0, b: 2, c: 3}).fullen._
_({a: 1, b: void 0, c: 3}).fullen._
_({a: 1, b: 2, c: void 0}).fullen._

// true
_({a: 0, b: true, c: false}).fullen._
_([0, true, false]).fullen._
`

$3

apply JSON.parse

`javascript
_('{"a": 5}').toObject._
// {a: 5}
`

$3

date string parse to Date Object

`javascript
_("2000-01-01T00:00:00.000Z").toDate._.getDate()
// 1

_('{"yr": 2000, "mo": 1, "dt": 1}').toDate._.getDate()
// 1
`
​


$3

is get whitch

Get LocalTimeZone
'yr': fullYear
'mo': month (not month ID)
'dt': date
'dy': day of the week ID
'wk': number of the week
'hr': hour
'min': minute
'sec': secounds
'ms': msec

Get UTC
'yrUTC': fullYear
'moUTC': month (not month ID)
'dtUTC': date
'dyUTC': day of the week ID
'hrUTC': hour
'minUTC': minute
'secUTC': secounds
'msUTC': msec

if single kind return value

`javascript
_(new Date(0)).get('yr')._
// 1970
`


if multi kind return Object

`javascript
_(new Date(0)).get('yr, mo, dt, dy, hr, min, sec, ms')._

/*
{
yr: 1970,
mo: 1,
dt: 1,
dy: 4,
wk: 1,
hr: Math.trunc(_.zone / 60),
min: _.zone % 60,
sec: 0,
ms: 0
}
*/
`

get UTC

`javascript
_(new Date(0)).get('yrUTC, moUTC, dtUTC, dyUTC, hrUTC, minUTC, secUTC')._

/*
{
yrUTC: 1970,
moUTC: 1,
dtUTC: 1,
dyUTC: 4,
hrUTC: 0,
minUTC: 0,
secUTC: 0
}
*/
`

$3

Date Object set value like a Object.assign

`javascript
_(new Date(0))
.put({
yr: 2020,
mo: 5, // not Month ID It meen 'May'
dt: 28,
hr: 15,
min: 28,
sec: 16,
ms: 330
})
.get('yr, mo, dt, dy, hr, min, sec, ms')
._

/*
{
yr: 2020,
mo: 5,
dt: 28,
dy: 4,
hr: 15,
min: 28,
sec: 16,
ms: 330
}
*/

_(new Date(0))
.put({
yrUTC: 2020,
moUTC: 5, // not Month ID It meen 'May'
dtUTC: 28,
hrUTC: 15,
minUTC: 28,
secUTC: 16
})
.get('yrUTC, moUTC, dtUTC, dyUTC, hrUTC, minUTC, secUTC')
._

/*
{
yrUTC: 2020,
moUTC: 5,
dtUTC: 28,
dyUTC: 4,
hrUTC: 15,
minUTC: 28,
secUTC: 16,
}
*/
`

$3

modify Date Object's it works likely Date .get's and set's keys

`javascript
_(new Date(0))
.map('min, sec')(
({min, sec}) => ({min: min + 1, sec: sec + 30})
)
.get('min, sec')
._

/*
{
min: 1,
sec: 30
}
*/

_(new Date(0))
.map(
'sec'
)(
s => s + 15
)
.get('sec')
._

// 15
`

$3

get the last month of the date

`javascript
_(new Date(0)).endOfMo.get('mo, dt')._

/*
{
mo: 1,
dt: 31
}
*/
`

$3

get the last month of the date in UTC GMT

`javascript
_(new Date(0)).endOfMoUTC.get('moUTC, dtUTC')._

/*
{
moUTC: 1,
dtUTC: 31
}
*/
`

$3

get TimeZone offset value

`javascript
_(new Date(0)).zone._
`

$3

get raw millisec at UTC 0

`javascript
_(new Date(0)).raw._
// 0
`

$3

get ISO String

`javascript
_(new Date(0)).ISO._
`

$3

get UTC String

`javascript
_(new Date(0)).UTC._
`




$3

get Date infomation on Object

`javascript
_(new Date(0)).toObject._

/*
{
yr: 1970,
mo: 1,
dt: 1,
dy: 4,
hr: Math.trunc(_.zone / 60),
min: _.zone % 60,
sec: 0,
ms: 0
}
*/
`

$3

get Date by UTC infomation on Object

`javascript
_(new Date(0)).toObjectUTC._

/*
{
yrUTC: 1970,
moUTC: 1,
dtUTC: 1,
dyUTC: 4,
hrUTC: 0,
minUTC: 0,
secUTC: 0
}
*/
`

$3

via _(Date).toObject.toJSON._

`javascript
_(new Date(0)).toJSON._

// expect
JSON.stringify({
yr: 1970,
mo: 1,
dt: 1,
dy: 4,
hr: Math.trunc(_.zone / 60),
min: _.zone % 60,
sec: 0,
ms: 0
});
`

$3

via _(Date).toObjectUTC.toJSON._

`javascript
_(new Date(0)).toJSONUTC._

JSON.stringify({
yrUTC: 1970,
moUTC: 1,
dtUTC: 1,
dyUTC: 4,
hrUTC: 0,
minUTC: 0,
secUTC: 0
})
`

$3

Parse from _(Date).toJSON._

`javascript
_(new Date(0)).toJSON.toDate.toObject._

/*
{
yr: 1970,
mo: 1,
dt: 1,
dy: 4,
hr: Math.trunc(_.zone / 60),
min: _.zone % 60,
sec: 0,
ms: 0
}
*/
`

$3

Parse from _(Date).toJSONUTC._

`javascript
_(new Date(0)).toJSONUTC.toDateUTC.toObjectUTC._

/*
{
yrUTC: 1970,
moUTC: 1,
dtUTC: 1,
dyUTC: 4,
hrUTC: 0,
minUTC: 0,
secUTC: 0
}
*/
``

$3

have a Timezone information on minutes base

Event driven development:

~~~javascript
const EETest = _(EventEmitter).fork(function () {
EventEmitter.call(this)
})._

const eeTest = new EETest()

//addLitener
_(eeTest).on({
a: 3,
"get" () {
this.a === 3 // true
this.put() // can call it
},
"put": () => {},
"post": () => {},
"delete": () => {}
})

//addOnce
_(eeTest).once({
b: 10,
"get" () {
this.b === 10 // true
this.put() // can call it
},
"put": () => {},
"post": () => {},
"delete": () => {}
})
~~~

Special Thanks
mafumafuultu