K भाषा: डेटा से GUI प्रदर्शित करें

हमेशा की तरह, मैं एपीएल के बारे में बात कर रहा हूं, लेकिन के भाषा के पुराने संस्करण के बारे में, जिसमें एक जीयूआई शामिल था, जिसमें बहुत ही असामान्य दृष्टिकोण था।

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

चलिए शुरू करते हैं। एपीआई का एक संक्षिप्त विवरण जो हमारे लिए उपलब्ध है:

`show$`v show variable v `hide$`v hide variable v 

बस, इतना ही नहीं है। यानी मुख्य विशेषता यह है कि K में GUI मेमोरी में डेटा का प्रत्यक्ष मानचित्रण है। और अब इसे आसानी से कैसे काम करना है।

सबसे पहले, आइए सबसे सरल प्रयास करें:

 C:\>k K 3.1 2004-01-28 Copyright (C) 1993-2004 Kx Systems WIN32 2CPU 4030MB ws-1341.x.com 0 EVAL a:10 _draw 100 / list a 20 51 12 34 31 51 29 35 17 89 `show$`a 

सूची के साथ एक तालिका स्क्रीन पर दिखाई देती है।

कोई भी मान संपादन योग्य है, 35 से 135 को बदलें और यह परिवर्तन सूची में मूल्य को तुरंत बदल देता है:

  a 20 51 12 34 31 51 29 135 17 89 

यदि हम सूची में मूल्य बदलते हैं, तो यह इंटरफ़ेस में भी अपडेट किया जाता है।

एक छोटी सूची को सूचीबद्ध करना कोई समस्या नहीं है, लेकिन अगर बहुत अधिक डेटा हो तो क्या होगा? बहुत कुछ होने दो:

  a:(10 10000000) _draw 100 / 10   10   `show$`a 

कोई समस्या नहीं - सब कुछ जल्दी से प्रदर्शित, स्क्रॉल और संपादित किया जाता है।

हम स्तंभों को नाम देते हैं: यह तर्कसंगत है कि स्तंभ नाम कुंजी है, और सूची हैशटेबल से मान है:

  t:.((`a;10 _draw 100;);(`b;10 _draw 100)) `show$`t 

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

सबसे सरल उदाहरण: एक लेबल जोड़ना।

  val:10 val..l:"Input field" `show$`val 

निम्नलिखित विशेषताएं गिनी में प्रदर्शन को प्रभावित करती हैं:

  Display attributes (for variables that have class). x width integer(KFONT width) y height integer(KFONT height) a arrangement nest of symbols(class `form) o options list of symbols(class `radio) l label string kl click label string (also klr) Data-display attributes (for variables that have class `data). functions (monadic, constant or array) default e editable 0 or 1 1 f format string from data 11$(11.2$) g getdata data from string 0$ etc. u update update[old;new] : fg foreground integer(rrggbb) 0 bg background integer(rrggbb) -1(808080) expressions/events (strings) ins, del, f1 ... f12, ctrl_a ... ctrl_z k, kr, kk click, click right, double click(precludes e) c class(display) symbol `data(default) atom, list, dict, list of lists, dict of lists `chart as above where atom is list of y values `plot as above where atom is matrix of (x;y) values `check 0 or 1 `radio symbol (one of ..o; see below) `button expression or dictionary of expressions `form dictionary of entries of any class(incl. `form) 

मैं प्रत्येक विशेषताओं की विस्तृत विशेषताओं का वर्णन नहीं करूंगा, क्योंकि उनमें से अधिकांश विवरण से स्पष्ट हैं और मैं मैनुअल से समानता नहीं बनाना चाहता।

शब्दकोश बनाने में आसानी के लिए - भाषा आपको शब्दकोश के संदर्भ में काम करने की अनुमति देती है - अर्थात फ़ोल्डर्स और मॉड्यूल के साथ सादृश्य है जो सिर्फ हैश टेबल हैं:

  \d form val:100 incr:"val+:1" incr..l:"Increment" decr:"val-:1" decr..l:"Decrement" incr..c: decr..c: `button \d ^ form /  -   . .((`val;100;) (`incr "val+:1" .((`l;"Increment";) (`c;`button;))) (`decr "val-:1" .((`l;"Decrement";) (`c;`button;)))) 

विशेषता .. एक प्रदर्शन क्रम सेट करें।

  form..a:`incr`val`decr form.val..e:0 /   . 

.. ए किसी भी रूप का हो सकता है। उदाहरण के लिए, कुछ बटन जोड़ें।

  form.incr10:"val+:10" form.decr10:"val-:10" form.incr10..c : form.decr10..c: `button form..a:(,`incr;`decr10`val`incr10;,`decr) form..a (,`incr `decr10 `val `incr10 ,`decr) 

यानी मुद्दा यह है कि संपूर्ण जीयूआई भाषा की आदिम संरचनाओं द्वारा वर्णित है और उनका प्रत्यक्ष मानचित्रण है। आप हैश को हैश में शामिल कर सकते हैं, अर्थात्। फार्म को बनाने वाले तत्वों आदि में शामिल करें।

खैर, अब सबसे दिलचस्प, अर्थात् कुछ उदाहरण:

कैलक्यूलेटर:

 calc..a:(`exp `va`vb`vc`vd `n0`n1`n2`n3 `n4`n5`n6`n7 `n8`n9`lp`rp `fa`fs`fm`fd`fe `eval`clear) /     calc:@[_n;1_-1_ calc..a;:[;"exp,:(~_v)`l"]] / expressions calc[.;`l]:"abcd0123456789()+-*%:" / labels calc.eval:"exp:5:. exp" calc.clear:"exp:\"\"" calc[.;`c]:`button calc.exp:calc.exp..l:"" `show$`calc 

आप रेखांकन आकर्षित कर सकते हैं:

  p..c:`chart p:(5 5) _draw 100 `show$`p 

या अत्यधिक कलात्मक डब:

 `show$.,((`p;({[x] (2 30)_draw 30}'!10);.,(`c;`plot;))) 

और अब एक आश्चर्यजनक बात यह है कि एक बार अपनी संक्षिप्तता और स्पष्टता (पाठ्यक्रम के शब्दकोश के एक न्यूनतम ज्ञान के साथ) के साथ आश्चर्यचकित हो गया कि मैंने के गहरा अध्ययन शुरू करने का फैसला किया:

प्रसारण सर्वर:

 d:10 _draw 10 w:!0 / empty client list .mg:{w,:_w;d} / return data .mc:"w@:&~w=_w" / retain clients .ms:{. x;w 3:\:x;} / (log `l 5:,x) apply and broadcast \mi 1 listen on port 1 

ग्राहक:

 h:3:(`;1) / connect to server d:h 4:_n / get database d..t:"if[0=_w;h 3:(_v;_i;:;_v ._i)]" / send my updates `show$`d 

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

पाठ्यक्रम की तस्वीर यह नहीं बताती है कि यह गतिशीलता में कैसे काम करता है।