हास्केल - सौंदर्यशास्त्र

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





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

Language.Haskell.Parser मॉड्यूल, एक्सटेंशन के बिना, Haskell'98 कोड (अच्छी तरह से, लगभग बिना एक्सटेंशन के) साफ का एक पार्सर है। "उन्नत" कार्यक्रमों को उनके लिए पार्स नहीं किया जा सकता है, लेकिन शुरुआत में Haskell'98 ही आंखों के लिए पर्याप्त है। प्रायोगिक खरगोश के रूप में, मैंने भाज्य गणना कोड लिया:

तथ्य 'एन | n == 0 = 1
| अन्यथा = तथ्य ' ( n - 1 ) * n

पुस्तकालय का उपयोग करके पार्सिंग और विश्लेषण प्राथमिक रूप से किया जाता है, यहां एक सरल कार्यक्रम का एक उदाहरण दिया गया है:

भाषा आयात करें । हास्केल । पार्सर

मु य = करना
s <- readFile "Fact.hs"
आज्ञा देना = पारसेयोदय करना
putStrLn । $ पार्स दिखाओ

ParseModule फ़ंक्शन निम्न प्रकार का है:

parseModule :: स्ट्रिंग -> ParseResult HsModule

जहाँ पहला तर्क हास्केल कोड है, और HsModule का मान लौटाया जाता है। HsModule प्रकार के साथ काम करने के लिए, आपको Language.Haskell.Syntax मॉड्यूल को कनेक्ट करना होगा। इसकी प्रकार संरचना पूरी तरह से एएस के रूप में हास्केल'98 सबसेट का वर्णन करती है:

ParseOk
( HsModule
( SrcLoc { srcFilename = "<अज्ञात>" , srcLine = 3 , srcColumn = 1 } )
( मॉड्यूल "मुख्य" )
( बस ( HsEVar ( UnQual ( HsIdent "main" ) ) ) ) ]
[ ]
[ HsFunBind
[ HsMatch
( SrcLoc { srcFilename = "<अज्ञात>" , srcLine = 3 , srcColumn = 1 } )
( HsIdent "fact '" )
[ HsPVar ( HsIdent "n" ) ]
( HsGuardedRhss
[ HsGuardedRhs
( SrcLoc { srcFilename = "<अज्ञात>" , srcLine = 3 , srcColumn = 9 } )
( HsInfixApp
( HsVar ( UnQual ( HsIdent "n" ) ) )
( HsQVarOp ( UnQual ( HsSymbol "==" ) ) )
( HsLit ( HsInt 0 ) ) )
( HsLit ( HsInt 1 ) )
, HsGuardedRhs
( SrcLoc { srcFilename = "<अज्ञात>" , srcLine = 4 , srcColumn = 9 } )
( HsVar ( UnQual ( HsIdent "अन्यथा" ) ) )
( HsInfixApp
( HsApp
( HsVar ( UnQual ( HsIdent "fact '" ) ) )
( एच.एस पारेन
( HsInfixApp
( HsVar ( UnQual ( HsIdent "n" ) ) )
( HsQVarOp ( UnQual ( HsSymbol "-" ) ) ))
( HsLit ( HsInt 1 ) ) ) )
( HsQVarOp ( UnQual ( HsSymbol "*" ) ) )
( HsVar ( UnQual ( HsIdent "n" ) ) ) ) ]] [ ] ] ]

ग्राफसर्वर परियोजना में, मैंने एएसटी पेड़ को घटकों में विभाजित किया है ताकि इसके साथ काम करना अधिक सुविधाजनक हो:

t1 = HsInfixApp ( HsVar ( UnQual ( HsIdent "n" ) ) )
( HsQVarOp ( UnQual ( HsSymbol "-" ) ) ))
( HsLit ( HsInt 1 ) )

t2 = HsApp ( HsVar ( UnQual ( HsIdent "fact '' ' ) ) ))
( HsParen t1 )

t3 = HsInfixApp t2
( HsQVarOp ( UnQual ( HsSymbol "*" ) ) )
( HsVar ( UnQual ( HsIdent "n" ) ) )

t4 = HsGuardedRhs ( SrcLoc { srcFilename = "<अज्ञात>" , srcLine = 4 , srcColumn = 9 } )
( HsVar ( UnQual ( HsIdent "अन्यथा" ) ) )
t3
...

जब सर्वर सामान्य मोड में काम करेगा, तो इसे हास्केल कोड की एक पंक्ति भेजना संभव होगा, जिसे सर्वर द्वारा एएसटी को पार्स किया जाता है और फिर विज़ुअलाइज़ किया जाता है। अब, विकास के सक्रिय चरण में, सर्वर निष्क्रिय है। मैं बस एक या दूसरे "टी-फ़ंक्शन" का चयन करता हूं और संपूर्ण विज़ुअलाइज़ेशन प्रक्रिया शुरू करता हूं; लेकिन स्पष्ट सादगी के तहत, विभिन्न तंत्र और एल्गोरिदम छिपे हुए हैं, जिसके परिणाम आप तस्वीर में देख सकते हैं:



यहाँ कार्य के सही हिस्सों के साथ सुरक्षा अभिव्यक्तियाँ हैं:

| n == 0 = 1
| अन्यथा = तथ्य ' ( n - 1 ) * n

मैं चाहता था कि ग्राफिक भाषा वाक्य रचना के अर्थ को प्रतिबिंबित करे। गार्ड अभिव्यक्ति "निष्पादन फिल्टर" की तरह काम करते हैं। आइए हम एक विचार प्रयोग के साथ फ्रेम की गहनता को दर्शाते हैं। कल्पना कीजिए कि प्रगति एक घन है जो फ्रेम के माध्यम से फ़ंक्शन के शरीर में जा सकता है, या इसके आकार ("तार्किक स्थिति") के आधार पर, इसके माध्यम से नहीं जा सकता है। ऊपर की छवि में तीर प्रगति दिखाते हैं। मज़ेदार क्या है, फ्रेम, यदि आप सामने से दृश्य को देखते हैं, तो बहुत ऊर्ध्वाधर रेखा में बदल जाता है जिसे हम कोड में देखते हैं।


मैंने यह पता लगाने की कोशिश की कि ऑपरेटर द्वारा बनाई गई सूची क्या दिखती है: पैटर्न मिलान के अंदर, और अब तक मैं चित्रों में विकल्प के साथ आया था। पहला एक्सप्रेशन (X1: x2: xs), दूसरा एक्सप्रेशन (X1: _: []) से मेल खाता है। "महत्वहीन" तत्व के बजाय, एक सपाट मंच को चित्रित किया गया है, और एक खाली सूची - यह खाली है। सशर्त यदि कथन और केस-कंस्ट्रक्शन भी कुछ हद तक सहज हैं। मेरे पास कागज पर अन्य मोटे रेखाचित्र हैं, लेकिन बहुत से हास्केल सिंटैक्स को अभी भी विकसित करने की आवश्यकता है। यह भी प्रकार घोषणाओं पर लागू होता है, और इसकी विशेषताओं, और पैटर्न मिलान, और अन्य महत्वपूर्ण चीजों के साथ निर्माण होता है। और फिर बनाए गए स्केच को कोड में लागू करने की आवश्यकता है ...



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

I. एक संरचना के लिए एक AST तत्व की संरचना के लिए एक मूल तत्व परिवर्तित करना
द्वितीय। एक संरचना के लिए एक संरचना आदिम का नक्शा करें
तृतीय। एक दूसरे के सापेक्ष एक StructureObject का संयोजन और स्थिति
चतुर्थ। दृश्य तत्वों में ग्राफिक आदिम का संकलन
वी। एक दृश्य का प्रतिपादन

इससे पहले कि हम कार्यान्वयन के लिए आगे बढ़ें, उन मॉड्यूल पर विचार करें जिनमें सर्वर कोड विभाजित है।

ग्राफसर्वर (मुख्य) - कार्यक्रम का मुख्य मॉड्यूल। मुख्य फ़ंक्शन, सर्वर लॉजिक; इसमें, ओपनजीएल का आरंभीकरण, एक खिड़की का निर्माण और प्रारंभिक सेटिंग्स होती हैं। मुख्य कार्यक्रम लूप भी वहां स्थित है, और ड्रा.ड्रॉव मॉड्यूल से ड्रॉ फ़ंक्शन इसमें कताई कर रहा है।

सामान्य - सामान्य डेटा और एल्गोरिदम।
कॉमन कॉस्टेंट्स - सामान्य स्थिरांक, सेटिंग्स, निश्चित डेटा।
Common.GLTypes - OpenGL प्रकार (वैक्टर, कोने, आदि), साथ ही साथ अन्य परिभाषाएँ।
Common.TestData - "t-functions", परीक्षण तंत्र के लिए अतिरिक्त डेटा।
Common.Units - ओपन यूनिट वैक्टर और कोने के साथ अंतरिक्ष इकाइयों के साथ काम करने के लिए कार्य करता है।

संरचना - डेटा प्रकार और एल्गोरिदम एक एएसटी ट्री को स्ट्रक्चुरोबोजेब ट्री में संकलित करने के लिए।
संरचना.संबंधी - स्थिरांक और चरण I, II, III से जुड़ी सेटिंग्स।
स्ट्रक्चर्स। SructructObject - स्ट्रक्चरऑब्जेक्ट के केंद्रीय डेटा प्रकार का विवरण।
संरचना.ग्राफऑब्जेक्ट - ग्राफऑब्जेक्ट प्रकार और कार्यों का विवरण जो इस प्रकार का ऑब्जेक्ट बनाते हैं।
संरचना.संयम - ग्राफिक ऑब्जेक्ट्स के आयामों के साथ काम करते हैं।
संरचना। I, II के चरणों के अनुरूप है।
संरचना.संकेत - कई संरचना का संबंध। तृतीय चरण के अनुरूप।
स्ट्रक्चोर.गॉम्पेलाइल - वास्तविक दृश्य वस्तुओं में ग्राफिक प्रिमिटिव्स (ग्राफऑब्जेक्ट) का संकलन। IV चरण के अनुरूप।
संरचना .syntaxTools - एएसटी के साथ काम करने के लिए सहायक कार्य करता है।
संरचना। पाठ - सहायक डेटा प्रकार और बनावट के साथ काम करने के लिए कार्य।

ड्रा - दृश्य प्रदान करने के लिए जिम्मेदार कार्य।
ड्रा.ड्रॉव - ड्रॉ फ़ंक्शन होता है जिसमें दृश्य संकलित और प्रस्तुत किया जाता है।
Draw.GLInit - नाम के रूप में डिज़ाइन किए गए सहायक फ़ंक्शन, जिसका नाम ओपनजीएल को इनिशियलाइज़ करने के लिए है।
ड्रा.रेंडर - इसमें रेंडर फंक्शन होता है। वी कदम के अनुरूप।
Draw.TextureInit - बनावट बनाने के लिए सहायक कार्य।

विविध - अन्य सहायक कार्य।
Misc.BoxSide - HOpenGL लाइब्रेरी से फ़ंक्शंस जिसमें बक्से के किनारों का निर्माण होता है।

थर्डपार्टी - थर्ड पार्टी यूटिलिटीज और प्रोग्राम।
ThirdParty.Frag - फ्रैग कार्यक्रम से कोड। टीजीए फाइलें डाउनलोड करें, बनावट बनाएं।
ThirdParty.GLUtil - OpenGL के साथ काम करने के लिए अतिरिक्त उपयोगिताओं।
ThirdParty.ImageFormats - TGA फ़ाइलें डाउनलोड करें।



मैं ऊपर उल्लिखित ड्रा फ़ंक्शन में एल्गोरिदम का परीक्षण और संचालन करता हूं:

ड्रा :: ड्राफंक्शन
ड्रा GLResources texRes n = करते हैं
putStr $ "करंट n =" ++ शो n
जीएल। स्पष्ट [ जीएल । ColorBuffer , जीएल । डेफ्थ बफ़र ]
जीएल। loadIdentity
जीएल। 10 घुमाएँ ( वेक्टर 3 0 1 0 )
जीएल। 20 घुमाएँ ( वेक्टर 3 1 0 0 )
जीएल। अनुवाद ( वेक्टर 3 ( - 5 ) - ( 10 ) ( - 30 ) )

- StructureObject से एक पदानुक्रम का निर्माण
Let c = constructFramedGRhss ( OcsGuardedRhss t6 )

- ग्राफिक आदिम से संकलित दृश्य तत्व
- और एक दृश्य ड्रा
प्रस्तुत करना
putStrLn "ठीक है।"

ConstructFramedGRhss और रेंडर फ़ंक्शंस सभी काम करते हैं, और आउटपुट में हमें वे चित्र मिलते हैं जो लेख की शुरुआत में प्रस्तुत किए जाते हैं। संरचना से निर्माणFramedGRhss फ़ंक्शन (और इसके एनालॉग्स)। संरचना अवरोधक उपकरण चरण I - III को कार्यान्वित करता है। वह इस प्रकार है:

constructFramedGRhss :: ObjectConstructSpec -> StructureObject

यह एक निश्चित ObjectConstruct विनिर्देश को स्वीकार करता है, और StructureObject से एक तैयार-पदानुक्रम देता है। एक विनिर्देश सिर्फ एक एडीटी है, जहां यह वर्तनी है कि हम किस सिंथैटिक यूनिट के साथ काम कर रहे हैं:

- मॉड्यूल संरचना। SructructObject
डेटा ObjectConstructSpec
= OcsApp HsExp
| OcsExpArgument HsExp
| OcsExpFuncName HsExp StructureObject
| OcsInfixOperator HsQOp
| OcsGuardedRhs HsGuardedRhs
| OcsFoundationExp StructureObject
| OcsGuardedRhss HsRhs
| OcsArrowBridge
| OcsEqualSignBridge
| ओक्समैच एचएसएमच

किसी भी संभावित पदानुक्रमित संरचना का वर्णन करने के लिए StructureObject डेटा प्रकार पर्याप्त सामान्य होना चाहिए।

- मॉड्यूल संरचना। SructructObject
data StructureObject = स्ट्रक्चरurebject
{ soObjectSpec :: ObjectSpec
, soGeometry :: ज्यामिति
, soGraphObjectSpec :: GraphObjectSpec
, soStructureObjects :: StructureObjects
} व्युत्पन्न ( दिखाएँ )

प्रकार StructureObjects = [ StructureObject ]

जैसा कि आप देख सकते हैं, soStructureObjects फ़ील्ड में चाइल्ड ऑब्जेक्ट्स की एक सूची है। वास्तव में, एएसटी पदानुक्रम को एक संरचना में बदल दिया जाता है। प्रतिपादन के लिए आवश्यक जानकारी के संचय के साथ एक पदानुक्रम पदानुक्रम: स्थिति, आकार, ग्राफिक आदिम, बनावट। एक पेड़ सबसे निचले स्तरों से शुरू होता है, क्योंकि यह निर्धारित करने का एकमात्र तरीका है कि अंतरिक्ष में एक अतिव्यापी स्तर का तत्व कहाँ होना चाहिए। यह योजना एक प्रतिबंध लगाती है कि स्ट्रैचर स्पेस में ऑब्जेक्ट्स को पूर्ण निर्देशांक को तुरंत असाइन करना असंभव है: अंतरिक्ष में बाल वस्तुओं से बढ़ते हुए, हम कल्पना भी नहीं कर सकते हैं कि मूल तत्व कहां होगा। इस प्रकार, सभी स्ट्रक्चरऑब्जेक्ट केवल अपने माता-पिता के सापेक्ष ही तैनात किए जा सकते हैं; वह है, प्रत्येक StructureObject के पास OX, OY और OZ कुल्हाड़ियों के साथ-साथ माता-पिता के शून्य बिंदु के सापेक्ष अपनी ऑफ़सेट है। यह इस तरह दिखता है:



आरेख पारंपरिक रूप से दो संरचना को चित्रित करता है। विषय: सफेद पैनल मूल वस्तु के स्थान से मेल खाते हैं, ईंट पैनल बच्चे के स्थान के अनुरूप हैं। स्ट्रक्चुरऑब्जेक्ट खुद को दृश्य पर प्रदर्शित नहीं किया जाता है, लेकिन ग्राफिक ऑब्जेक्ट्स के लिए कंटेनर माना जाता है (आरेख में नीला)। ग्राफिकल ऑब्जेक्ट्स को स्ट्रक्चर स्ट्रक्चरऑब्जेक्ट के शून्य बिंदु के सापेक्ष स्थित किया जाता है। आयाम (आयाम) स्ट्रक्चरऑब्जेक्ट सभी उपग्रहों के सामान्य आयाम हैं और मूल तत्व में गणना के लिए आवश्यक हैं। SoGeometry फील्ड, Geometry का प्रकार है। इसमें तीन-आयामी वेक्टर द्वारा परिभाषित सामान्य विस्थापन और आयाम शामिल हैं:

- कॉमन.जीएलटाइप्स मॉड्यूल
प्रकार ज्यामिति = ( अनुवाद , आयाम )
टाइप करें GLfVector3 = GL । वेक्टर 3 जीएल । GLfloat
प्रकार अनुवाद = GLfVector3
प्रकार आयाम = GLfVector3

इसी तरह के डेटा, साथ ही एक ग्राफिक ऑब्जेक्ट में निम्न प्रकार का soGraphObjectSpec फ़ील्ड शामिल है:

ग्राफऑब्जेक्टस्पेक = ( अनुवाद , आयाम , ग्राफऑब्जेक्ट ) टाइप करें

स्ट्रक्चुरेबजेक्ट बनाने का कोड व्यापक है और इसे दो मॉड्यूल में विभाजित किया गया है। सिंटैक्स तत्व, सरल और जटिल, संरचना में परिवर्तित हो जाते हैं। प्रारंभ में, soGeometry क्षेत्र में अनुवाद ऑफसेट एक शून्य वेक्टर के बराबर है। हम बस यह नहीं जान सकते कि नव निर्मित स्ट्रक्चुरऑबजेक्ट माता-पिता के सापेक्ष कैसे स्थित है, और माता-पिता अभी तक मौजूद नहीं है, और भविष्य में जरूरी नहीं है। ऑफसेट को बाद में संशोधित किया जाता है, उस कोड में जो बच्चा बनाता है; या यह केवल शून्य रहता है - फिर यह वह वस्तु है जो इसके उप-बिंदुओं के लिए संदर्भ बिंदु होगा। नीचे दिए गए कोड में - तीन सरल वस्तुओं ("चर", "प्लेटफ़ॉर्म", "पुल") और एक जटिल (तर्कों के साथ इन्फिक्स ऑपरेटर) का निर्माण:

- एक वस्तु एक चर अभिव्यक्ति के लिए बनाई गई है:
constructExp ( OcsExpArgument ( HsVar var ) ) = let
varText = makeName । getHsQualName $ var
रॉडिम = जीएल । वेक्टर 3 ( hsNameLength varText ) 2 2
मंद = व्युत्पन्नता ( फनडिमेंशन वेरिएबलबॉक्सडिम्स ) रॉडिम
graphObjSpec = variableBox varText dim
in स्ट्रक्चरurebject ऑसर्गुमेंट ( nullVector3 , dim ) graphObjSpec [ ]

- "प्लेटफार्म" का निर्माण किया जा रहा है:
constructFoundation :: ObjectConstructSpec -> StructureObject
constructFoundation ( OcsFoundationExp expSo ) = चलो
expSoDim = geometryDim । soGeometry $ expSo
मंद = व्युत्पन्न फाउंडेशनडिमेंशन एक्सपोज़डिम
graphObjSpec = नींव बॉक्स मंद
in स्ट्रक्चरure ऑबाउंडेशन ( nullVector3 , dim ) ग्राफऑब्जेस्पेक [ ]

- "पुल" का निर्माण किया जा रहा है:
निर्माणब्रिज :: ObjectConstructSpec -> StructureObject
constructBridge ocsBridgeType = चलो
मंद = वेक्टर 3 2 0.25 2
( graphObjSpec , bType ) = मामला ocsBridgeType का
OcsArrowBridge -> ( ऐरोब्रिज मंद , OsArowrowBridge )
OcsEqualSignBridge -> ( equSignBridgeBox मंद , OsEqualSignBridge )
in स्ट्रक्चरurebject bType ( nullVector3 , dim ) graphObjSpec [ ]

- एक जटिल वस्तु का निर्माण किया जाता है - तर्कों के साथ एक इन्फिक्स ऑपरेटर:
constructExp ( OcsExpArgument ( HsInfixApp exp1 qOp exp2 ) ) = चलो
exp1So = constructExp ( OcsExpArgument exp1 )
qOpSo = constructQOp ( OcsInfixOperator qOp )
exp2So = constructExp ( OcsExpArgument exp2 )
in connectStructureObjects OsInfixApp [ exp1So , qOpSo , exp2So ]

एक जटिल वस्तु बनाते समय, हमें किसी तरह इसके बच्चों की व्यवस्था करनी चाहिए। यह स्पष्ट है कि विभिन्न वाक्यात्मक इकाइयों के लिए अलग-अलग स्थिति होगी। हमें वस्तुओं को शून्य के सापेक्ष ऑफसेट की गणना और असाइन करने की आवश्यकता है। नव निर्मित वस्तु होने के कारण, अभिभावक को शून्य पर स्थानांतरित कर दिया जाएगा (अर्थात, बिल्कुल स्थानांतरित नहीं किया गया), क्योंकि हम अभी तक नहीं जानते हैं कि कितना बदलाव करना है और इसके बारे में क्या करना है। Offsets की गणना ConnectStructureObjects फ़ंक्शन द्वारा Structure.SOConnect मॉड्यूल से की जाती है। सिंटैक्टिक यूनिट का दृश्य और पहले बनाए गए सबजेक्ट की सूची को इसमें स्थानांतरित कर दिया जाता है। प्रत्येक मामले के लिए, ConnectStructureObjects फ़ंक्शन के पास अपनी गणना विकल्प हैं।

connectStructureObjects :: ObjectSpec -> StructureObjects -> StructureObject

- इनफ़िक्स ऑपरेटर और दो एक्सप्रेशन जुड़े हुए हैं:
connectStructureObjects OsInfixApp ( exp1So: opSo: exp2So: [ ] ) / let
exp1SoDim @ ( GL । वेक्टर 3 e1dl e1dh e1dw ) = जियोमेट्रीडिम । soGeometry $ exp1So
exp2SoDim = ज्योमेट्रीडिम । soGeometry $ exp2So
opSoDim @ ( GL । वेक्टर 3 opdl opdh opdw ) = geometryDim । soGeometry $ opSo
exp1Trans = nullVector3 - अभिव्यक्ति 1 मूल शून्य पर शुरू होती है
opTrans = वेक्टर 3 e1dl 0 0 - ऑपरेटर को एक्सएक्स 1 की लंबाई 1 (इसके बगल में स्थित) द्वारा स्थानांतरित किया जाता है
exp2Trans = वेक्टर 3 ( e1dl + opdl ) 0 0 - अभिव्यक्ति 2 को अभिव्यक्ति 1 की लंबाई और ऑपरेटर की लंबाई के आधार पर ओए द्वारा स्थानांतरित किया जाता है।
generalDim = generalizedDimension [ ( exp1Trans , exp1SoDim ) - माता-पिता के सामान्य आयाम
, ( exp2Trans , exp2SoDim )
, ( opTrans , opSoDim ) ]
newOpGoSpec = ( opTrans , opSoDim , graphObjectFromSpec । soGraphObjectSpec $ opSo )
newExp1So = exp1So { soGeometry = ( exp1Trans , exp1SoDim ) }
newExp2So = exp2So { soGeometry = ( exp2Trans , exp2SoDim ) }
in StructureObject OsInfixApp ( nullVector3 , generalDim ) newOpGoSpec [ newExp1So , newExp2So ]

समन्वय अक्षों द्वारा खींची गई एक खाली जगह की कल्पना करें। निर्देशांक के केंद्र में - शून्य। मानसिक रूप से दृश्य को एक छोटे से बॉक्स में जोड़ें, दाएं-ऊपर स्थानांतरित कर दिया गया। अब एक अलग आकार का एक बॉक्स जोड़ें, हमें और बाईं ओर स्थानांतरित कर दिया गया। यदि ये दोनों बॉक्स कुछ माता-पिता के उप-विषय हैं, तो उनके किनारे इसकी जगह को सीमित करते हैं। उपरोक्त आरेख में, स्ट्रक्चर ऑरबजेक्ट स्पष्ट रूप से दिखाई देता है: किसी वस्तु का स्थान इसकी सामग्री द्वारा निर्धारित किया जाता है। लेकिन माता-पिता के कुल आयामों की गणना कैसे करें? हमें प्रत्येक उप-तत्व के विस्थापन और आकार को ध्यान में रखना चाहिए और निर्देशांक के सामान्य न्यूनतम, अधिकतम पता लगाना चाहिए। फिर चढ़ाव उच्च से घटाया जाता है, और समग्र आकार प्राप्त किया जाता है। यह ऐसा है जैसे हम वस्तुओं के चरम किनारों के साथ विमानों को खींचते हैं, वांछित स्थान को रेखांकित करते हैं। यह एल्गोरिथ्म ऑफ़सेट्स और आकारों की एक सूची पर दृढ़ विश्वास से लागू किया जाता है, और फ़ंक्शन को सामान्यीकृतकरण कहा जाता है।

- मॉड्यूल संरचना
generalizedDimension :: ज्यामिति -> आयाम
सामान्यीकृत तनाव ( g: gs ) = गति ( गुना f g gs )
जहाँ
एफ ( जीएल । वेक्टर 3 डीएक्स 1 डाइ 1 डीज़ 1 ) , ( जीएल वेक्टर 3 एक्स 1 ए 1 एज़ 1 )
( ( GL । वेक्टर 3 dx2 dy2 dz2 ) , ( GL । वेक्टर 3 ax2 ay2 az2 ) = )
( वेक्टर 3 ( न्यूनतम dx1 dx2 ) ( न्यूनतम डाई 1 डाई 2 ) ( न्यूनतम dz1 dz2 ) ,
वेक्टर 3 ( अधिकतम ( dx1 + ax1 ) ( dx2 + ax2 ) )
( अधिकतम ( dy1 + ay1 ) ( dy2 + ay2 ) )
( अधिकतम ( dz1 + az1 ) ( dz2 + az2 ) )
टेंशन ( ( GL । वेक्टर 3 X1 y1 z1 ) , ( GL । वेक्टर 3 x2 y2 z2 ) =
वेक्टर 3 ( एब्स ( x2 - X1 ) ) ( एब्स ( y2 - y1 ) ) ( एब्स ( z2 - z1 ) )

स्ट्रक्चर्स.कॉन्स्ट्रक्ट एंड स्ट्रक्चर्स.कॉनकनेक्ट मॉड्यूल्स में बोझिल फीचर्स के बावजूद, मैंने अभी तक कुछ भी बेहतर नहीं किया है। संभवतः किसी प्रकार का घोषणात्मक समाधान है, लेकिन यह संभावना नहीं है कि कम कोड होगा। ऐसे विशेष मामले हैं जिन्हें एक एकल घोषणा योजना में फिट करना मुश्किल है; इसलिए, भाषा के डिजाइन के अनुसार, फ़ंक्शन ऊंचाई में एक इकाई में एक बॉक्स जैसा दिखता है, और इसके तर्क उस पर स्थित हैं। यह इस प्रकार है कि बॉक्स की लंबाई की गणना करने के लिए आपको तर्कों की संख्या, उनके आकार और उनके बीच की दूरी पर विचार करना होगा। ग्राफिक भाषा में अभिव्यक्ति एक पिरामिड की तरह दिखती है, जिसका अर्थ है कि प्रत्येक अंतर्निहित परत के प्रोट्रूशियंस से जुड़ी अतिरिक्त गणनाएं होती हैं। इस कार्य को सारांशित करते हुए, मैंने एक "विरासत के आकार का तंत्र" बनाया, जिसमें संरचना से व्युत्पन्न आयाम। आयाम मॉड्यूल एक महत्वपूर्ण भूमिका निभाते हैं। यह तत्व के प्रारंभिक आकार, आवश्यक बाल तत्वों के आकार और विरासत एल्गोरिथ्म को उच्च-क्रम फ़ंक्शन के रूप में व्यक्त करता है, और नए, "विरासत में" आकार देता है। पूर्व-पूर्व-सूची के निर्माण कार्य से निम्न कोड सरल है:

चलो
रॉडिम = जीएल । वेक्टर 3 1 2 2
मंद = व्युत्पन्नता ( फनडिमेंशन वेरिएबलबॉक्सडिम्स ) रॉडिम
...

यहां, चर के लिए रॉडिम मूल बॉक्स आकार है, और मंद नया, "विरासत में मिला" आकार है। FuncDimensions डेटा कंस्ट्रक्टर DerivedDimensions विशेष डेटा प्रकार के अंतर्गत आता है:

- मॉड्यूल संरचना
डेटा व्युत्पन्नताएं = फनडिमेंशन्स ( GLfVector3 -> GLfVector3 )
| FoundationDimensions

व्युत्पन्न और उच्च-क्रम के कार्यों को निम्नानुसार परिभाषित किया गया है:

- मॉड्यूल संरचना
व्युत्पन्न तनाव :: व्युत्पन्न तनाव -> GLfVector3 -> GLfVector3
व्युत्पन्न ( फनडिमेंशन च ) मंद = एफ मंद
व्युत्पन्नता फाउंडेशन फाउंडेशन ( GL । वेक्टर 3 l h w ) = वेक्टर 3 ( l + 2 ) 0.25 ( w + 2 )

- कार्य व्युत्पन्नता में जगह के लिए
- | फ़ंक्शन बॉक्स आयामों की गणना तर्क के अनुसार होती है
funcBoxDerivedDims :: GLfVector3 -> GLfVector3 -> GLfVector3
funcBoxDerivedDims ( GL । वेक्टर 3 ओपल oph opw ) ( GL । वेक्टर 3 fBoxl fBoxh fBoxw ) =
( GL । वेक्टर 3 ( f opl fBoxh ) fBoxh ( अधिकतम opw fBoxw ) )
जहाँ
f ऑप बॉक्स | op > = बॉक्स = op + १
| ( box - op ) < 1 = op + 1
| ( box - op ) > = 1 = बॉक्स

- | चर बॉक्स के लिए गणना करता है
परिवर्तनीय बॉक्स :: GLfVector3 -> GLfVector3
variableBoxDims ( GL । वेक्टर 3 varl varh varw ) =
( GL । वेक्टर ३ ( यदि varl < २ तब 2 और varl ) varh varw )

जैसा कि आप देख सकते हैं, व्युत्पन्न फ़ंक्शन में फाउंडेशनडिमेंट्स कंस्ट्रक्टर के लिए, एक सरल एल्गोरिथ्म निर्दिष्ट किया गया है जिसमें मूल आकार बस एक निश्चित राशि द्वारा बदल दिए जाते हैं। लंबाई और चौड़ाई 2 से बढ़ जाती है, और ऊंचाई 0.25 हो जाती है। अधिक जटिल मामलों को funcBoxDerivedDims और variableBoxDims का उपयोग करके कार्यान्वित किया जाता है। उदाहरण के लिए, उस सरलीकृत कोड से मंद GL.Vector3 2 2 2 के बराबर हो जाएगा, क्योंकि गणना वेरिएबलबॉक्सडम्स (GL.Vector3 1 2 2) को कॉल करने के लिए कम हो जाएगी। यदि आवश्यक हो, तो आप अन्य समान फ़ंक्शन लिख सकते हैं। और भी अधिक सहज ज्ञान युक्त ग्राफिक भाषा के लिए, मैं भविष्य में कार्यों की विविधता को जोड़ने की योजना बना रहा हूं। यह एक बॉक्स पर खांचे की तरह दिखेगा; खाली स्लॉट्स करी या अनुभाग के अनुरूप हैं।बेशक, अकेले विरासत में मिले आकार का तंत्र पर्याप्त नहीं होगा, क्योंकि धमनी निर्धारित करने के लिए, सिंटैक्स में सरल अपघटन की तुलना में अधिक उन्नत कोड विश्लेषण की आवश्यकता होती है। लेकिन यह एक और कहानी है ...

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

- मॉड्यूल संरचना। GraphObjec
डेटा ग्राफऑब्जेक्ट = NoGraphObject
| प्रिमिटिवबॉक्स GLfVertex3 TextureName
| TexturedBox GLfVertex3 ObjectTextureSpec
| GraphObjects [ GraphObjectSpec ]
deriving ( Show )

यह नोटिस करना आसान है कि एक स्ट्रक्चोरऑब्जेक्ट में कई ग्राफिक ऑब्जेक्ट्स (ग्राफऑब्जेक्ट्स कंस्ट्रक्टर) हो सकते हैं, और उन्हें बिल्कुल नहीं (नॉटग्राफऑब्जेक्ट कंस्ट्रक्टर)। और यह समझ में आता है: HsGuardedRhss के मूल्य के लिए ऊपर दिखाए गए AST ट्री में, ग्राफिक से मेल खाने के लिए कुछ भी नहीं है। बल्कि, यह अन्य वस्तुओं के लिए एक कंटेनर होगा, अर्थात्, समारोह के सही हिस्सों के लिए गार्ड अभिव्यक्ति (Rhss - "दाहिने हाथ की ओर")। उसी समय, तथाकथित "वास्तविक" ग्राफिक ऑब्जेक्ट्स को केवल दो तत्वों द्वारा दर्शाया जाता है: आदिम बॉक्स PrimitiveBox और उन्नत बॉक्स TexturedBox। दोनों बॉक्सों में GLFVertex3 का मान होता है - ये केवल आकार हैं जिनके द्वारा बनावट वाले चेहरे, छह टुकड़े, चरण IV में बनाए जाएंगे। एक आदिम बॉक्स में एक बनावट होती है, लेकिन टेक्सचर्डबॉक्स के लिए प्रत्येक चेहरे के लिए एक अलग बनावट सेट करना संभव है। ObjectTextureSpec प्रकार इस तरह संरचित है:

-- Structure.Texture
data ObjectTextureSpec = BoxTextureSpec
{ quadSideTexes :: [ ( BoxSide , QuadColorSpec ) ]
, defQuadSideTex :: QuadColorSpec
} deriving ( Show )

data QuadColorSpec = QuadTexture TextureName
| QuadPlainColor GLfColor4
| NoQuadColorSpec
deriving ( Show )

-- BoxSide Common.GLTypes.
-- , :
data BoxSide = SideTop
| SideBottom
| SideLeft
| SideRight
| SideRear
|SideFront
पाने ( दिखाएँ , Eq )

शीर्ष पर एक तीर रखना चाहते हैं और सभी डिफ़ॉल्ट रूप से बनावट वाले हैं? कोई बात नहीं!

जाने TExES = [ ( SideTop , QuadTexture ARROWTEX ) ]
defaultTex = QuadTexture yellowBaseTex
boxTexSpec = BoxTextureSpec TExES defaultTex

या बनावट के साथ सिर्फ दो चेहरे, और कुछ रंग के साथ बाकी? और यह संभव है।

जाने TExES = [ ( SideFront , QuadTexture ARROWTEX )
, ( SideRear , QuadTexture ARROWTEX ) ]
defaultTex = QuadPlainColor ( color3 1 0 0 )
boxTexSpec = BoxTextureSpec TExES defaultTex

एक प्रकार का विषय के निर्माण के दौरान ग्राफोमबजेक्ट के तत्वों का निर्माण मेनेमोनिक कार्यों का उपयोग करके किया जाता है। वर्तमान में, निम्न कार्य संरचना में उपलब्ध हैं। GraphObject मॉड्यूल: primitiveBox, variableBox, functionBox, नींव बॉक्स, arrowBridgeBox, equSignBridgeBox, BridgeBox, और guardFrame। उदाहरण के लिए, मैं केवल कुछ ही कार्य दूंगा:

-- Structure.GraphObject
primitiveBox trans dim @ ( GL . Vector3 l h w ) texName = ( trans , dim , PrimitiveBox ( vertex3 l h w ) texName )
variableBox _ dim @ ( GL . Vector3 l h w ) = ( nullVector3 , dim , PrimitiveBox ( vertex3 l h w ) helloTex )

arrowBridgeBox dim = bridgeBox dim arrowTex
equalSignBridgeBox dim = bridgeBox dim equalSignTex

bridgeBox dim @ ( GL . Vector3 l h w ) texName =
( nullVector3 , dim , TexturedBox ( vertex3 l h w ) boxTexSpec )
where
boxTexSpec = BoxTextureSpec texes defTex
texes = [ ( SideTop , QuadTexture texName ) ]
defTex = QuadTexture yellowBaseTex

हमें प्रतिपादन प्रणाली के बारे में भी बात करनी चाहिए। फिलहाल, मैं ग्राफिक प्राइमेटिक्स को दृश्य वस्तुओं में संकलित कर रहा हूं और उन्हें तुरंत आकर्षित कर रहा हूं। यह रेंडर फ़ंक्शन में होता है, जो ड्रॉ फ़ंक्शन के हिस्से के रूप में प्रोग्राम लूप में हमेशा के लिए घूमता है। बेशक, ऐसा कोड अक्षम है, क्योंकि जब एक ही स्ट्रक्चोर ऑबजेक्ट ट्री को संकलित किया जाता है, तो हमें वस्तुओं के साथ एक ही दृश्य मिलता है, और हम इसे समय से पहले तैयार कर सकते हैं। यहां कोई बाधा नहीं है, इसके अलावा, यदि आप क्रियाओं की सूची [IO ()] लौटाते हैं, तो रेंडरिंग और संकलन आसानी से अलग हो जाते हैं, और उन्हें क्रियान्वित नहीं करते हैं, जैसा कि अभी किया गया है:

-- Draw.Render
render texRes ( StructureObject _ ( soTrans , _ ) goSpec objects ) = do
GL . translate soTrans --
mapM_ ( render texRes ) objects --
sequence_ $ compileGraphObjectSpec texRes goSpec -- OpenGL-
GL . translate . negateVector3 $ soTrans --

रेंडरिंग एल्गोरिदम पुनरावर्ती है। वृक्ष को मूल संरचना से नीचे जाते हुए, हम बाल तत्वों के लिए अधिक से अधिक ऑफसेट सेट करते हैं, और जब हम पिछले स्तर पर लौटते हैं, तो हम इन ऑफसेट को हटा देते हैं। CompileGraphObjectSpec फ़ंक्शन किसी ग्राफ़ ऑब्जेक्ट में एक ग्राफ़ऑब्जेक्ट को संकलित करता है। अनुक्रम_ फ़ंक्शन क्रियाओं की सूची को निष्पादित करता है [IO ()]। ग्राफिक ऑब्जेक्ट्स में एक रिश्तेदार ऑफसेट भी होता है, इसलिए हम एनालॉग कोऑर्डिनेट ट्रांसफर करते हैं:

-- Structure.GOCompile
compileGraphObjectSpec texRes ( goTrans , _, go ) = let
forwardTrans = GL . translate goTrans
compiled = compileGraphObject texRes go
backwardTrans = GL . translate . negateVector3 $ goTrans
in ( forwardTrans : compiled ) ++ [ backwardTrans ]

सामान्य तौर पर, संरचना में कोड .GOCompile मॉड्यूल उपयोग की जाने वाली तकनीकों (उदाहरण के लिए, दृढ़ संकल्प और सूची समझ) के लिए बहुत दिलचस्प है। बेशक, इस तरह के कोड को समझना अधिक कठिन है, लेकिन मुझे लगता है कि यह किसी प्रकार की आंतरिक सुंदरता और पूर्णता है, जो अपने आप में मूल्यवान है:

-- | Collects actions for specified box side drawings.
-- | It should be used only in this module.
f :: PreparedTextureObjects
-> GLfVertex3
-> ( BoxSide , QuadColorSpec )
-> ( [ BoxSide ] , [ IO ( ) ] )
-> ( [ BoxSide ] , [ IO ( ) ] )
f texRes boxDim ( side , qColorSpec ) ( sList , ioList ) = let
boxIO = do setQuadColorSpec texRes qColorSpec
GL . renderPrimitive GL . Quads ( boxSide boxDim side )
in ( side : sList , boxIO : ioList )

-- | Compiles GraphObject into action list structure, which is ready-to-eval. ([IO ()])
compileGraphObject :: PreparedTextureObjects -> GraphObject -> [ IO ( ) ]

compileGraphObject _ NoGraphObject = [ ]

compileGraphObject texRes ( GraphObjects gObjectSpecs ) =
concatMap ( compileGraphObjectSpec texRes ) gObjectSpecs

compileGraphObject texRes ( PrimitiveBox boxDim texName ) =
[ do GL . color colorWhite
GL . textureBinding GL . Texture2D GL .$= lookup texName texRes
GL . renderPrimitive GL . Quads ( allBoxSides boxDim ) ]

compileGraphObject texRes ( TexturedBox boxDim boxTexSpec ) = let
( BoxTextureSpec sideTexes defTex ) = boxTexSpec
( textedSides , textedSideDrawList ) = foldr ( f texRes boxDim ) ( [ ] , [ ] ) sideTexes
untextedSides = [ s | s <- boxSideList , s ` notElem ` textedSides ]
untextedQColor = setQuadColorSpec texRes defTex
untextedSidesDraw = GL । प्रस्तुत करना GL । क्वाड्स ( बॉक्ससाइड्स बॉक्सडिम अनटेक्स्टेडसाइड्स ) अनटेक्स्टेड क्यूक्लर
में : अनटेक्स्टेडसाइडवार्ड: टेक्स्टेडसाइडड्रालिस्ट

बक्से चेहरे से बने होते हैं, और पक्ष रंग या बनावट से भरे होते हैं। ओपनजीएल में, आप किसी भी आकार को लंबवत आकर्षित कर सकते हैं; हमारे मामले में, ये चतुर्भुज के कोने होंगे। कोने की लंबाई, ऊंचाई और चौड़ाई मंद में समाहित की जाती है, और शून्य बिंदु बायाँ-निचला-बैक के कोने से मेल खाता है (केवल इसलिए कि OpenGL समन्वय प्रणाली में अक्षों को निर्देशित किया जाता है: OX - दाईं ओर, ओए - शीर्ष पर, OZ - हमारे लिए) । HOpenGL लाइब्रेरी के कार्यों का उपयोग करके Misc.BoxSide मॉड्यूल में चेहरे बनाए जाते हैं।

boxSide :: GLfVertex3 -> BoxSide -> IO ( )

boxSide ( GL . Vertex3 x y z ) SideTop = do
GL . texCoord texCoordDR >> GL . vertex ( vertex3 x y z )
GL . texCoord texCoordUR >> GL . vertex ( vertex3 x y 0 )
GL . texCoord texCoordUL >> GL . vertex ( vertex3 0 y 0 )
GL . texCoord texCoordDL >> GL . vertex ( vertex3 0 y z )

boxSide ( GL . Vertex3 x y z ) SideFront = do
GL . texCoord texCoordUR >> GL . vertex ( vertex3 x y z )
GL . texCoord texCoordUL >> GL . vertex ( vertex3 0 y z )
GL . texCoord texCoordDL >> GL . vertex ( vertex3 0 0 z )
GL . texCoord texCoordDR >> GL . vertex ( vertex3 x 0 z )

-- ... 6 .

boxSideList = [ SideTop , SideBottom , SideLeft , SideRight , SideRear , SideFront ]
boxSides boxDim = mapM_ ( boxSide boxDim )
allBoxSides boxDim = boxSides boxDim boxSideList

ठीक है, हम बल्कि सतही रूप से ग्राफसर्वर कार्यक्रम की सामान्य संरचना का पता लगा चुके हैं। मैं यह नहीं बताऊंगा कि प्रोग्राम के सर्वर भाग को कैसे व्यवस्थित किया जाता है, चित्रों को फ़ाइलों से कैसे डाउनलोड किया जाता है, चित्रों से बनावट कैसे बनाई जाती है, और तीसरे पक्ष की उपयोगिताओं का उपयोग कैसे किया जाता है। अभी भी बहुत काम है, विज़ुअलाइज़ेशन सर्वर लगभग 10 प्रतिशत तैयार है। काम इस तथ्य से जटिल है कि सभी हास्केल भाषा तत्व स्केच के लिए तैयार नहीं हैं। दृश्य के साथ कठिनाइयाँ हैं, जो स्क्रीनशॉट में बहुत स्पष्ट रूप से दिखाई देती हैं; सब के बाद, डिबगिंग बनावट आदर्श से बहुत दूर हैं। मैं ऑब्जेक्ट के पार बनावट के खिंचाव को सामान्य करना चाहता हूं, सजाने, कुछ अधिक सामंजस्यपूर्ण बनाना, डिजाइन पर काम करना। अभी भी फोंट और लाइन ड्राइंग की आवश्यकता है; भविष्य में, एरिटी के लिए फ़ंक्शन का विश्लेषण जोड़ा जाएगा, और यह एक और रीफैक्टरिंग, अन्य दृष्टिकोण, अन्य तरीके हैं। और फिर, सूक्ष्म तकनीक, मुश्किल एल्गोरिदम,स्मार्ट डेटा संरचनाएं, जो अकेले ओह विकसित करने के लिए कितनी कठिन है ... परियोजना बड़े पैमाने पर है, गहरी और सौंदर्य आनंद ला रही है। मैं सभी को उसमें शामिल होने के लिए आमंत्रित करता हूं: यह हास्केल में अभ्यास है, और बड़े कार्यक्रमों को डिजाइन करने में अनुभव, और ग्राफिक्स में ज्ञान, और एल्गोरिदम का अध्ययन। लेकिन सबसे बढ़कर, यह कला और रचनात्मकता है, जो हमारे जीवन को और अधिक सुंदर बनाती है।

कोड खुला है और GitHub पर स्थित है: github.com/graninas/GraphServer

यह एक क्रॉस-लेख है। ग्राफिक भाषा डिजाइन के लिए, हास्केल - डिजाइन लेख पढ़ें ।

पाठकों के लिए पीएस अनुरोध: यदि आप इस परियोजना में शामिल होने के इच्छुक हैं, तो कृपया मुझे पीएम से, आईसीक्यू में या मेल से संपर्क करें। Google पर मेल, उपनाम Habré पर समान है। यदि आप अन्य हास्केल प्रेमियों के बीच, या उन लोगों के बीच लेख को बढ़ावा दे सकते हैं, जो इस परियोजना में शामिल होकर इसका अध्ययन करना चाहते हैं। सामूहिक विकास के लिए, परियोजना और उपकरणों के कुछ अनुकूलन की आवश्यकता होगी। मैं इस मामले को पेशेवर तरीके से निभाने का वादा करता हूं।