Lambda Calculus

Bitwise operation using math functions

Lambda Calculus with the Tree Structures Representation.

❝𝐖𝐡𝐚𝐭 𝐚𝐧𝐝 𝐖𝐡𝐲?❞

• ကျွန်တော်တို့ ၁၀တန်းတုန်းက သင်ခဲ့ရတဲ့ Logic gatesတွေရဲ့ အလုပ်လုပ်ပုံကို Math functionတွေသုံးပြီး တည်ဆောက်လို့ရပါတယ်။ Math functionတွေက Logic Gateတခုတည်း မဟုတ်ဘဲ ကိုယ်ကြိုက်ရာ ဘာမဆို တည်ဆောက်ပြီးလည်း သက်သေပြလို့ရပါတယ်။ အရာရာတိုင်းက functionဖြစ်နိုင်တယ်၊ ဖတ်ရလွယ်စေတယ်။ ဒါပေမယ့် နေရာတိုင်းတော့ မသုံးသင့်ဘူး။

❝𝐖𝐡𝐚𝐭 𝐢𝐬 𝐚 𝐦𝐚𝐭𝐡 𝐟𝐮𝐧𝐜𝐭𝐢𝐨𝐧?❞

• စစချင်း Maths functionတွေအကြောင်းကို ရှင်းပြပါမယ်။ Functionရဲ့ သဘောတရားက သူ့ထဲကို Argumentsတွေ ထည့်လို့ရတယ်။ အဲ့ဒီArgumentsတွေက ဘာမဆို(ထည့်တဲ့ input valueက Math function၊ ကိန်းဂဏန်း၊ စာလုံးတွေ၊ ဘာမဆို)ဖြစ်နိုင်တယ်။

□ f(x) = x

• ဒီမှာဆိုရင် fသည် function nameဖြစ်တယ်။ xဆိုတာ variableပေါ့။ ဒီxကို ‘မသိကိန်း’ဆိုပြီး ကျောင်းမှာသင်ရတယ်။ ကိန်းဂဏန်းပဲ ထည့်တွက်ကြတာကိုး။ တကယ်တမ်းကတော့ ဘာမဆိုထည့်လို့ရတယ်။ “မသိကိန်း”ဆိုတဲ့ စကားကြီးကြောင့် “ကိန်းဂဏန်း”ပဲ ထည့်လို့ရတယ်ဆိုတဲ့ အသိက ကိုယ့်အတွက် အမှောင်ကျသွားပြီး တခြားဟာထည့်ကြည့်ဖို့ မစဥ်းစားမိကြတော့ဘူး။ xသည် variable(ဘာလာလာ)ဖြစ်တယ်။ Argumentsဆိုတာသည် အဲ့ဒီ variableထဲကို ထည့်လိုက်တဲ့ actual valueပေါ့။
• အသီးဖျော်တဲ့ functionရှိတဲ့ စက်တလုံးမှာ ထည့်လို့ရတဲ့ ခွက်အပေါက်ရှိတယ်။ အဲ့ခွက်အပေါက်သည် variableပေါ့။ ဘာထည့်ထည့် လက်ခံမယ့် အပေါက်တခုပေါ့။ တကယ်တမ်းထည့်လိုက်တဲ့ actual valueသည် ဖရဲသီးဖြစ်နိုင်တယ်၊ ထောပတ်သီးလည်း ဖြစ်နိုင်တယ်။ ဒီကောင်တွေသည် argumentsတွေပေါ့။
• ဒီမှာဆိုရင် function fရဲ့ လုပ်ဆောင်ပုံက သူ့ထဲကို Left Hand Side(LHS)မှာရှိတဲ့ variable xကနေ ဘာထည့်ထည့်၊ ညီမျှခြင်း တဖက်က Right Hand Side(RHS)မှာ LHSကနေ ထည့်တဲ့အတိုင်း ပြန်ထွက်မယ်။ သူရဲ့ Syntax(ရေးသားပုံ ရေးသားနည်း)ကတော့ အဲ့လိုပုံစံပါပဲ။

□ f(1) = 1
□ f(g(y)) = g(y)
□ f(‘A’) = ‘A’

• 1ဆိုတဲ့ ဂဏန်းထည့်လိုက်တယ်။ သူက outputအနေနဲ့ ဘာပြန်ပေးသလဲဆိုရင် 1ပြန်ပေးတယ်။ သူ့ထဲကို function g(y)ထည့်မယ်ဆိုရင် g(y)ကို ပြန်မယ်။ ‘A’ဆိုတဲ့ characterထည့်မယ်ဆိုရင်လည်း ‘A’ကိုပြန်မယ်။
• ဒါက အရှင်းဆုံးပြလို့ရတဲ့ Math functionတခုပါပဲ။ ထည့်ရင် ထည့်တဲ့အတိုင်း တဖက်မှာထွက်တယ်။ အချစ်ပေးရင် အချစ်ပြန်ရမယ်။ ငါချစ်သလို ပြန်ချစ်ပါတယ်ပေါ့။ :3

(ကားမောင်းမယ်ဆိုရင် Engineလည်ရတဲ့ functionရှိမယ်။ အဲ့ဒီမှာ ဘာလိုသလဲဆိုရင် ဓာတ်ဆီ (သို့မဟုတ်) ဒီဇယ်လိုပြီ။ အဲ့ဒီမှာ ကိုယ်က ရေထည့်မောင်းလို့တော့ မရဘူး။ ထည့်လို့မရဘူးမပြောဘူးနော်။ Engineက အလုပ်လုပ်မှာ မဟုတ်ဘူး။ ဒါကတော့ အသုံးပြုသူကိုယ်တိုင်က ဒီfunctionသည် ဘာလုပ်ရတဲ့ functionဆိုတာကို သိဖို့လိုတယ်။ မဟုတ်ရင် outputထွက်မှာ မဟုတ်ဘူး။ ဒါက Logical thinkingအပိုင်းပေါ့။ အဓိကပြောချင်တာက ထည့်ချင်တာ ထည့်တိုင်းလည်း အလုပ်မလုပ်ဘူး။)

❝𝐓𝐰𝐨 𝐨𝐫 𝐦𝐨𝐫𝐞 𝐚𝐫𝐠𝐮𝐦𝐞𝐧𝐭𝐬❞

• အဲ့ဒီမှာ arguments၂ခု (သို့မဟုတ်) ၂ခုထက် ပိုလာပြီဆိုရင် အောက်ကလို ရေးလို့ရတယ်။

□ f(x, y) = x

• ဒီမှာဆိုရင် ၂ခုထည့်မယ်။ ပထမတခုပဲ ပြန်ထွက်မယ်ပေါ့။

□ f(1, 2) = 1
□ f(‘A’, ‘B’) = A

(ဒီequationကို မြင်တော့ ဘာကိုသွားသတိရမိလဲဆိုတော့ ဂျင်းထည့်ခဲ့တဲ့ Exကြီးကို သွားသတိရတာ။ ဒုတိယတယောက်ဆိုတာ ပထမတယောက်ကို မချစ်လို့ ရှိလာတာဆိုပြီး ပထမတယောက်ကိုပဲ ‌ရွေးချယ်သွားတာမျိုးပေါ့။ တကယ်တမ်းကတော့ ဒုတိယတခုက ဘာဖြစ်ပဲနေနေ စာရင်းထဲကို မရှိတာမျိုး။ :3)

❝𝐇𝐨𝐰 𝐭𝐨 𝐩𝐫𝐨𝐯𝐞 𝐞𝐪𝐮𝐚𝐥𝐢𝐭𝐲 𝐢𝐧 𝐟𝐮𝐧𝐜𝐭𝐢𝐨𝐧𝐬❞
□ f(x) = 2x, g(x) = x+x

• ဒီမှာဆိုရင် f(x)နဲ့ g(x)ထဲကို တူညီတဲ့ argumentတခု ထည့်ကြည့်ပါမယ်။

□ f(3) = 2*3 = 6
□ g(3) = 3+3 = 6

• Functionဆိုတာ ဘာမှန်းမသိတဲ့ black boxကြီးတခုနဲ့ တူတယ်။ သူ့ထဲကို argumentတခုခုထည့်ကြည့်ပြီးမှ resultကို ကြည့်ပြီး တူမတူကို သိရတာမျိုးပါ။ ဒီလို တူတာမျိုးကို extensional equalityလို့ ခေါ်ပါတယ်။ Functionဆိုတဲ့ သဘောတရားအရ same resultထွက်နေပေမယ့် internallyမှာတော့ လုပ်ဆောင်ပုံက ကွဲသွားနိုင်လို့ပါပဲ။
• Function fရဲ့ 2*3ဆိုတဲ့ သဘောက Distributive Lawအရ internal operationက +ဖြစ်မယ်ဆိုရင်တောင် 2+2+2လည်း ဖြစ်နေနိုင်ပါတယ်။ အဲ့ဒါကြောင့် မတူတဲ့လုပ်ဆောင်ချက်(Multiplicationနဲ့ Addition)ကနေ ထွက်လာ|နိုင်|တဲ့ resultမို့ extensional equalityပဲ ရနိုင်တာပါ။ (Equality ၃မျိုးရှိပါတယ်။ Strict, Loose, Extensional Equalityဆိုပြီးတော့ပေါ့။)
• Functionတွေအကြောင်းကို အခြေခံအားဖြင့် နားလည်သွားပြီဆိုရင် နောက်တဆင့် တက်လို့ရပါပြီ။ ကျွန်တော်တို့ ခုအသုံးပြုမှာက Function usageရဲ့ အခွဲတခုဖြစ်တဲ့ Lambda Calculusပေါ့။ သူ့ရဲ့ အလုပ်လုပ်ပုံနဲ့ Syntaxကို ဆက်ရှင်းပြပါမယ်။

❝𝐈𝐧𝐭𝐫𝐨𝐝𝐮𝐜𝐭𝐢𝐨𝐧 𝐭𝐨 𝐥𝐚𝐦𝐛𝐝𝐚 𝐜𝐚𝐥𝐜𝐮𝐥𝐮𝐬❞

• Lambda Calculusမှာ Functionတွေသည် ဘာမဆိုဖြစ်နိုင်တယ်(ဘုရားတောင် ဖြစ်နိုင်တယ်)။ ဒါပေမယ့် နေရာတိုင်းမှာ မသုံးသင့်ဘူး။ ဘာကြောင့်လဲဆိုတော့ computation powerအရမ်းသုံးလို့။ ဒါကို Alonzo Churchဆိုတဲ့ ဘဲကြီးက တီထွင်ခဲ့တာပါ။ Computingကို pure functional paradigmကနေတဆင့် သက်သေပြခဲ့တာပေါ့။ အဲံဒီမှာ Alan Turingဆိုတဲ့ ဘဲကြီးကလည်း 1(high, true), 0(low, false)ကိုသုံးပြီး state-based machineကို တီထွင်ခဲ့တယ်။ Turing machineဆိုပြီး အဲ့မှာစပေါ်ခဲ့တယ်။ သူက ဂျာမန်တွေရဲ့ Enigma machineရဲ့ ဝှက်စာကို ဖောက်ဖို့တီထွင်ခဲ့တာပါ။ Enigma machineရဲ့ ဝှက်စာကိုလည်း ဖောက်နိုင်ခဲ့ပါတယ်။ အဲ့ဒီကနေ Computerဖြစ်လာတာပါပဲ။ သူရဲ့ လုပ်ဆောင်ချက်က Churchနဲ့ different approachပေမယ့် same resultပဲ ထွက်တာပါပဲ။ Church-Turing Thesisဆိုပြီး Google‌ခေါက်ရှာကြည့်လို့ရပါတယ်။ (ရှာမှာလည်း မဟုတ်ပါဘူး။ ဒီထိ ဖတ်ရင်ကို တော်တော်ဟုတ်နေပြီ။:3)
  Functionတခုသည် argumentတခုကိုပဲ လက်ခံတယ်။ ၂ခုနှင့်အထက် ပိုလာတဲ့ argumentsတွေဆိုရင် functionတခုပေါ်မှာ တခုဆင့်ပြီး ဆွဲခေါ်သွားပါတယ်။ အဲ့လို ဆင့်ခေါ်သွားတာမျိုးကို Curryingလို့ ခေါ်ပါတယ်။

❝𝐒𝐲𝐧𝐭𝐚𝐱 𝐨𝐟 𝐋𝐚𝐦𝐛𝐝𝐚 𝐂𝐚𝐥𝐜𝐮𝐥𝐮𝐬❞

• Lambda Calculusရဲ့ Syntaxကို အရင် စပြောပြပါမယ်။

□ λx.x

• Lambda Symbol(λ)ပါနေတဲ့ဘက်က argumentဖြစ်ပြီး မပါတဲ့ဘက်က output resultဖြစ်ပါတယ်။ f(x) = xနဲ့ အတူတူပါပဲ။ ဒါဆိုရင် f(x, y) = xဆိုရင် အောက်ကလိုမျိုး ရေးရပါမယ်။

□ λx.λy.x

• ဒီနေရာမှာ λက argumentတခုထည့်တိုင်း ပါနေမှာဖြစ်တဲ့အတွက် ခဏခဏထည့်မရေးဘဲ λinput(s).outputပုံစံနဲ့ ရေးပါမယ်။ အပေါ်က λx.λy.yကို λxy.xဆိုပြီး ပြောင်းရေးပါမယ်။ λပါတဲ့ဘက်သည် argumentတွေရှိတဲ့ဘက််ဖြစ်ပြီး dot(.)နောက်က ရေးတာတွေသည် resultဖြစ်ပါတယ်။ ဒါသည် simplify version(အရှင်းဆုံး ပုံစံ)ပါပဲ။ ဒီပုံစံကို readabilityသက်သက်ပဲ သုံးတာပါ။

❝𝐂𝐮𝐫𝐫𝐲𝐢𝐧𝐠❞

• တွက်ချက်ဖို့ mathematical languageအနေနဲ့ ရေးမယ်ဆိုရင်တော့ အောက်ကလို ရေးရပါတယ်။ ဒါက Syntaxပဲ ရှိသေးပါတယ်။ :3

□ let x = f(a, b, c)

• ဒီအပေါ်က functionကို Lambda calculusက ဘယ်လို ခေါ်ထားသလဲဆိုရင်…

□ let h = g(a)
□ let i = h(b)
□ let x = i(c)

• ဒီလို functionလေးတွေ ဆောက်ပြီး အောက်ကလို တကြောင်းလည်း ပြန်ခေါ်လိုက်ပါတယ်။ i = h(b)နေရာမှာ hကို g(a)နဲ့ အစားထိုးလိုက်တယ်။

□ let i = g(a)(b)

• ရလာတဲ့ iအသစ်ကို x = i(c)ရဲ့ iနေရာမှာ အစားထိုးလိုက်ပါတယ်။

□ let x = g(a)(b)(c)

(Argumentsတွေက function nameနောက်ကနေ လက်သည်းကွင်းခတ်ပြီး ခေါ်ရတယ်လို့ပဲ အလွယ်မှတ်ထားရင်လည်း ရပါတယ်။ Sequenceက Left to rightပဲသွားပါတယ်။ a, b, cတခုချင်း ထည့်သွားတယ်ပေါ့။)

□ f(a, b, c) = g(a)(b)(c)

ဒါကို အ‌ပေါ်က f(x, y) = xကို Lambda Calculusအနေနဲ့ ပြမယ်ဆိုရင် f(x)(y) = xလို့ ရေးပါတယ်။

❝𝐆𝐫𝐨𝐮𝐩𝐢𝐧𝐠 𝐚𝐧𝐝 𝐀𝐩𝐩𝐥𝐢𝐜𝐚𝐭𝐢𝐨𝐧❞

• နောက်တခုကတော့ Spaceကို Functionက argumentတခုကို အသုံးချနေချိန်မှာ သုံးပြီး Groupingကို Parenthesis(လက်သည်းကွင်း)နဲ့ သုံးပါတယ်။ အောက်မှာ ဥပမာတွေနဲ့ ရှင်းပြပါမယ်။

□ one := λfx.f x
□ one(f)(x) = f(x)

အပေါ်က ပုံထဲကလို one := λsz.s zဆိုပြီး variableကို ဘာနဲ့သုံးသုံး အတူတူပါပဲ။ ကျွန်တော်က ဒီမှာဘာလို့ variable nameကို fလို့ သုံးရသလဲဆိုရင် ထည့်ရမယ့် variableသည် functionဖြစ်ရမယ်ဆိုပြီး အသိပေးချင်လို့ပါပဲ။

□ two := λfx.f (f x)
□ two(f)(x) = f(f(x))

• one, twoတွေက function nameတွေပါ။ Groupingကတော့ ရှင်းပါတယ်။ Equationတခုမှာ အရင်ဆုံး လုပ်မယ့် Mathematical Operationတွေကို ပုံမှန်အတိုင်း ကွင်းခတ်တဲ့ သဘောပါပဲ။ ဒါဆိုရင်တော့ Syntaxကို နားလည်လိမ့်မယ်လို့ ထင်ပါတယ်။

❝𝐁𝐮𝐢𝐥𝐝𝐢𝐧𝐠 𝐚 𝐟𝐮𝐧𝐜𝐭𝐢𝐨𝐧❞

• စစချင်း အရှင်းဆုံးပုံစံကနေ စလိုက်မယ်။

□ I := λ‌a.a
□ I(a) = a

Get Aye Chan Aung Thwin’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

□ K := λab.a
□ K(a)(b) = a

• အဲ့အပေါ်က equation ၂ခုကို မှတ်မိမယ်ဆိုရင် “အချစ်ပေးရင် အချစ်ပြန်ရတာ”နဲ့ “Exက ဂျင်းထည့်တာ”နဲ့ပေါ့။ ခင်ဗျားတို့ကို အလကားနေ ဟာသပြောနေတာမဟုတ်ဘူး။ Memorizing Techniqueတခုနဲ့ ခေါင်းထဲထည့်ပေးနေတာ။ ဘယ်အရာမဆို တခုခုနဲ့ ထပ်ပြီးတွဲမှတ်ရင် ဘယ်တော့မှ မမေ့ဘူး။

❝𝐂𝐨𝐦𝐛𝐢𝐧𝐢𝐧𝐠 𝐭𝐰𝐨 𝐨𝐫 𝐦𝐨𝐫𝐞 𝐟𝐮𝐧𝐜𝐭𝐢𝐨𝐧𝐬 𝐭𝐨 𝐜𝐫𝐞𝐚𝐭𝐞 𝐚 𝐧𝐞𝐰 𝐨𝐧𝐞❞

• ကျွန်တော် အ‌ပေါ်က ပြောခဲ့သလိုပဲ argumentတွေကို ဘာထည့်ထည့်ရတယ်ဆိုတော့ K functionရဲ့ first argumentကို I functionကို ထည့်ကြည့်ပါမယ်။

□ K(I)(a) = I

• Equationအရ function Kသည် ပထမဆုံးတခုကိုပဲ resultထုတ်မှာပါ။ အဲ့ဒီတော့ function Iကို ပြန်ရပါမယ်။

□ K(I)(a)(b) = I(b) = b

• ဒီမှာဆိုရင် function Iက argumentတခုကို လက်ခံနိုင်တဲ့အတွက် သူ့ထဲကို နောက်တခုကို ထည့်လိုက်ပါတယ်။ ဆိုတော့ ဘာဖြစ်သွားသလဲကြည့်လိုက်ပါ။
  ပထမဆုံး function Kတုန်းက aနဲ့ bထည့်ရင် ပထမတခုဖြစ်တဲ့ aထွက်ပါတယ်။ K(I)မှာကတော့ aနဲ့ bထည့်ရင် ဒုတိယတခုဖြစ်တဲ့ bထွက်ပါတယ်။ ဒါကြောင့် ကျွန်တော်တို့က functionအသစ်တခုဖြစ်ဖို့ရာအတွက် functionအသစ်တခုကို တည်ဆောက်စရာမလိုဘဲ functionတွေပေါင်းပြီးတော့ တည်ဆောက်လို့ရတယ်ဆိုတာပါပဲ။
• Kနဲ့ Iကို ပေါင်းပြီး ခုလို functionအသစ်တခု ထုတ်လိုက်ပါတယ်။

□ KI := λab.K I a b
□ KI(a)(b) = K I a b

• အဲ့လို မရေးချင်ဘူးဆိုလည်း အောက်ကလို manually createလုပ်လို့လည်း ရပါသေးတယ်။ ထွက်တဲ့ resultကတော့ အတူတူပါပဲ။

□ KI := λab.b
□ KI(a)(b) = b

• ဒီနေရာမှာ မှန်ခြင်းနဲ့ မှားခြင်းကို စဥ်းစားဖို့ လိုပါပြီ။ အမှားအမှန်သိဖို့အတွက် အကြောင်းအရာ ၂ခုလိုအပ်ပါတယ်။ ၂ခုထဲ ၁ခုကို ရွေးချယ်တာမျိုး ဖြစ်ရပါမယ်။ ဒါဆိုရင် argument ၂ခုထည့်ပြီး ပထမတခုကို အဖြေထုတ်ပေးတဲ့ Kကို True functionလို့ သတ်မှတ်ပြီး KIကိုတော့ False functionလို့ သတ်မှတ်လိုက်ပါမယ်။

□ T := K
□ F := KI

❝𝐅𝐮𝐧𝐜𝐭𝐢𝐨𝐧 𝐭𝐨 𝐬𝐞𝐞 𝐫𝐞𝐬𝐮𝐥𝐭❞

• သတ်မှတ်ပြီးပြီဆိုပေမယ့် သူတို့ကို အဖြေထုတ်ပြဖို့အတွက် Functionတခုတည်ဆောက်ပါမယ်။ True, Falseတည်ဆောက်မှာ ဖြစ်တဲ့အတွက် Mathematianတယောက်ဖြစ်တဲ့ Boolean Algebraကို Logical Operationတွေအတွက် တီထွင်ခဲ့တဲ့ George Booleကို ဂုဏ်ပြုသောအားဖြင့် သူ့နာမည်ထည့်ပြီး တည်ဆောက်ပါမယ်။
  □ toBool := f(true)(false)
  Equationကတော့ ရှင်းရှင်းလေးပါပဲ။ functionကို လက်ခံမယ်၊ arguments၂ခုကို sequenceအတိုင်း ထည့်မယ်။ ဒါပါပဲ။ ရမရထည့်စမ်းကြည့်ကြမယ်။

□ toBool(T) = T(true)(false) = true
□ toBool(F) = F(true)(false) = false
ဒါဆိုရင် Bitwise operationလုပ်ဖို့အတွက် Boolean valueတွေဖြစ်တဲ့ true, falseတော့ ရသွားပါပြီ။

❝𝐅𝐥𝐢𝐩 𝐜𝐨𝐦𝐛𝐢𝐧𝐚𝐭𝐨𝐫❞

• Lambda Calculusရဲ့ Boolean expressionတွေထဲမှာ flip combinatorဆိုတာရှိပါတယ်။ သူ့equationကတော့ အောက်ကအတိုင်းပဲ ဖြစ်ပါတယ်။

□ C := λfab.f b a
□ C(f)(a)(b) = f(b)(a)

• Equationက အတော်ရိုးရှင်းပါတယ်။ ဝင်လာတဲ့ argument ၂ခုကို ပြောင်းပြန်ထည့်ပစ်လိုက်တာပါ။ ဒါဆိုရင် trueထည့်ရင် falseရပြီး falseထည့်ရင် trueရပါလိမ့်မယ်။ ဒါသည် NOT functionဖြစ်ပါတယ်။

→ <Assigning C to NOT function>
□ NOT := C

□ NOT(T)(a)(b) = T(b)(a) = b
□ NOT(F)(a)(b) = F(b)(a) = a

• ဒီမှာဆိုရင် Tရဲ့ aနဲ့ bကို နေရာချိန်းလိုက်တော့ resultမှာ aမထွက်ဘဲ bထွက်ပါတယ်။

□ toBool(NOT(T)) = T(false)(true) = false
□ toBool(NOT(F)) = F(false)(true) = true

• ဒါကတော့ ခုနက ထုတ်ခဲ့တဲ့toBool functionမှာ သွင်းပြီး resultထုတ်ကြည့်တာပါ။

❝𝐖𝐡𝐚𝐭 𝐜𝐚𝐧 𝐲𝐨𝐮 𝐝𝐨 𝐮𝐬𝐢𝐧𝐠 𝐭𝐡𝐢𝐬?❞

• ဒါကိုသိရင် ဘာလုပ်လို့ရသလဲဆိုတော့ ဟိုးအောက်ဆုံးကနေစပြီး high-levelထိ ကိုယ်ဖြစ်တဲ့အတိုင်း တည်ဆောက်လို့ရပါတယ်။ ဒါကိုသုံးပြီးတော့ပဲ boolean, arithematic, data structureကနေ to the moonထိသွားလို့ရပါတယ်။ ဒါကြောင့်Functionတွေက ဘာမဆိုဖြစ်နိုင်တယ်လို့ ပြောခဲ့တာပေါ့။
• ဒါဆိုရင်တော့ Bitwise operationထိရောက်အောင် သင်္ချာနည်းနဲ့ တွက်လို့ရတယ်ဆိုတာကိုတော့ သိသွားတာပေါ့။ သိသွားပြီဆိုတော့ ကျန်တဲ့AND, OR, NOR, NAND, XOR, XNORတွေကို truth tableတွေအတိုင်း ကြည်ပြီး functionတွေ ကိုယ်တိုင်တည်ဆောက်ကြည့်ပေါ့ဗျာ။ :3
• FYI, ဒီfunctionေတွ အားလုံးကို dynamic typingရတဲ့ programming languageေတွမှာ စမ်းလို့ရပါတယ်။ အောက်ကလင့်မှာ စမ်းသပ်ပါ။
• https://ayechanaungthwin.github.io/lambda-calculus-with-js/