រដូវក្តៅមុនខ្ញុំបានចូលរួម ហ្គូហ្គលរដូវក្តៅនៃកូដ - កម្មវិធីសម្រាប់សិស្សពី Google ។ ជារៀងរាល់ឆ្នាំ អ្នករៀបចំជ្រើសរើសគម្រោង Open Source ជាច្រើន រួមទាំងពីអង្គការល្បីៗដូចជា Boost.org и មូលនិធិលីនុច. Google អញ្ជើញសិស្សមកពីជុំវិញពិភពលោកឱ្យធ្វើការលើគម្រោងទាំងនេះ។ 

ក្នុងនាមជាអ្នកចូលរួមនៅក្នុង Google Summer of Code 2019 ខ្ញុំបានធ្វើគម្រោងមួយនៅក្នុងបណ្ណាល័យ សារាយ។ ជាមួយអង្គការ Haskell.orgដែលកំពុងអភិវឌ្ឍភាសា Haskell ដែលជាភាសាកម្មវិធីមុខងារដ៏ល្បីល្បាញបំផុតមួយ។ Alga គឺជាបណ្ណាល័យដែលតំណាង ប្រភេទសុវត្ថិភាព តំណាងសម្រាប់ក្រាហ្វនៅក្នុង Haskell ។ វាត្រូវបានគេប្រើឧទាហរណ៍ក្នុង ឆមាស - បណ្ណាល័យ Github ដែលបង្កើតដើមឈើអក្ខរាវិរុទ្ធ ក្រាហ្វការហៅទូរសព្ទ និងភាពអាស្រ័យដោយផ្អែកលើកូដ ហើយអាចប្រៀបធៀបវាបាន។ គម្រោងរបស់ខ្ញុំគឺដើម្បីបន្ថែមតំណាងសុវត្ថិភាពប្រភេទសម្រាប់ក្រាហ្វិកទ្វេភាគី និងក្បួនដោះស្រាយសម្រាប់ការតំណាងនោះ។ 

នៅក្នុងការប្រកាសនេះ ខ្ញុំនឹងនិយាយអំពីការអនុវត្តរបស់ខ្ញុំនៃក្បួនដោះស្រាយសម្រាប់ពិនិត្យមើលក្រាហ្វសម្រាប់ភាពទ្វេភាគីនៅក្នុង Haskell ។ ទោះបីជាក្បួនដោះស្រាយគឺជាផ្នែកមួយនៃមូលដ្ឋានបំផុតក៏ដោយ ប៉ុន្តែការអនុវត្តវាយ៉ាងស្រស់ស្អាតនៅក្នុងរចនាប័ទ្មមុខងារបានធ្វើឱ្យខ្ញុំធ្វើម្តងទៀតជាច្រើនដង និងទាមទារការងារច្រើន។ ជាលទ្ធផលខ្ញុំបានដោះស្រាយលើការអនុវត្តជាមួយ monad transformers ។ 

អំពីខ្លួនខ្ញុំ

ឈ្មោះរបស់ខ្ញុំគឺ Vasily Alferov ខ្ញុំជានិស្សិតឆ្នាំទី 4 នៅ St. Petersburg HSE ។ មុននេះនៅក្នុងប្លក់ខ្ញុំបានសរសេរ អំពីគម្រោងរបស់ខ្ញុំអំពីក្បួនដោះស្រាយប៉ារ៉ាម៉ែត្រ и អំពីការធ្វើដំណើរទៅ ZuriHac. ពេលនេះខ្ញុំកំពុងហាត់ការនៅ សាកលវិទ្យាល័យ Bergen នៅប្រទេសន័រវេស ជាកន្លែងដែលខ្ញុំកំពុងធ្វើការលើវិធីសាស្រ្តដោះស្រាយបញ្ហា បញ្ជីពណ៌. ចំណាប់អារម្មណ៍របស់ខ្ញុំរួមមានក្បួនដោះស្រាយប៉ារ៉ាម៉ែត្រ និងកម្មវិធីមុខងារ។

អំពីការអនុវត្តក្បួនដោះស្រាយ

បុព្វកថា

សិស្សានុសិស្សដែលចូលរួមក្នុងកម្មវិធីនេះត្រូវបានលើកទឹកចិត្តយ៉ាងខ្លាំងក្នុងការសរសេរប្លុក។ ពួកគេបានផ្តល់ឱ្យខ្ញុំនូវវេទិកាសម្រាប់ប្លុក រដូវក្តៅនៃ Haskell. អត្ថបទនេះគឺជាការបកប្រែ អត្ថបទសរសេរដោយខ្ញុំនៅទីនោះក្នុងខែកក្កដា ជាភាសាអង់គ្លេស ជាមួយនឹងបុព្វកថាខ្លី។ 

ទាញសំណើដោយប្រើលេខកូដនៅក្នុងសំណួរអាចរកបាន នៅទីនេះ.

អ្នកអាចអានអំពីលទ្ធផលនៃការងាររបស់ខ្ញុំ (ជាភាសាអង់គ្លេស) នៅទីនេះ.

ប្រកាសនេះសន្មត់ថាអ្នកអានបានស្គាល់គោលគំនិតជាមូលដ្ឋានក្នុងការសរសេរកម្មវិធីដែលមានមុខងារ ទោះបីជាខ្ញុំនឹងព្យាយាមរំលឹកឡើងវិញនូវពាក្យទាំងអស់ដែលបានប្រើនៅពេលដែលពេលវេលាមកដល់។

ពិនិត្យក្រាហ្វសម្រាប់ភាពទ្វេភាគី 

ក្បួនដោះស្រាយសម្រាប់ពិនិត្យមើលក្រាហ្វសម្រាប់ភាពទ្វេភាគីជាធម្មតាត្រូវបានផ្តល់ឱ្យនៅក្នុងវគ្គសិក្សាស្តីពីក្បួនដោះស្រាយដែលជាក្បួនដោះស្រាយក្រាហ្វដ៏សាមញ្ញបំផុតមួយ។ គំនិតរបស់គាត់គឺត្រង់៖ ដំបូងយើងដាក់ចំនុចកំពូលនៅក្នុងចំណែកខាងឆ្វេង ឬស្តាំ ហើយនៅពេលរកឃើញគែមដែលផ្ទុយគ្នា យើងអះអាងថាក្រាហ្វមិនមែនជាទ្វេភាគីទេ។

ព័ត៌មានលម្អិតបន្តិច៖ ដំបូងយើងដាក់ចំនុចកំពូលមួយចំនួននៅក្នុងការចែករំលែកខាងឆ្វេង។ ជាក់ស្តែង ប្រទេសជិតខាងទាំងអស់នៃចំនុចកំពូលនេះត្រូវតែដេកនៅក្នុង lobe ខាងស្តាំ។ ជាងនេះទៅទៀត អ្នកជិតខាង​ទាំងអស់​របស់​អ្នក​ជិតខាង​នៃ​ចំណុច​កំពូល​នេះ​ត្រូវ​ដេក​នៅ​ផ្នែក​ខាងឆ្វេង ហើយ​ដូច្នេះ​នៅលើ​។ យើងបន្តកំណត់ការចែករំលែកទៅចំនុចកំពូល ដរាបណានៅមានចំនុចកំពូលនៅក្នុងសមាសធាតុតភ្ជាប់នៃចំនុចកំពូលដែលយើងបានចាប់ផ្តើមជាមួយដែលយើងមិនបានកំណត់ឱ្យអ្នកជិតខាង។ បន្ទាប់មក យើងធ្វើសកម្មភាពនេះម្តងទៀតសម្រាប់សមាសធាតុដែលបានតភ្ជាប់ទាំងអស់។

ប្រសិនបើមានគែមរវាងចំនុចកំពូលដែលធ្លាក់ចូលទៅក្នុងភាគថាសដូចគ្នា វាមិនពិបាកក្នុងការស្វែងរកវដ្ដសេសក្នុងក្រាហ្វ ដែលត្រូវបានគេស្គាល់យ៉ាងទូលំទូលាយ (ហើយច្បាស់ណាស់) មិនអាចទៅរួចនៅក្នុងក្រាហ្វទ្វេភាគីនោះទេ។ បើមិនដូច្នោះទេយើងមានភាគថាសត្រឹមត្រូវដែលមានន័យថាក្រាហ្វគឺទ្វេភាគី។

ជាធម្មតា ក្បួនដោះស្រាយនេះត្រូវបានអនុវត្តដោយប្រើ ការស្វែងរកដំបូង ឬ ការស្វែងរកជម្រៅដំបូង. ជាភាសាចាំបាច់ ជាធម្មតាការស្វែងរកជម្រៅដំបូងត្រូវបានប្រើព្រោះវាសាមញ្ញជាងបន្តិច ហើយមិនត្រូវការរចនាសម្ព័ន្ធទិន្នន័យបន្ថែមទេ។ ខ្ញុំ​ក៏​បាន​ជ្រើសរើស​ការ​ស្វែងរក​ជម្រៅ​ដំបូង​ដែរ ព្រោះ​វា​ជា​ប្រពៃណី​ជាង។

ដូច្នេះយើងបានមកដល់គ្រោងការណ៍ខាងក្រោម។ យើងឆ្លងកាត់ចំនុចកំពូលនៃក្រាហ្វដោយប្រើការស្វែងរកជម្រៅដំបូង ហើយផ្តល់ការចែករំលែកដល់ពួកគេ ដោយផ្លាស់ប្តូរចំនួននៃការចែករំលែកនៅពេលយើងផ្លាស់ទីតាមគែម។ ប្រសិនបើយើងព្យាយាមកំណត់ការចែករំលែកទៅចំណុចកំពូលដែលមានចំណែកដែលបានកំណត់រួចហើយ យើងអាចនិយាយដោយសុវត្ថិភាពថាក្រាហ្វមិនមែនជាទ្វេភាគីទេ។ នៅពេលដែលចំនុចកំពូលទាំងអស់ត្រូវបានផ្តល់ចំណែក ហើយយើងបានមើលគែមទាំងអស់ យើងមានភាគថាសដ៏ល្អ។

ភាពបរិសុទ្ធនៃការគណនា

នៅក្នុង Haskell យើងសន្មតថាការគណនាទាំងអស់គឺ ស្អាត។ ទោះយ៉ាងណាក៏ដោយ ប្រសិនបើនេះជាករណីពិត យើងនឹងគ្មានវិធីបោះពុម្ពអ្វីលើអេក្រង់នោះទេ។ ទាំងអស់, ស្អាត ការគណនាគឺខ្ជិលណាស់ដែលមិនមានមួយ។ ស្អាត ហេតុផលដើម្បីគណនាអ្វីមួយ។ ការគណនាទាំងអស់ដែលកើតឡើងនៅក្នុងកម្មវិធីត្រូវបានបង្ខំដោយដូចម្ដេច "មិនស្អាត" Monad IO ។

Monads គឺជាវិធីមួយដើម្បីតំណាងឱ្យការគណនាជាមួយ ផលប៉ះពាល់ នៅ Haskell ។ ការពន្យល់ពីរបៀបដែលពួកគេធ្វើការគឺហួសពីវិសាលភាពនៃប្រកាសនេះ។ ការពិពណ៌នាល្អ និងច្បាស់លាស់អាចអានជាភាសាអង់គ្លេសបាន។ នៅទីនេះ.

នៅទីនេះខ្ញុំចង់ចង្អុលបង្ហាញថាខណៈពេលដែល monads មួយចំនួនដូចជា IO ត្រូវបានអនុវត្តតាមរយៈ compiler magic ស្ទើរតែទាំងអស់ផ្សេងទៀតត្រូវបានអនុវត្តនៅក្នុងកម្មវិធី ហើយការគណនាទាំងអស់នៅក្នុងវាគឺសុទ្ធ។

មានផលប៉ះពាល់ជាច្រើនហើយនីមួយៗមាន monad ផ្ទាល់ខ្លួន។ នេះគឺជាទ្រឹស្ដីដ៏រឹងមាំ និងស្រស់ស្អាត៖ monads ទាំងអស់អនុវត្តចំណុចប្រទាក់ដូចគ្នា។ យើង​នឹង​និយាយ​អំពី​ព្រះ​អង្គ​បី​អង្គ​ដូច​ខាង​ក្រោម៖

• ទាំង ea គឺជាការគណនាដែលត្រឡប់តម្លៃនៃប្រភេទ a ឬបោះករណីលើកលែងនៃប្រភេទ e ។ អាកប្បកិរិយារបស់ monad នេះគឺស្រដៀងគ្នាទៅនឹងការដោះស្រាយករណីលើកលែងនៅក្នុងភាសាចាំបាច់: កំហុសអាចត្រូវបានចាប់បានឬឆ្លងកាត់។ ភាពខុសគ្នាសំខាន់គឺថា monad ត្រូវបានអនុវត្តយ៉ាងពេញលេញនៅក្នុងបណ្ណាល័យស្តង់ដារនៅ Haskell ខណៈពេលដែលភាសាចាំបាច់ជាធម្មតាប្រើយន្តការប្រព័ន្ធប្រតិបត្តិការ។
• រដ្ឋ sa គឺជាការគណនាដែលត្រឡប់តម្លៃនៃប្រភេទ a និងមានសិទ្ធិចូលប្រើស្ថានភាពដែលអាចផ្លាស់ប្តូរបាននៃប្រភេទ s ។
• ប្រហែលជា ក. The May monad បង្ហាញពីការគណនាដែលអាចត្រូវបានរំខាននៅពេលណាមួយដោយត្រឡប់ Nothing ។ ទោះជាយ៉ាងណាក៏ដោយយើងនឹងនិយាយអំពីការអនុវត្តថ្នាក់ MonadPlus សម្រាប់ប្រភេទ Maybe ដែលបង្ហាញពីឥទ្ធិពលផ្ទុយគ្នា៖ វាគឺជាការគណនាដែលអាចត្រូវបានរំខាននៅពេលណាមួយដោយត្រឡប់តម្លៃជាក់លាក់មួយ។

ការអនុវត្តក្បួនដោះស្រាយ

យើងមានប្រភេទទិន្នន័យពីរគឺ Graph a និង Bigraph ab ដែលទីមួយតំណាងឱ្យក្រាហ្វដែលមានបន្ទាត់បញ្ឈរដែលមានស្លាកតម្លៃនៃប្រភេទ a និងទីពីរតំណាងឱ្យក្រាហ្វទ្វេភាគីជាមួយចំនុចកំពូលខាងឆ្វេងដែលមានស្លាកតម្លៃនៃប្រភេទ a និងខាងស្តាំ។ -side vertices ដែល​មាន​ស្លាក​តម្លៃ​នៃ​ប្រភេទ b ។

ទាំងនេះមិនមែនជាប្រភេទពីបណ្ណាល័យ Alga ទេ។ Alga មិនមានតំណាងសម្រាប់ក្រាហ្វទ្វេភាគីដែលមិនបានដឹកនាំទេ។ ខ្ញុំ​បាន​បង្កើត​ប្រភេទ​នេះ​សម្រាប់​ភាព​ច្បាស់​លាស់។

យើងក៏នឹងត្រូវការមុខងារជំនួយដែលមានហត្ថលេខាដូចខាងក្រោម៖

-- Список соседей данной вершины.
neighbours :: Ord a => a -> Graph a -> [a]

-- Построить двудольный граф по графу и функции, для каждой вершины
-- выдающей её долю и пометку в новой доле, игнорируя конфликтные рёбра.
toBipartiteWith :: (Ord a, Ord b, Ord c) => (a -> Either b c)
                                         -> Graph a
                                         -> Bigraph b c

-- Список вершин в графе
vertexList :: Ord a => Graph a -> [a]
Сигнатура функции, которую мы будем писать, выглядит так:

type OddCycle a = [a]
detectParts :: Ord a => Graph a -> Either (OddCycle a) (Bigraph a a)

វាជាការងាយស្រួលក្នុងការមើលឃើញថា ប្រសិនបើក្នុងអំឡុងពេលស្វែងរកជម្រៅដំបូង យើងបានរកឃើញគែមដែលផ្ទុយគ្នានោះ វដ្តសេសស្ថិតនៅលើកំពូលនៃជង់ការហៅឡើងវិញ។ ដូច្នេះ ដើម្បីស្ដារវាឡើងវិញ យើងត្រូវកាត់ផ្តាច់អ្វីៗទាំងអស់ចេញពីការប្រមូលឡើងវិញ រហូតដល់ការកើតឡើងដំបូងនៃចំណុចចុងក្រោយ។

យើងអនុវត្តការស្វែងរកជម្រៅដំបូងដោយរក្សាអារេពាក់ព័ន្ធនៃលេខចែករំលែកសម្រាប់ចំណុចនីមួយៗ។ ជង់ recursion នឹងត្រូវបានរក្សាទុកដោយស្វ័យប្រវត្តិតាមរយៈការអនុវត្តនៃថ្នាក់ Functor នៃ monad ដែលយើងបានជ្រើសរើស: យើងនឹងគ្រាន់តែត្រូវការដាក់បញ្ឈរទាំងអស់ពីផ្លូវចូលទៅក្នុងលទ្ធផលដែលត្រឡប់ពីមុខងារ recursive ។

គំនិតដំបូងរបស់ខ្ញុំគឺប្រើ Either monad ដែលហាក់ដូចជាអនុវត្តយ៉ាងពិតប្រាកដនូវផលប៉ះពាល់ដែលយើងត្រូវការ។ ការអនុវត្តដំបូងដែលខ្ញុំបានសរសេរគឺជិតស្និទ្ធនឹងជម្រើសនេះ។ តាមពិតទៅ ខ្ញុំមានការអនុវត្តប្រាំផ្សេងគ្នានៅចំណុចមួយ ហើយនៅទីបំផុតបានដោះស្រាយលើមួយទៀត។

ជាដំបូង យើងត្រូវរក្សាអារេសហការនៃការកំណត់អត្តសញ្ញាណចែករំលែក - នេះគឺជាអ្វីមួយអំពីរដ្ឋ។ ទីពីរ យើងត្រូវតែអាចបញ្ឈប់នៅពេលដែលមានជម្លោះត្រូវបានរកឃើញ។ នេះអាចជា Monad for Either ឬ MonadPlus for Maybe។ ភាពខុសគ្នាចំបងគឺថា ទាំងអាចត្រឡប់តម្លៃមួយ ប្រសិនបើការគណនាមិនទាន់ត្រូវបានបញ្ឈប់ ហើយប្រហែលជាត្រឡប់តែព័ត៌មានអំពីរឿងនេះក្នុងករណីនេះប៉ុណ្ណោះ។ ដោយ​សារ​យើង​មិន​ត្រូវ​ការ​តម្លៃ​ដាច់​ដោយ​ឡែក​សម្រាប់​ភាព​ជោគជ័យ (វា​ត្រូវ​បាន​រក្សា​ទុក​រួច​ហើយ​ក្នុង​រដ្ឋ) យើង​ជ្រើស​រើស​ប្រហែល។ ហើយ​នៅ​ពេល​ដែល​យើង​ត្រូវ​ការ​រួម​បញ្ចូល​ឥទ្ធិពល​នៃ monads ពីរ​វា​ចេញ​មក​ ឧបករណ៍បំលែង monadដែលរួមបញ្ចូលគ្នាយ៉ាងជាក់លាក់នូវផលប៉ះពាល់ទាំងនេះ។

ហេតុអ្វីបានជាខ្ញុំជ្រើសរើសប្រភេទស្មុគស្មាញបែបនេះ? ហេតុផលពីរ។ ទីមួយ ការអនុវត្តប្រែជាស្រដៀងនឹងការចាំបាច់។ ទីពីរ យើងត្រូវរៀបចំតម្លៃត្រឡប់មកវិញក្នុងករណីមានជម្លោះនៅពេលត្រលប់មកវិញពីការហៅឡើងវិញដើម្បីស្ដាររង្វិលជុំសេស ដែលកាន់តែងាយស្រួលធ្វើនៅក្នុង Maybe monad។

ដូច្នេះយើងទទួលបានការអនុវត្តនេះ។

{-# LANGUAGE ExplicitForAll #-}
{-# LANGUAGE ScopedTypeVariables #-}

data Part = LeftPart | RightPart

otherPart :: Part -> Part
otherPart LeftPart  = RightPart
otherPart RightPart = LeftPart

type PartMap a = Map.Map a Part
type OddCycle a = [a]

toEither :: Ord a => PartMap a -> a -> Either a a
toEither m v = case fromJust (v `Map.lookup` m) of
                    LeftPart  -> Left  v
                    RightPart -> Right v

type PartMonad a = MaybeT (State (PartMap a)) [a]

detectParts :: forall a. Ord a => Graph a -> Either (OddCycle a) (Bigraph a a)
detectParts g = case runState (runMaybeT dfs) Map.empty of
                     (Just c, _)  -> Left  $ oddCycle c
                     (Nothing, m) -> Right $ toBipartiteWith (toEither m) g
    where
        inVertex :: Part -> a -> PartMonad a
        inVertex p v = ((:) v) <$> do modify $ Map.insert v p
                                      let q = otherPart p
                                      msum [ onEdge q u | u <- neigbours v g ]

        {-# INLINE onEdge #-}
        onEdge :: Part -> a -> PartMonad a
        onEdge p v = do m <- get
                        case v `Map.lookup` m of
                             Nothing -> inVertex p v
                             Just q  -> do guard (q /= p)
                                           return [v]

        processVertex :: a -> PartMonad a
        processVertex v = do m <- get
                             guard (v `Map.notMember` m)
                             inVertex LeftPart v

        dfs :: PartMonad a
        dfs = msum [ processVertex v | v <- vertexList g ]

        oddCycle :: [a] -> [a]
        oddCycle c = tail (dropWhile ((/=) last c) c)

កន្លែងដែលប្លុកគឺជាស្នូលនៃក្បួនដោះស្រាយ។ ខ្ញុំនឹងព្យាយាមពន្យល់ពីអ្វីដែលកំពុងកើតឡើងនៅក្នុងវា។

• inVertex គឺជាផ្នែកមួយនៃការស្វែងរកជំរៅដំបូង ដែលយើងចូលទៅកាន់ vertex ជាលើកដំបូង។ នៅទីនេះយើងកំណត់លេខចែករំលែកទៅ vertex ហើយដំណើរការ onEdge នៅលើអ្នកជិតខាងទាំងអស់។ នេះក៏ជាកន្លែងដែលយើងស្ដារជង់ការហៅផងដែរ៖ ប្រសិនបើ msum ត្រឡប់តម្លៃមួយ យើងរុញ vertex v នៅទីនោះ។
• onEdge គឺជាផ្នែកដែលយើងទស្សនាគែម។ វាត្រូវបានគេហៅថាពីរដងសម្រាប់គែមនីមួយៗ។ នៅទីនេះយើងពិនិត្យមើលថាតើ vertex នៅម្ខាងទៀតត្រូវបានទៅទស្សនាហើយឬអត់ ហើយទៅមើលវាប្រសិនបើមិនបាន។ ប្រសិនបើ​បាន​ចូល​ទស្សនា យើង​ពិនិត្យ​មើល​ថា​តើ​គែម​មាន​ជម្លោះ​ឬ​អត់។ ប្រសិនបើវាជា យើងត្រឡប់តម្លៃវិញ - កំពូលនៃជង់ការហៅឡើងវិញ ដែលចំណុចកំពូលផ្សេងទៀតទាំងអស់នឹងត្រូវបានដាក់នៅពេលត្រឡប់មកវិញ។
• processVertex ពិនិត្យរកចំនុចកំពូលនីមួយៗថាតើវាត្រូវបានចូលមើល ហើយដំណើរការនៅក្នុងVertex លើវាឬអត់។
• dfs ដំណើរការ processVertex នៅលើកំពូលទាំងអស់។

អស់ហើយ។

ប្រវត្តិនៃពាក្យ INLINE

ពាក្យ INLINE មិន​មែន​នៅ​ក្នុង​ការ​អនុវត្ត​ដំបូង​នៃ​ក្បួន​ដោះស្រាយ​នោះ​ទេ វា​បាន​បង្ហាញ​នៅ​ពេល​ក្រោយ។ នៅពេលដែលខ្ញុំព្យាយាមស្វែងរកការអនុវត្តដែលប្រសើរជាងនេះ ខ្ញុំបានរកឃើញថាកំណែដែលមិនមែនជា INLINE មានភាពយឺតយ៉ាវគួរឱ្យកត់សម្គាល់នៅលើក្រាហ្វមួយចំនួន។ ដោយពិចារណាថាមុខងារ semantically គួរតែដំណើរការដូចគ្នា នេះធ្វើឱ្យខ្ញុំភ្ញាក់ផ្អើលយ៉ាងខ្លាំង។ សូម្បីតែមនុស្សចម្លែកក៏ដោយ នៅលើម៉ាស៊ីនមួយផ្សេងទៀតដែលមានកំណែខុសគ្នានៃ GHC មិនមានភាពខុសគ្នាគួរឱ្យកត់សម្គាល់នោះទេ។

បន្ទាប់ពីចំណាយពេលមួយសប្តាហ៍អានលទ្ធផល GHC Core ខ្ញុំអាចដោះស្រាយបញ្ហាជាមួយនឹងបន្ទាត់ជាក់លាក់មួយ INLINE ។ នៅចំណុចមួយចំនួនរវាង GHC 8.4.4 និង GHC 8.6.5 កម្មវិធីបង្កើនប្រសិទ្ធភាពបានឈប់ធ្វើវាដោយខ្លួនឯង។

ខ្ញុំមិនរំពឹងថានឹងជួបប្រទះភាពកខ្វក់បែបនេះនៅក្នុងកម្មវិធី Haskell នោះទេ។ ទោះយ៉ាងណាក៏ដោយ សូម្បីតែសព្វថ្ងៃនេះ អ្នកបង្កើនប្រសិទ្ធភាពពេលខ្លះមានកំហុស ហើយវាជាការងាររបស់យើងក្នុងការផ្តល់ការណែនាំដល់ពួកគេ។ ជាឧទាហរណ៍ នៅទីនេះយើងដឹងថាមុខងារគួរតែត្រូវបានដាក់ក្នុងជួរ ព្រោះវាត្រូវបានដាក់បញ្ចូលក្នុងកំណែចាំបាច់ ហើយនេះជាហេតុផលដើម្បីផ្តល់ការណែនាំដល់អ្នកចងក្រង។

តើមានអ្វីកើតឡើងបន្ទាប់?

បន្ទាប់មកខ្ញុំបានអនុវត្តក្បួនដោះស្រាយ Hopcroft-Karp ជាមួយ monads ផ្សេងទៀត ហើយនោះជាចុងបញ្ចប់នៃកម្មវិធី។

សូមអរគុណដល់ Google Summer of Code ខ្ញុំទទួលបានបទពិសោធន៍ជាក់ស្តែងក្នុងការសរសេរកម្មវិធីមុខងារ ដែលមិនត្រឹមតែជួយខ្ញុំឱ្យទទួលបានកម្មសិក្សានៅ Jane Street នៅរដូវក្តៅបន្ទាប់ទេ (ខ្ញុំមិនប្រាកដថាកន្លែងនេះល្បីប៉ុណ្ណាទេ សូម្បីតែអ្នកទស្សនាដែលមានចំណេះដឹងរបស់ Habr ប៉ុន្តែវាជាកន្លែងមួយ ក្នុងចំណោមកន្លែងមួយចំនួនដែលអ្នកអាចចូលរួមកម្មវិធីដែលមានមុខងារក្នុងរដូវក្តៅ) ប៉ុន្តែក៏បានណែនាំខ្ញុំទៅកាន់ពិភពដ៏អស្ចារ្យនៃការអនុវត្តគំរូនេះក្នុងការអនុវត្ត ដែលខុសពីបទពិសោធន៍របស់ខ្ញុំជាភាសាប្រពៃណី។

ប្រភព: www.habr.com