บทสรุปของโพสต์โดย durumis AI
- ในบรรดาไลบรารีการเขียนโค้ดเชิงฟังก์ชัน fp-ts ได้รับความนิยมเนื่องจากมุ่งเน้นไปที่ฟังก์ชันแมปปิ้งและโมแนด แต่ได้เปลี่ยนไปเป็นลักษณะของเฟรมเวิร์กเมื่อรวมเข้ากับ Effect
- Effect ทำงานเหมือนเฟรมเวิร์กซึ่งแตกต่างจากไลบรารีทั่วไป และจำเป็นต้องมีความรู้ที่เกี่ยวข้องเพื่อใช้ Effect Object
- Effect ใช้วัตถุที่ห่อหุ้มด้วย Effect คล้ายกับ Observable ของ RxJs และคาดว่าจะมีศักยภาพในการตั้งมาตรฐานใหม่ในวงการ Node.js
ในช่วงไม่กี่ปีที่ผ่านมา การเขียนโปรแกรมเชิงฟังก์ชันได้รับความนิยมอย่างมาก
การเขียนโปรแกรมเชิงวัตถุช่วยสร้างโครงสร้าง
ส่วนการเขียนโปรแกรมเชิงฟังก์ชันช่วยสร้างความกระชับของโค้ดในส่วนย่อยๆ
แน่นอนว่ากระแสความนิยมของการเขียนโปรแกรมเชิงฟังก์ชันนั้นมีวงจรซ้ำๆ ทุกๆ ไม่กี่ปี
และจากกระแสความนิยมนี้เอง ทำให้มีไลบรารีต่างๆ เกิดขึ้นมากมาย
สำหรับผมแล้ว FxTs ดูเหมือนจะเป็นเพียงชุดเครื่องมือที่ใช้ generator ในการสร้างการประเมินแบบล่าช้า
lodash ก็คล้ายกัน คือให้ความรู้สึกเหมือนเป็นชุดเครื่องมือ
แน่นอนว่าชุดเครื่องมือเหล่านี้ช่วยในการเขียนโปรแกรมเชิงประกาศ
แต่สิ่งที่เราต้องการจากการเขียนโปรแกรมเชิงฟังก์ชันนั้นไม่ใช่แบบนั้น แต่เป็นเรื่องของการแมป การจับคู่ โมแนด และโมแนดอื่นๆ อีกมากมาย
fp-ts ตรงตามสิ่งที่เราต้องการ และผู้ดูแลรักษาก็จริงจังกับการเขียนโปรแกรมเชิงฟังก์ชันอย่างแท้จริง
แต่เมื่อไม่กี่เดือนก่อน ผมได้ยินข่าวว่าไลบรารีนี้Effect ได้ถูกผสานเข้าด้วยกันแล้ว
ดังนั้น ผมจึงลองดู Effect และพบว่ามันแตกต่างออกไป
ถ้า fp-ts เป็นเหมือนไลบรารี Effect นี้กลับเป็นเหมือนเฟรมเวิร์ก
การจะใช้ Effect นั้นจำเป็นต้องมีความรู้พื้นฐานเกี่ยวกับ Effect ด้วย
NestJs และ NextJs ก็เหมือนกัน คือต้องมีความเข้าใจเกี่ยวกับมันก่อนที่จะใช้งานได้
ไลบรารีถ้ามี API ที่เปิดเผยอย่างดี ก็แค่เอามาใช้ได้เลย แต่เฟรมเวิร์กนั้นต้องมีความเข้าใจในแพ็คเกจนั้นๆ ด้วย
import { Effect, Console } from "effect"
let i = 1
const expensiveTask = Effect.promise(() => {
console.log("expensive task...")
return new Promise((resolve) => {
setTimeout(() => {
resolve(result ${i++})
}, 100)
});
})
const program = Effect.gen(function* () {
console.log("non-cached version:")
yield* expensiveTask.pipe(Effect.andThen(Console.log))
yield* expensiveTask.pipe(Effect.andThen(Console.log))
console.log("cached version:")
const cached = yield* Effect.cached(expensiveTask)
yield* cached.pipe(Effect.andThen(Console.log))
yield* cached.pipe(Effect.andThen(Console.log))
})
Effect.runFork(program)
/*
Output:
non-cached version:
expensive task...
result 1
expensive task...
result 2
cached version:
expensive task...
result 3
result 3
*/
ลักษณะของ Effect นั้นคล้ายกับ RxJs ซึ่งแทนที่จะใช้ Observable ห่อหุ้ม ก็ใช้ Effect ห่อหุ้มวัตถุต่างๆ
เหมือนกับ async ที่แพร่กระจายไปทั่ว
ในการใช้วัตถุ Effect ฟังก์ชันที่ใช้กับวัตถุนั้นก็ต้องเป็น Effect ด้วย
เช่นเดียวกับ program ในโค้ดข้างต้น
แน่นอนว่ามีฟังก์ชันที่ใช้เป็นจุดเริ่มต้นอยู่บ้าง แต่ก็ไม่ค่อยน่าสนใจเท่าไหร่
อย่างไรก็ตาม รูปแบบและความเรียบง่ายของ Effect ในฐานะเฟรมเวิร์กนั้น อาจจะนำพาความเปลี่ยนแปลงและมาตรฐานใหม่ๆ มาสู่วงการ NodeJS ผมเองก็คาดหวังเช่นนั้น