Funktsjónal forritun í JavaScript, hluti 2 – samsetjendur

Inngangur að kombínatorum

Combinators eru hærri stigs fall sem gera þér kleift að sameina fall, breytur eða aðra combinators. Venjulega innihalda þau hvorki yfirlýsingar um eigin breytur né viðskiptalógík. Þau eru einu sem framkvæma stjórnflæðið í fallprógrammi.

Í þessari grein mun ég reyna að fjalla um nokkur þeirra:

• Snertu
• Kúrýering
• Pípa/Samsetning
• gafl
• Skipti
• Röð

Snertu

Combinator er mjög gagnlegur fyrir fall sem skilar engu. Hann tekur fallið sem breytan fer í og skilar því síðan.

Yfirlýsing

const tap = (fn) => (value) => {
fn(value);
return value;
};

Hvortvísunardæmi

const [items, setItems] = useState(() => [])

axios
.get('http://localhost')
.then({ gögn } => {
setItems(data)
console.log(data)
onLoadData(data)
}).then(...) // skilar undefined - gögnin í promise-inu hafa verið breytt

Yfirlýsingardæmi

const [items, setItems] = useState(() => [])

axios
.get('http://localhost')
.then(({ data }) => data)
.then(tap(setItems)) // (data) => { setItems(data); return data }
.then(tap(console.log)) // einn then = ein fall = ein ábyrgð
.then(tap(onLoadData))
.then(...) // enn aðgangur að upprunalegu gögnum
// auðvelt að viðhalda opna/loka meginreglunni

Kúrýering

Það skiptir rökum falls í sundur og gerir kleift að kalla þau í röð.

Yfirlýsing

const curry = (fn) => {
const curried = (...args) => {
if (fn.length !== args.length){
return curried.bind(null, ...args)
}
return fn(...args);
};

return curried

};

Dæmi

const curry = (fn) => {
const curried = (...args) => {
if (fn.length !== args.length){
return curried.bind(null, ...args)
}
return fn(...args);
};

return curried

};

const sum = (a, b, c) => a + b + c

const currySum = curry(sum)
/*
mögulegir kallir
currySum(a)(b)(c),
currySum(a)(b,c),
currySum(a,b)(c),
currySum(a,b,c)
*/

currySum(1) // (b, c) => 1 + a + b eða (b) => (c) => 1 + a + b
currySum(5)(10) // (c) => 5 + 10 + b
currySum(5, 10) // (c) => 5 + 10 + b
currySum(5)(10)(20) // 35
currySum(5, 10)(20) // 35
currySum(5)(10, 20) // 35

const divideBy = curry((a, b) => b / a)
const multiplyBy = curry((a, b) => a * b)

const divideByTwo = divideBy(2)
divideByTwo(10) // skilar 5

const multiplyByFive = multiplyBy(5)
multiplyByFive(10) // skilar 50

Pípa/Samsetning

Með samsetningu er hægt að senda gögn frá einni falli til annars. Mikilvægt er að fallin taki sama fjölda rökstuðnings. Munurinn á pipe og compose er sá að pipe keyrir fallin frá fyrsta til síðasta, en compose kallar þau frá enda.

Yfirlýsing

const pipe = (...fns) => (value, ...args) =>
fns.reduce((v, f, i) =>
i === 0?
 f(v, ...args)
: f(v),
value);

const compose = (...fns) => (value, ...args) =>
fns.reduceRight((v, f, i) =>
i === (fns.length - 1)?
 f(v, ...args)
: f(v),
value);

const pipe = (...fns) => (value, ...args) =>
fns.reduce((v, f, i) =>
i === 0?
 f(v, ...args)
: f(v),
value);

const compose = (...fns) => (value, ...args) =>
fns.reduceRight((v, f, i) =>
i === (fns.length - 1)?
 f(v, ...args)
: f(v),
value);

Hvortvísunardæmi

const sine = (val) => Math.sin(val * Math.PI / 180) // ekki læsilegt
 sine(90) // skilar 1Hljóðskrift

Yfirlýsingardæmi

const sine = pipe(
multiplyBy(Math.PI) // ↓ val * Math.PI
divideBy(180), // ↓ val * Math.PI / 180
Math.sin, // ↓ Math.sin(val * Math.PI / 180)
)

const sine = compose(
Math.sin, // ↑ Math.sin(val * Math.PI / 180)
divideBy(180), // ↑ val * Math.PI / 180
multiplyBy(Math.PI) // ↑ val * Math.PI)


sine(90) // skilar 1

gafl

Gaffakombinerinn er gagnlegur í aðstæðum þar sem þú vilt vinna úr gildi á tvo vegu og sameina niðurstöðurnar.

Yfirlýsing

`fork` er fall sem tekur `join`, `fn1` og `fn2` sem rök og skilar `value` sem fall. Þetta fall sameinar gildið með `join`-fallunum `fn1` og `fn2`.;Hljóðskrift

Dæmi

const length = (array) => array.length
const sum = (array) => array.reduce((a, b) => a + b, 0)
const divide = (a, b) => a / b

const arithmeticAverage = fork(divide, sum, length)

arithmeticAverage([5, 3, 2, 8, 4, 2]) // skilar 4

Skipti

Þessi samsetjari tekur tvær fall og skilar gildi fyrsta fallsins ef skilyrðið er satt. Annars skilar hann gildi annars fallsins.

Yfirlýsing

`const alt = (fn, orFn) => (value) => fn(value) || orFn(value)`HljóðskriftHljóðskrift

Dæmi

const users = [{
uuid: '123e4567-e89b-12d3-a456-426655440000',
name: 'William'
}]

const findUser = ({ uuid: searchesUuid }) =>
users.find(({ uuid }) => uuid === searchesUuid)

const newUser = data => ({ ...data, uuid: uuid() // búa til nýjan uuid })

const findOrCreate = alt(findUser, newUser)

findOrCreate({ uuid: '123e4567-e89b-12d3-a456-426655440000' }) // skilar William hlut
findOrCreate({ name: 'John' }) // skilar John hlut með nýjum uuid

Röð

Það tekur við mörgum sjálfstæðum fallum og sendir sömu breytuna til hvers og eins þeirra. Venjulega skila þessi fall engu gildi.

Yfirlýsing

`const seq = (...fns) => (val) => fns.forEach(fn => fn(val))`HljóðskriftHljóðskrift

Dæmi

const appendUser = (id) => ({ name }) => {
document.getElementById(id).innerHTML = name
}

const printUserContact = pipe(
findOrCreate, // skilar notanda
seq(
appendUser('#contact'), // notandi => tóm
console.log, // notandi => tóm
onContactUpdate // notandi => tóm)

)

printUserContact(userData)