Monad ගැන බ්ලොග් ලිපි පලය ගණනාවක් කියවලා, තේරුම් ගැනීමට තවත් අමාරු වුනාද? දැන් ඒ සංකීර්ණතා අතහැර, TypeScript දිනපතා භාවිත කරන Promise සහ Array මගින් Monad එකේ මූලික රටාව ඉක්මනින් ගවේෂණය කරමු.
Monad කියන්නේ "අගයක් ගොඩනැගෙන පේට්රෝලයක්" වගේ, තුන් ක්රියාකාරකම් – of, map සහ chain – ලබා දෙන වර්ගයක්. of(a) මඟින් අගයක් පේට්රෝලයට ඇතුළත් කරයි, map(f) පේට්රෝලය තුළ අගය වෙනස් කරයි, chain(f) අගය නව පේට්රෝලයක් බවට පත් කර, පසුව ඒ පේට්රෝලය සමතල කරයි.
Promise එකත් මේ රටාවට අනුකූල වේ. Promise.resolve(42) යනු of ක්රියාව, then(x => x*2) යනු map (සාමාන්ය අගයක් ආපසු දෙන විට) සහ then(id => fetch(`/api/users/${id}`)) යනු chain (ආපසු Promise එකක් දෙන විට). JavaScript එකේ .then එකම දෙකම කරයි – අගය සාමාන්ය වුවමනා නම් map, Promise එකක් නම් chain.
Array ද Monad එකකි. [42] යනු of, arr.map(x => x*2) යනු map, සහ arr.flatMap(x => [x, x*10]) යනු chain. මෙහි flatMap කියන්නේ map පසු flatten කිරීමයි, ඒ නිසා එය chain ලෙසද හඳුන්වයි.
මේ රටාව වඩාත් ප්රායෝගිකව දැකගත හැක්කේ Maybe Monad භාවිතයෙන් නල් (null) පරීක්ෂණ ඉවත් කිරීමයි. පාරම්පරිකව if (user && user.address && user.address.city) වගේ කේතයක් ලියන්නෙමු, නමුත් Maybe සමඟ pipe හා chain භාවිතා කරලා එක ලයින් එකට ලියන්න පුළුවන්:
- M.fromNullable(user) – නල් නම් Nothing, නැතිනම් Just(user)
- M.chain(u => M.fromNullable(u.address))
- M.chain(a => M.fromNullable(a.city))
- M.map(city => city.toUpperCase())
- M.getOrElse(() => "UNKNOWN")
එකක්වත් Nothing වෙලා ඉඳලා, ඊළඟ map හෝ chain ක්රියා නොකෙරේ. එබැවින් නල් පරීක්ෂණ, early return, exception handling ආදිය අතහැර, පිරිසිදු, ආකෘතිමත් කේතයක් ලියන්න පුළුවන්.
ශ්රී ලංකාවට ඇති වැදගත්කම
- අධ්යයන ශිෂ්යයින් – Functional Programming මූලධර්ම ඉගෙන ගන්න සරල උදාහරණයක්.
- දේශීය සංවර්ධකයින් – Promise, Array, Maybe වැනි Monad භාවිතයෙන් කේතයේ අඩු බග්, වැඩි maintainability ලැබේ.
- ව්යාපාර – Null‑check අඩු කර, සේවා වේගය වැඩි කර, දෝෂ අවදානම අඩු කරයි.
Monad එකේ මූලික රටාව තේරුම් ගත් පසු, @oofp/core වැනි ලයිබ්රරී වල ඇති අනෙකුත් Monad වර්ගයන්ටත් ඒකම ආකාරයෙන් යොමු විය හැකිය. TypeScript කේතය වඩාත් පාරදර්ශී, ආරක්ෂිත, සහ ප්රතිපත්තිමත් කර ගැනීමට මේ මාර්ගෝපදේශය ඔබේ අත්වැල වේ.
