हाफ रिंग्स की कहानी

नमस्कार, हेब्र! मैं आपके ध्यान में लुका जैकबोवित्ज के लेख "ए स्टोरी ऑन सेमरिंग्स" का अनुवाद करता हूं।

कभी आपने सोचा है कि प्रकारों के योग को प्रकारों का योग क्यों कहा जाता है। या शायद आप हमेशा यह जानना चाहते थे कि <*> ऑपरेटर इस तरह से क्यों लिखा जाता है? और आधे छल्ले के साथ इसका क्या करना है? इच्छुक कृपया एक कट के लिए पूछें!

यह लेख ल्यूक जकोबोविच के टाइपलेवेल ब्लॉग पोस्ट का अनुवाद है । इसकी सबसे अच्छी धारणा के लिए, कम से कम स्काला भाषा और इसके पारिस्थितिकी तंत्र (बिल्लियों की लाइब्रेरी सहित) के साथ एक सतही परिचितता की आवश्यकता है और अमूर्त बीजगणित की बुनियादी अवधारणाओं का ज्ञान: एक अर्धवृत्त, एक मोनॉयड, आदि।

बीजगणितीय संरचनाएँ

हम में से बहुत से लोग मोनोइड्स और सेमिनग्रुप के बारे में जानते हैं और यहां तक ​​कि उनका उपयोग भी करते हैं। इन संरचनाओं में ऐसे गुण होते हैं जो आपको उच्च स्तर की अमूर्तता प्राप्त करने के लिए सीधे उन्हें लागू करने की अनुमति देते हैं (यदि आप उनके बारे में नहीं जानते हैं, तो आप बिल्लियों के पुस्तकालय से प्रलेखन पढ़ सकते हैं)। हालांकि, कभी-कभी एक डेटा प्रकार में एक से अधिक मोनोइड या सेमीग्रुप होते हैं। एक स्पष्ट उदाहरण विभिन्न संख्यात्मक प्रकार हैं, जहां गुणन और जोड़ दो पूर्ण मोनॉयड बनते हैं।

अमूर्त बीजगणित में, एक निश्चित तरीके से बातचीत करने वाले दो मोनोइड्स के साथ संरचनाओं का एक अलग वर्ग होता है। यह क्लास हाफ रिंग्स है। चूँकि अक्सर न्यूमेरिकल प्रकारों का वर्णन करने के लिए मोनोइड्स का उपयोग किया जाता है, इसलिए उन्हें आमतौर पर गुणात्मक और योगात्मक में विभाजित किया जाता है। जैसा कि संख्याओं के मामले में, एक संगोष्ठी के नियम यह निर्धारित करते हैं कि गुणन इसके अलावा वितरण है, और इसके अलावा एकता द्वारा किसी भी संख्या का गुणन - शून्य - शून्य देता है।

इसे प्रस्तुत करने के विभिन्न तरीके हैं जैसे कि टाइप कक्षाएं और विभिन्न पुस्तकालय इसे अपने तरीके से करते हैं, लेकिन आइए देखें कि यह बीजगणित परियोजना में कैसे किया जाता है। इसमें आधार AdditiveSemigroup और MultiplicativeSemigroup ।

[ नोट: चूंकि "प्रकार वर्ग" नाम रूसी में मूल नहीं है, इसलिए इसके अंग्रेजी संस्करण का उपयोग बाद में किया जाएगा - प्रकार वर्ग ]

 import simulacrum._ @typeclass trait AdditiveSemigroup[A] { def +(x: A)(y: A): A } @typeclass trait AdditiveMonoid[A] extends AdditiveSemigroup[A] { def zero: A } @typeclass trait MultiplicativeSemigroup[A] { def *(x: A)(y: A): A } @typeclass trait MultiplicativeMonoid[A] extends MultiplicativeSemigroup[A] { def one: A } 

[ नोट: simulacrum परियोजना से @typeclass एनोटेशन आपको स्वचालित रूप से टाइप कक्षाओं के लिए अक्सर उपयोग किए जाने वाले तरीकों को उत्पन्न करने की अनुमति देता है और कोड के तार्किक घटक को प्रभावित नहीं करता है ]

इस मामले में, Semiring ( Semiring ) एक एडिटिव Semiring ( AdditiveMonoid ) है, जो कि Semiring ( MultiplicativeMonoid ) के साथ संयुक्त है और निम्नलिखित अतिरिक्त कानूनों से सुसज्जित है:

1. योजक कम्यूटिटी: $$$x + y = y + x$
2. दाईं ओर वितरण: $$$(x + y) \ गुना z = (x \ टाइम्स z) + (y \ टाइम्स z)$
3. बाईं ओर वितरण: $$$x \ गुना (y + z) = (x \ times y) + (x \ times z)$
4. दाईं ओर शून्य की उपस्थिति: $$$x \ गुना शून्य = शून्य$
5. बाईं ओर शून्य की उपस्थिति: $$$शून्य \ गुना x = शून्य$

प्रकार वर्ग के संगत सेमिनार को सेट करने के लिए, AdditiveMonoid और MultiplicativeMonoid संयोजित करें:

 @typeclass trait Semiring[A] extends MultiplicativeMonoid[A] with AdditiveMonoid[A] 

अब हमारे पास Semiring , हम इसे विभिन्न संख्यात्मक प्रकारों के साथ उपयोग कर सकते हैं: Int , Long , BigDecimal , आदि, लेकिन क्या यह वास्तव में आधे छल्ले के बारे में पूरे लेख के लायक है? यह पता चला है कि कई अन्य चीजें भी आधे छल्ले हैं, जिनमें तार्किक मूल्य, सेट और यहां तक ​​कि एनिमेशन भी शामिल हैं।

मैं यह नोट करना चाहूंगा कि इन प्रकारों के संभावित प्रतिनिधियों की कुल संख्या में कई प्रकारों से एक अर्ध-रिंग होमोमोर्फिज्म बनाना संभव है। इसका क्या मतलब है? ठीक है, धैर्य रखें और मैं समझाने का प्रयास करूंगा कि मेरा क्या मतलब है।

कार्डिनल नंबर

आइए इसकी शुरुआत करें जो आम तौर पर कार्डिनल नंबर से होती है। प्रत्येक प्रकार उन मानों की संख्या से मेल खाता है जो इस प्रकार के प्रतिनिधि ले सकते हैं। उदाहरण के लिए, Boolean प्रकार का कार्डिनल नंबर होता है $$$2$ क्योंकि इसके केवल दो संभावित मूल्य हैं: true और false ।

तो, Boolean - $$$2$ , लेकिन कितने अन्य प्रकार? Byte - $$$2 ^ 8$ , Short - $$$2 ^ {16}$ Int - $$$2 ^ {32}$ और Long $$$2 ^ {64}$ । तार के बारे में क्या? String एक औपचारिक रूप से असीमित प्रकार है और सैद्धांतिक रूप से मूल्यों की एक अनंत संख्या है (व्यवहार में, निश्चित रूप से, हमारे पास अनंत स्मृति नहीं है, इसलिए विशिष्ट संख्या कंप्यूटर के कॉन्फ़िगरेशन पर निर्भर करेगी)।

किस प्रकार के लिए हम उनकी कार्डिनल संख्या निर्धारित कर सकते हैं? दो बिल्कुल सरल उदाहरण: Unit , जिसमें बिल्कुल एक प्रतिनिधि है, और Nothing , जो स्काला में सभी संभावित प्रकारों की निचली सीमा है और तदनुसार है $$$0$ संभव मान। यही है, आप कभी Nothing मान सकते हैं, जो कार्डिनल संख्या से मेल खाती है $$$0$ ।

महान, अब आप इसे कोड में व्यक्त करने का प्रयास कर सकते हैं। हम एक प्रकार का वर्ग बना सकते हैं जो हमें संबंधित प्रकार के मूल्यों की कुल संख्या दे सकता है।

 trait Cardinality[A] { def cardinality: BigInt } object Cardinality { def of[A: Cardinality]: BigInt = apply[A].cardinality def apply[A: Cardinality]: Cardinality[A] = implicitly } 

अब इस वर्ग के कई उदाहरण बनाने की कोशिश करें:

 implicit def booleanCardinality = new Cardinality[Boolean] { def cardinality: BigInt = BigInt(2) } implicit def longCardinality = new Cardinality[Long] { def cardinality: BigInt = BigInt(2).pow(64) } implicit def intCardinality = new Cardinality[Int] { def cardinality: BigInt = BigInt(2).pow(32) } implicit def shortCardinality = new Cardinality[Short] { def cardinality: BigInt = BigInt(2).pow(16) } implicit def byteCardinality = new Cardinality[Byte] { def cardinality: BigInt = BigInt(2).pow(8) } implicit def unitCardinality = new Cardinality[Unit] { def cardinality: BigInt = 1 } implicit def nothingCardinality = new Cardinality[Nothing] { def cardinality: BigInt = 0 } 

[ नोट: दिए गए मूल्यों को भी implicit val रूप में घोषित किया जा सकता है ]

आइए, REPL में उन्हें आज़माएँ:

 scala> Cardinality.of[Int] res11: BigInt = 4294967296 scala> Cardinality.of[Unit] res12: BigInt = 1 scala> Cardinality.of[Long] res13: BigInt = 18446744073709551616 

महान, लेकिन यह सब बहुत सरल है, एडीटी के बारे में क्या? क्या हम उन्हें इस तरह से संभाल सकते हैं? यह पता चला है कि हम कर सकते हैं, हमें बस यह समझने की जरूरत है कि सरलतम प्रकार और प्रकार के उत्पादों को कैसे संभालना है। आरंभ करने के लिए, सबसे सरल प्रकार के उत्पाद पर विचार करें: (Boolean, Byte)

इस प्रकार के कितने प्रतिनिधि हैं? हम जानते हैं कि Boolean उनके Boolean है $$$2$ और Byte $$$256$ । इस प्रकार, से संख्या $$$-128$ को $$$127$ true या false के साथ संयुक्त। यह पता चला है $$$512$ अद्वितीय मूल्य।

$$$512$ जैसा दिखता है $$$256$ से गुणा $$$2$ , इसलिए हो सकता है कि आपको पहले प्रकार के मूल्यों की संख्या को दूसरे के मूल्यों की संख्या से गुणा करने की आवश्यकता हो? यदि आप बाकी उदाहरणों के साथ इसकी जांच करते हैं, तो सुनिश्चित करें कि यह सच है। आइए इसे एक प्रकार की श्रेणी के उदाहरण के रूप में देखें:

 implicit def tupleCardinality[A: Cardinality, B: Cardinality] = new Cardinality[(A, B)] { def cardinality: BigInt = Cardinality[A].cardinality * Cardinality[B].cardinality } 

अब एक प्रकार के उदाहरण पर विचार करें: Either[Boolean, Byte] । इस मामले में, उत्तर और भी स्पष्ट है, क्योंकि इस प्रकार का मूल्य (वास्तव में) Boolean या Byte हो सकता है, इसलिए यह कार्डिनल संख्याओं को जोड़ने के लिए पर्याप्त है। तो Either[Boolean, Byte ] होना चाहिए $$$256 + 2 = $ 25$ प्रतिनिधि।

आइए इसे कोड में उसी तरह व्यक्त करते हैं और REPL में परिणामों की पुष्टि करते हैं:

 implicit def eitherCardinality[A: Cardinality, B: Cardinality] = new Cardinality[Either[A, B]] { def cardinality: BigInt = Cardinality[A].cardinality + Cardinality[B].cardinality } scala> Cardinality.of[(Boolean, Byte)] res14: BigInt = 512 scala> Cardinality.of[Either[Boolean, Byte]] res15: BigInt = 258 scala> Cardinality.of[Either[Int, (Boolean, Unit)]] res16: BigInt = 4294967298 

नतीजतन, कार्डिनल संख्याओं के प्रकारों के योग के लिए, और उत्पाद के लिए उन्हें गुणा किया जाता है। यह तर्कसंगत है उनके नाम दिए गए।

तो होमोर्फिज्म के बारे में पहले क्या चर्चा हुई? एक समरूपता एक संरचना-संरक्षण मानचित्रण है जो एक ही प्रकार के दो बीजगणितीय संरचनाओं के बीच होता है (इस मामले में, अर्धसूत्रीविभाजन)।

इसका मतलब है कि किसी के लिए भी $$$x$ । $$$य$ और समलैंगिकता $$$च$ हमारे पास है:

1. $$$f (x \ टाइम्स y) = f (x) \ गुना f (y)$
2. $$$f (x + y) = f (x) + f (y)$

बाद के भाव काफी सारगर्भित लग सकते हैं, लेकिन वे सीधे तौर पर इस बात से जुड़े हैं कि हमने क्या किया। यदि हम दो प्रकार के Byte और Boolean को जोड़ते हैं, तो हम Either[Byte, Boolean] , और अगर हम कार्डिनैलिटी होमोमोर्फिज्म को इसके लिए लागू करते हैं, तो हम प्राप्त करते हैं $$$258$ । यह Byte और Boolean लिए Byte को अलग-अलग लागू करने के बराबर है, इसके बाद परिणाम जोड़ते हैं।

बेशक, एक ही प्रकार के गुणन और उत्पाद पर लागू होता है। फिर भी, सही आधा रिंग के लिए हमारे पास अभी भी कुछ कमी है, क्योंकि हमने केवल जोड़ और गुणा का उल्लेख किया है, लेकिन संबंधित व्यक्तिगत तत्वों का नहीं।

जैसा कि हमने पहले ही देखा है, टाइप Unit एक प्रतिनिधि होता है, और टाइप Nothing नहीं होता है। क्या हम इन दो प्रकारों का उपयोग करके आधा रिंग बना सकते हैं?

चलो कोशिश करो! यदि Unit गुणन की एक इकाई है, तो इकाई के साथ किसी भी प्रकार का उत्पाद पहले प्रकार के बराबर होना चाहिए। स्वाभाविक रूप से, यह किया जाता है, क्योंकि हम बिना डिस्चार्ज (Int, Unit) से Int और इसके विपरीत नुकसान के लिए आसानी से कुछ मैप कर सकते हैं, ताकि कार्डिनल नंबर अपरिवर्तित रहे।

 scala> Cardinality.of[Int] res17: BigInt = 4294967296 scala> Cardinality.of[(Unit, Int)] res18: BigInt = 4294967296 scala> Cardinality.of[(Unit, (Unit, Int))] res19: BigInt = 4294967296 

Nothing बारे में क्या? चूंकि यह एक अतिरिक्त इकाई है, Nothing साथ किसी भी प्रकार का योग एक ही प्रकार के बराबर होना चाहिए। Either[Nothing, A] मैच A ? हाँ! चूंकि Nothing भी कोई मतलब नहीं है, Either[Nothing, A] केवल Right हो सकता है और, परिणामस्वरूप, केवल A , इसलिए ये प्रकार समतुल्य हैं।

हमें गुणा द्वारा शून्य की शुद्धता की जांच करने की भी आवश्यकता है: zero को जोड़कर एकता द्वारा गुणा की गई किसी भी संख्या को zero मेल खाना चाहिए। चूँकि Nothing भी हमारी अतिरिक्त इकाई Nothing है, इसलिए (Int, Nothing) जैसे प्रकारों का एक उत्पाद (Int, Nothing) बराबर होना चाहिए। ऐसा इसलिए किया जाता है क्योंकि हम Nothing प्रकार का मान नहीं बना सकते हैं, और परिणामस्वरूप, इस तरह के मूल्य से युक्त एक ट्यूपल है।

आइए देखें कि यह कार्डिनल संख्याओं से कैसे संबंधित है।

इसके अलावा की इकाई:

 scala> Cardinality.of[Either[Nothing, Boolean]] res0: BigInt = 2 scala> Cardinality.of[Either[Nothing, (Byte, Boolean)]] res1: BigInt = 258 

शून्य द्वारा अवशोषण:

 scala> Cardinality.of[(Nothing, Boolean)] res0: BigInt = 0 scala> Cardinality.of[(Nothing, Long)] res1: BigInt = 0 

यह वितरण को सत्यापित करने के लिए बनी हुई है। प्रकारों के संदर्भ में, इसका मतलब यह है कि (A, Either[B, C]) को Either[(A, B), (A, C)] मेल खाना चाहिए। यदि आप जांच करते हैं, तो ये दो प्रकार वास्तव में समकक्ष होंगे।

 scala> Cardinality.of[(Boolean, Either[Byte, Short])] res20: BigInt = 131584 scala> Cardinality.of[Either[(Boolean, Byte), (Boolean, Short)]] res21: BigInt = 131584 

उच्च क्रम की बीजगणितीय संरचनाएं

कुछ ने पहले से ही Semigroupal टाइप क्लास के बारे में सुना होगा। लेकिन ऐसा क्यों कहा जाता है और यह Semigroup से कैसे संबंधित है? आरंभ करने के लिए, आइए Semigroupal ही नज़र Semigroupal हैं:

 @typeclass trait Semigroupal[F[_]] { def product[A, B](fa: F[A], fb: F[B]): F[(A, B)] } 

Semigroup साथ एक निश्चित समानता है: दो मान संयुक्त हैं, और इसी ऑपरेशन को एसोसिएटिव होना चाहिए ( Semigroup समान)।

अब तक, इतना अच्छा है, लेकिन फ़ंक्शन नाम product थोड़ा भ्रमित है। यह तर्कसंगत है, क्योंकि हम A और B को एक टपल में मिलाते हैं, जो कि प्रकारों का एक उत्पाद है, लेकिन अगर हम उत्पाद का उपयोग करते हैं, तो शायद यह एक मनमाना Semigroupal , लेकिन गुणक है? इसका नाम बदल देते हैं।

 @typeclass trait MultiplicativeSemigroupal[F[_]] { def product[A, B](fa: F[A], fb: F[B]): F[(A, B)] } 

अब देखते हैं कि Semigroupal क्या Semigroupal सकता है। स्वाभाविक रूप से, हम सभी को बदलने के लिए राशि के लिए एक उत्पाद है:

 @typeclass trait AdditiveSemigroupal[F[_]] { def sum[A, B](fa: F[A], fb: F[B]): F[Either[A, B]] } 

यह अच्छा लग रहा है - क्या हम Monoidal प्राप्त करने के लिए इकाइयों को जोड़ सकते हैं? बेशक हम कर सकते हैं! यह फिर से सम एण्‍ड प्रोडक्‍ट के लिए Nothing एंड Unit होगा:

 @typeclass trait AdditiveMonoidal[F[_]] extends AdditiveSemigroupal[F] { def nothing: F[Nothing] } @typeclass trait MultiplicativeMonoidal[F[_]] extends MultiplicativeSemigroupal[F] { def unit: F[Unit] } 

अब हमारे पास इन प्रकार की कक्षाएं हैं, लेकिन हम उनका उपयोग कैसे कर सकते हैं? खैर, मैं विश्वासपूर्वक घोषणा करता हूं कि वे पहले से ही बिल्लियों के पुस्तकालय में उपयोग किए जाते हैं, लेकिन विभिन्न नामों के तहत।

संभवतः इन वर्गों की तरह क्या हो सकता है? आरंभ करने के लिए, sum फ़ंक्शन पर एक नज़र डालें और AdditiveSemigroupal समान कुछ खोजने का प्रयास करें। चूंकि निचले क्रम के प्रकारों के लिए इन वर्गों के एनालॉग्स में संबंधित प्रतीकात्मक ऑपरेटर होते हैं, इसलिए ऐसे ऑपरेटर को AdditiveSemigroupal जोड़ें।

चूंकि यह एक राशि है, इस ऑपरेटर को सबसे अधिक संभावना + होनी चाहिए और यह इंगित करना चाहिए कि ऑपरेशन किसी संदर्भ में किया जा रहा है। यह [+] जैसे कुछ का उपयोग करने के लिए आदर्श होगा, लेकिन यह एक अमान्य पहचानकर्ता है, इसलिए इसके बजाय <+> प्रयास करें।

 def <+>[A, B](fa: F[A], fb: F[B]): F[Either[A, B]] 

<+> फ़ंक्शन पहले से ही combineK लिए एक उपनाम के रूप में बिल्लियों में मौजूद है, जो SemigroupK में पाया जा सकता है, लेकिन यह अलग तरह से व्यवहार करता है। इनपुट में यह दो F[A] लेता है और F[A] लौटाता है - बिल्कुल वैसा नहीं जैसा हमारे पास है।

या समान? वास्तव में, ये दो कार्य मेल खाते हैं और हम एक फ़नकार की उपस्थिति में एक दूसरे के माध्यम से परिभाषित कर सकते हैं:

 def sum[A, B](fa: F[A], fb: F[B]): F[Either[A, B]] def combineK[A](x: F[A], y: F[A]): F[A] = { val feaa: F[Either[A, A]] = sum(x, y) feaa.map(_.merge) } 

चूंकि AdditiveSemigroupal SemigroupK बराबर है, क्या यह संभव है कि AdditiveMonoidal MonoidK AdditiveMonoidal समान हो? हां, और यह दिखाना आसान है। MonoidK empty समारोह द्वारा पूरक है:

 def empty[A]: F[A] 

यह फ़ंक्शन A लिए एक सार्वभौमिक क्वांटिफायर का उपयोग करता है, अर्थात, यह किसी भी A लिए काम करता है, जिसका अर्थ है कि वास्तव में यह किसी विशिष्ट A पर काम नहीं कर सकता है और इस प्रकार AdditiveMonoidal में F[Nothing] बराबर है।

खैर, हमने एडिटिव क्लासेज के लिए एनालॉग्स पाए और पहले से ही जानते हैं कि MultiplicativeSemigroupal cats.Semigroupal बराबर है। cats.Semigroupal । हमारे लिए जो कुछ भी रहता है वह है MultiplicativeMonoidal के समकक्ष खोजना।

मैं थोड़ा धोखा देता हूं और कहता हूं कि यह समकक्ष लागू है। यह एक pure फ़ंक्शन जोड़ता है जो A लेता है और F[A] । MultiplicativeMonoidal बदले में, एक unit फ़ंक्शन है जो कोई पैरामीटर नहीं लेता है और F[Unit] । एक से दूसरे में कैसे जाएं? जवाब फिर से एक फफूंद का उपयोग कर निकलता है:

 def unit: F[Unit] def pure(a: A): F[A] = unit.map(_ => a) 

आवेदक सहसंयोजक का उपयोग करता है, लेकिन सामान्य मामले में, हम भी अवायवीय और कंट्रावेरेंट संरचनाओं का उपयोग कर सकते हैं। इसके अलावा, एप्टीट्यूट में product और map के संयोजन के लिए एक उपनाम के रूप में <*> शामिल है, जो एक और सुराग की तरह दिखता है कि यह एक गुणक वर्ग है और अंतर्ज्ञान हमें असफल नहीं हुआ है।

अब बिल्लियों में हमारे पास <+> और <*> , लेकिन क्या एक प्रकार का वर्ग है जो उन्हें जोड़ती है, Semiring कैसे + और * को जोड़ती है? हां, और इसे Alternative कहा जाता है। यह MonoidK और MonoidK से विरासत में मिला है। सुसंगत होने के लिए, हम इसे Semiringal :

 @typeclass trait Semiringal[F[_]] extends MultiplicativeMonoidal[F] with AdditiveMonoidal[F] 

महान, अब हमारे पास उच्च क्रम प्रकारों के लिए Semiring और इसके समकक्ष हैं। दुर्भाग्य से, पहली बिल्लियों में नहीं है, लेकिन शायद यह भविष्य के संस्करणों में दिखाई देगा।

यदि यह उपलब्ध थे, तो हम किसी भी Alternative लिए Semiring अनुमान लगा सकते हैं Alternative जैसे कि Monoid और MonoidK लिए MonoidK । इसके अलावा, हम Semiring का उपयोग करके Semiring को Alternative में वापस Semiring सकते हैं, जो Monoid को Monoid में बदल Monoid है।

निष्कर्ष में, आइए देखें कि यह परिवर्तन कैसे लिखा जा सकता है:

 import Semiring.ops._ case class Const[A, B](getConst: A) implicit def constSemiringal[A: Semiring] = new Semiringal[Const[A, ?]] { def sum[B, C](fa: Const[A, B], fb: Const[A, C]): Const[A, Either[B, C]] = Const(fa.getConst + fb.getConst) def product[B, C](fa: Const[A, B], fb: Const[A, C]): Const[A, (B, C)] = Const(fa.getConst * fb.getConst) def unit: Const[A, Unit] = Const(Semiring[A].one) def nothing: Const[A, Nothing] = Const(Semiring[A].zero) } 

निष्कर्ष

अंगूठियां और आधा छल्ले बहुत ही दिलचस्प बीजीय संरचनाएं हैं, और यहां तक ​​कि अगर आपने इसके बारे में नहीं सोचा था, तो सबसे अधिक संभावना है कि आप पहले ही उनका उपयोग कर चुके हैं। यह पोस्ट यह दर्शाने के लिए लिखी गई थी कि कैसे MonoidK और MonoidK से संबंधित है, क्यों बीजीय डेटा प्रकार एक आधा रिंग बनाते हैं, और कैसे ये बीजगणितीय संरचनाएं स्काला और अन्य प्रोग्रामिंग भाषाओं में फैलती हैं। मेरे लिए व्यक्तिगत रूप से, यह किस प्रकार परस्पर जुड़ा हुआ है और एक बहुत ही दिलचस्प समरूपता एक मस्तिष्क विस्फोट था, और मुझे उम्मीद है कि यह पोस्ट विभिन्न गणितीय सार के आधार पर Cats और अन्य पुस्तकालयों में इसी तरह के दिलचस्प समानताएं खोजने में मदद कर सकती है। आप इस विषय पर आगे की सामग्री यहां पा सकते हैं।

इसके अलावा

इस पोस्ट में, मैंने टाइप कक्षाओं के रिकॉर्ड में कम्यूटेटिविटी के बारे में चुप रहा। कम्यूटेशन सेमरिंग्स के लिए एक बहुत महत्वपूर्ण संपत्ति है और कोड को इस संपत्ति को प्रतिबिंबित करना चाहिए। फिर भी, चूंकि पोस्ट में पहले से ही कई परिभाषाएँ हैं, इसलिए इसे कई और कम्यूटेटिव प्रकार की कक्षाओं में शामिल किया गया है, जो कुछ भी नहीं करते हैं, लेकिन नए कानूनों को पेश करते हुए बेमानी लग रहा था और पोस्ट के मुख्य उद्देश्य से विचलित हो रहा था।

इसके अलावा, मैंने केवल उन्हीं वर्गों की कार्डिनल संख्याओं पर ध्यान केंद्रित किया, जिनकी हमें ज़रूरत थी, लेकिन पूर्णता के लिए, आप A => B , Option[A] , Ior[A, B] जैसी चीजों के लिए Cardinality परिभाषा जोड़ सकते हैं:

1.  Cardinality.of[A => B] === Cardinality.of[B].pow(Cardinality.of[A]) 

   
   

2.  Cardinality.of[Option[A]] === Cardinality.of[A] + 1 

   
   

3.  Cardinality.of[Ior[A, B]] === Cardinality.of[A] + Cardinality.of[B] + Cardinality.of[A] * Cardinality.of[B]