एल्म - त्वरित गाइड

एल्म एक कार्यात्मक प्रोग्रामिंग भाषा है। इसे 2012 में Evan Czaplicki द्वारा डिजाइन किया गया था।

एल्म का उपयोग विशेष रूप से वेब अनुप्रयोगों के सामने के छोर को डिजाइन करने के लिए किया जाता है।

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

एल्म प्रोग्रामिंग प्लेटफॉर्म के कुछ व्यावहारिक अनुप्रयोगों में शामिल हैं -

  • Games
  • Graphics
  • एकल पृष्ठ अनुप्रयोग

क्यों एल्म

एल्म फ्रंटेंड डेवलपर्स द्वारा सामना की जाने वाली अधिकांश सामान्य समस्याओं को समाप्त करता है। इसमें शामिल हैं -

कोई रनटाइम अपवाद नहीं है

एल्म एक स्टेटिकली टाइप्ड भाषा है। संकलन-समय पर सभी संभावित त्रुटियों को मान्य और सही किया जाता है। इससे रनटाइम अपवादों का होना संभव है।

डेवलपर के अनुकूल त्रुटि संदेश

अन्य प्रोग्रामिंग भाषाओं के विपरीत, एल्म के कंपाइलर को संकलन समय पर बहुत विशिष्ट और डेवलपर के अनुकूल त्रुटि संदेश प्रदान करने के लिए डिज़ाइन किया गया है। त्रुटि संदेशों में अनुशंसित डिज़ाइन दस्तावेज़ों के लिंक जैसे संकेत भी शामिल हैं।

टेस्ट करने में आसान

प्रत्येक एल्म फ़ंक्शन को अन्य सभी के अलगाव में परीक्षण किया जा सकता है। इससे एल्म में लिखे गए प्रोग्राम आसानी से टेस्ट किए जा सकते हैं।

स्वचालित शब्दार्थ संस्करण

एल्म संकुल के स्वचालित अर्थ वर्जनिंग को लागू करता है। यह सुनिश्चित करता है कि पैच परिवर्तन पहले से चल रहे एप्लिकेशन को क्रैश नहीं करता है।

पुन: प्रयोज्य कोड

एल्म फ़ंक्शन जावास्क्रिप्ट, पायथन या टाइपस्क्रिप्ट के कार्यों की तुलना में पुन: उपयोग करना स्वाभाविक है।

यह अध्याय विंडोज, मैक और लिनक्स प्लेटफार्मों पर एल्म को स्थापित करने के चरणों पर चर्चा करता है।

स्थानीय पर्यावरण सेटअप

एल्म को अपने स्थानीय वातावरण में स्थापित करने के लिए नीचे दिए गए चरणों पर विचार करें।

Step 1 − Install node

चूंकि एल्म को जावास्क्रिप्ट के लिए संकलित किया गया है, इसलिए लक्ष्य मशीन होनी चाहिए nodeस्थापित। सेटअप के चरणों के लिए TutorialsPoint NodeJS पाठ्यक्रम देखेंnode तथा npm

नोड सेटअप।

Step 2 − Install elm

एल्म स्थापित करने के लिए टर्मिनल पर निम्न कमांड निष्पादित करें। ध्यान दें कि इस पाठ्यक्रम को लिखने के समय एल्म का स्थिर संस्करण 0.18 था।

npm install -g [email protected]

स्थापना के बाद, एल्म के संस्करण को सत्यापित करने के लिए निम्न कमांड निष्पादित करें।

C:\Users\dell>elm --version
0.18.0

Step 2 − Install the Editor

यहां उपयोग किया जाने वाला विकास वातावरण विजुअल स्टूडियो कोड (विंडोज प्लेटफॉर्म) है।

विजुअल स्टूडियो कोड विजुअल स्टूडियो से एक ओपन सोर्स आईडीई है। यह मैक ओएस एक्स, लिनक्स और विंडोज प्लेटफार्मों के लिए उपलब्ध है। VSCode पर उपलब्ध है

विंडोज पर स्थापना

इस खंड में, हम विंडोज पर एल्म को स्थापित करने के चरणों पर चर्चा करेंगे।

डाउनलोड https://code.visualstudio.com/। विंडोज के लिए।

सेटअप प्रक्रिया शुरू करने के लिए VSCodeSetup.exe पर डबल-क्लिक करें। इसमें केवल एक मिनट लगेगा।

आप सीधे फ़ाइल → कमांड प्रॉम्प्ट में खोलें पर क्लिक करके फ़ाइल के पथ पर सीधे जा सकते हैं। इसी तरह, एक्सप्लोरर विकल्प में पता चलता है फ़ाइल एक्सप्लोरर में फ़ाइल को दिखाता है।

मैक ओएस एक्स पर स्थापना

विजुअल स्टूडियो कोड का मैक ओएस एक्स विशिष्ट इंस्टॉलेशन गाइड पर पाया जा सकता है VSCode स्थापना-मैक।

लिनक्स पर स्थापना

विजुअल स्टूडियो कोड के लिनक्स विशिष्ट इंस्टॉलेशन गाइड पर पाया जा सकता है VSCode स्थापना-लिनक्स।

Step 4 − Install the elm Extension

VSCode में एल्म एक्सटेंशन स्थापित करें जैसा कि नीचे दिखाया गया है।

एल्म REPL

REPL का मतलब Read Eval Print Loop है। यह एक विंडोज कंसोल या यूनिक्स / लिनक्स शेल जैसे कंप्यूटर वातावरण का प्रतिनिधित्व करता है जहां एक कमांड दर्ज किया जाता है और सिस्टम एक इंटरैक्टिव मोड में आउटपुट के साथ प्रतिक्रिया करता है।

एल्म एक REPL पर्यावरण के साथ बंडल में आता है। यह निम्नलिखित कार्य करता है -

  • पढ़ें - उपयोगकर्ता के इनपुट को पढ़ता है, इनपुट को एल्म डेटा-संरचना, और मेमोरी में स्टोर करता है।

  • Eval - डेटा संरचना को लेता है और उसका मूल्यांकन करता है।

  • प्रिंट - परिणाम प्रिंट करता है।

  • लूप - उपयोगकर्ता द्वारा बाहर निकलने तक उपरोक्त कमांड को लूप करता है। आदेश का उपयोग करें: REPL से बाहर निकलने और टर्मिनल पर वापस जाने के लिए।

REPL में दो नंबर जोड़ने का एक सरल उदाहरण नीचे दिखाया गया है -

VSCode टर्मिनल खोलें और कमांड elm REPL टाइप करें।

REPL टर्मिनल उपयोगकर्ता को कुछ इनपुट दर्ज करने की प्रतीक्षा करता है। निम्नलिखित अभिव्यक्ति 10 + 20 दर्ज करें। REPL पर्यावरण नीचे दिए गए इनपुट को संसाधित करता है -

  • उपयोगकर्ता से संख्या 10 और 20 पढ़ता है।

  • + ऑपरेटर का उपयोग करके मूल्यांकन करता है।

  • प्रिंट का परिणाम 30 है।

  • अगले उपयोगकर्ता इनपुट के लिए लूप्स। यहाँ हम पाश से बाहर निकलते हैं।

इस अध्याय में चर्चा की गई है कि एल्म में एक सरल कार्यक्रम कैसे लिखा जाए।

Step 1 − Create a directory HelloApp in VSCode

अब, एक फ़ाइल बनाएँ - Hello.elm इस निर्देशिका में।

उपरोक्त आरेख प्रोजेक्ट फ़ोल्डर दिखाता है HelloApp और टर्मिनल VSCode में खोला गया।

Step 2 − Install the necessary elm packages

एल्म में पैकेज प्रबंधक एल्म-पैकेज है । एल्म-लैंग / html पैकेज स्थापित करें । यह पैकेज हमें ब्राउज़र में एल्म कोड के आउटपुट को प्रदर्शित करने में मदद करेगा।

के लिए पार HelloApp फ़ाइल पर राइट क्लिक करके प्रोजेक्ट फोल्डर → VSCode में कमांड प्रॉम्प्ट में खोलें।

टर्मिनल विंडो में निम्न कमांड निष्पादित करें -

C:\Users\dell\Elm\HelloApp> elm-package install elm-lang/html

पैकेज स्थापित करने पर प्रोजेक्ट निर्देशिका में निम्नलिखित फाइलें / फ़ोल्डर जोड़े जाते हैं।

  • elm-package.json (फ़ाइल), प्रोजेक्ट मेटा डेटा संग्रहीत करता है
  • एल्म-सामान (फ़ोल्डर), बाहरी पैकेज संग्रहीत करता है

पैकेज सफलतापूर्वक स्थापित होने के बाद निम्न संदेश दिखाई देगा।

Step 3 − Add the following code to the Hello.elm file

-- importing Html module and the function text
import Html exposing (text)

-- create main method
main =
-- invoke text function
text "Hello Elm from TutorialsPoint"

उपरोक्त कार्यक्रम एक स्ट्रिंग संदेश प्रदर्शित करेगा Hello Elm from TutorialsPoint ब्राउज़र में।

इसके लिए, हमें फ़ंक्शन को आयात करना होगा text के अंदर Htmlमापांक। पाठ फ़ंक्शन का उपयोग ब्राउज़र में किसी भी स्ट्रिंग मान को प्रिंट करने के लिए किया जाता है। मुख्य विधि एक कार्यक्रम के लिए प्रवेश बिंदु है। मुख्य विधि invokes पाठ समारोह और इसे करने के लिए एक स्ट्रिंग मान से गुजरता है।

Step 4 − Compile the project

VSCode टर्मिनल विंडो में निम्न कमांड निष्पादित करें।

elm make Hello.elm

उपरोक्त कमांड का आउटपुट नीचे दिखाया गया है -

//update path to the proj folder in the command elm make
C:\Users\dell\elm\HelloApp>elm make Hello.elm
Success! Compiled 38 modules.
Successfully generated index.html

उपरोक्त कमांड एक उत्पन्न करेगा index.htmlफ़ाइल। एल्म कंपाइलर .elm फ़ाइल को जावास्क्रिप्ट में कनवर्ट करता है और इसे अंदर एम्बेड करता हैindex.html फ़ाइल।

Step 5 − Open the index.html in the browser

किसी भी ब्राउज़र में index.html फ़ाइल खोलें । आउटपुट नीचे दिखाया गया है -

एल्म में टिप्पणियाँ

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

एल्म निम्नलिखित प्रकार की टिप्पणियों का समर्थन करता है -

  • एकल-पंक्ति टिप्पणियाँ (-) - एक पंक्ति के अंत और उसके बीच के किसी भी पाठ को एक टिप्पणी के रूप में माना जाता है।

  • मल्टी-लाइन टिप्पणियां ({- -}) - इन टिप्पणियों में कई लाइनें हो सकती हैं।

चित्रण

-- this is single line comment

{- This is a
   Multi-line comment
-}

लाइन्स और इंडेंटेशन

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

module ModuleIf exposing (..)
x = 0

function1 =
   if x > 5 then
      "x is greater"
   else
      "x is small"

हालाँकि, निम्न ब्लॉक एक त्रुटि उत्पन्न करता है -

-- Create file ModuleIf.elm
module ModuleIf exposing (..)
x = 0

function1 =
   if x > 5 then
      "x is greater"
         else --Error:else indentation not at same level of if statement
      "x is small"

इस प्रकार, एल्म में समान संख्या में रिक्त स्थानों के साथ सभी निरंतर लाइनें एक ब्लॉक का निर्माण करेंगी।

C:\Users\admin>elm repl
---- elm-repl 0.18.0 -----------------------------------------------------------
   :help for help, :exit to exit, more at 
   <https://github.com/elm-lang/elm-repl>
   ---------------------------------------
   -----------------------------------------

> import ModuleIf exposing(..) -- importing module from ModuleIf.elm file
>function1 -- executing function from module
-- SYNTAX PROBLEM ---------------------------------------------------

I need whitespace, but got stuck on what looks like a new declaration. 
You are either missing some stuff in the declaration above or just need to add some spaces here:
7| else
   ^
I am looking for one of the following things:

   whitespace

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

एल्म एक स्टेटिकली टाइप्ड भाषा है। एल्म के प्रकार हैं जो अन्य भाषाओं के समान हैं।

संख्या

संख्या डेटा प्रकार संख्यात्मक मान का प्रतिनिधित्व करता है। एल्म प्रकार प्रणाली निम्नलिखित संख्यात्मक प्रकारों का समर्थन करती है -

अनु क्रमांक। प्रकार उदाहरण
1 नंबर - किसी भी नंबर को स्टोर करता है 7 नंबर प्रकार है
2 फ्लोट - भंडार भिन्नात्मक मूल्य 7/2 फ्लोट के रूप में 3.5 परिणाम देता है
3 इंट - गैर-आंशिक मूल्यों को संग्रहीत करता है 7 // 2 इंट के रूप में 3 परिणाम देता है

प्रकार संख्या आंशिक और गैर-भिन्न दोनों मानों को समायोजित करती है। एल्म आरईपीएल खोलें और नीचे दिए गए उदाहरणों की कोशिश करें -

C:\Users\admin>elm repl
---- elm-repl 0.18.0 
---------------------------------------------
--------------
:help for help, :exit to exit, more at <https://github.com/elm-lang/elm-repl>
------------------------------------------
--------------------------------------
> 7
7 : number
> 7/2
3.5 : Float
> 7//2
3 : Int
>

स्ट्रिंग और चार

स्ट्रिंग डेटा प्रकार वर्णों के क्रम का प्रतिनिधित्व करने के लिए प्रयोग किया जाता है। चार डेटा प्रकार एकल वर्ण का प्रतिनिधित्व करने के लिए किया जाता है। स्ट्रिंग मानों को एक दोहरे उद्धरण में परिभाषित किया गया है "और चार मान एक उद्धरण के भीतर संलग्न हैं '।

अनु क्रमांक। प्रकार उदाहरण
1 स्ट्रिंग - पात्रों का एक क्रम संग्रहीत करता है "TutorialsPoint"
2 चार - स्टोर भिन्नात्मक मूल्य 'टी'

एल्म आरईपीएल खोलें और नीचे दिए गए उदाहरणों की कोशिश करें -

C:\Users\admin>elm repl
---- elm-repl 0.18.0 ---------------------------------------
--------------------
:help for help, :exit to exit, more at <https://github.com/elm-lang/elm-repl>
--------------------------------------
------------------------------------------
> "TutorialsPoint"
"TutorialsPoint" : String
> 'T'
'T' : Char

बूल

एल्म में बूल डेटा प्रकार केवल दो मूल्यों का समर्थन करता है - सच और गलत। बूल शब्द का उपयोग बूलियन मान का प्रतिनिधित्व करने के लिए किया जाता है।

अनु क्रमांक। प्रकार उदाहरण
1 बूल - स्टोर वैल्यू ट्रू या फाल्स 1 == 1 रिटर्न सही

एल्म आरईपीएल खोलें और नीचे दिए गए उदाहरणों की कोशिश करें -

C:\Users\dell\elm>elm repl
---- elm-repl 0.18.0 -----------------------------------
------------------------
:help for help, :exit to exit, more at <https://github.com/elm-lang/elm-repl>
----------------------------------------
----------------------------------------
> True
True : Bool
> False
False : Bool
> 1==1
True : Bool
> 1==2
False : Bool
> 1 /= 2 -- not equal
True : Bool
> not True
False : Bool
> not False
True : Bool

कस्टम प्रकार

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

निम्न उदाहरण दिखाता है कि कस्टम प्रकार कैसे बनाया जाए।

> type PaymentMode = CreditCard|NetBanking|DebitCard
> payment1 = CreditCard
CreditCard : Repl.PaymentMode
> payment2 = DebitCard
DebitCard : Repl.PaymentMode
> payment3 = UPI
-- NAMING ERROR ---------------------------------------------- repl-temp-000.elm

Cannot find variable `UPI`

7| payment3 = UPI

उपरोक्त उदाहरण में, हमने एक भुगतान मोड कस्टम प्रकार बनाया। वेरिएबल्स पेमेंट 1 और पेमेंट 2 को पेमोड मानों को सौंपा गया है। यदि वैरिएबल को असाइन किया गया मान, PaymentMode प्रकार द्वारा परिभाषित किसी भी मान से मेल नहीं खाता है, तो अनुप्रयोग सिंटैक्स त्रुटि को फेंक देगा।

संरचित डेटा प्रकार

संरचित डेटा प्रकारों का उपयोग संरचित प्रारूप में कई मूल्यों को संग्रहीत करने के लिए किया जा सकता है। एल्म निम्नलिखित संरचित डेटा प्रकारों का समर्थन करता है -

  • Tuple
  • List
  • Record
  • Record

इन पर आगामी अध्यायों में विस्तार से चर्चा की जाएगी।

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

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

परिवर्तनीय नामकरण-नियम

इस खंड में, हम चर नामकरण-नियमों के बारे में जानेंगे।

  • परिवर्तनीय नाम अक्षरों, अंकों और अंडरस्कोर वर्ण से बना हो सकते हैं।
  • परिवर्तनीय नाम एक अंक से शुरू नहीं हो सकते हैं। यह या तो एक पत्र या एक अंडरस्कोर से शुरू होना चाहिए।
  • ऊपरी और निचले अक्षर अलग हैं क्योंकि एल्म केस-संवेदी है।

एल्म में चर घोषणा

एल्म में एक चर घोषित करने के लिए वाक्य रचना नीचे दिया गया है -

सिंटेक्स 1

variable_name:data_type = value

":" वाक्यविन्यास (प्रकार एनोटेशन के रूप में जाना जाता है) का उपयोग चर को डेटा प्रकार के साथ जोड़ने के लिए किया जाता है।

सिंटैक्स 2

variable_name = value-- no type specified

एल्म में एक चर घोषित करते समय डेटा प्रकार वैकल्पिक है। इस स्थिति में, चर का डेटा प्रकार इसके द्वारा निर्दिष्ट मान से अनुमानित है।

चित्रण

यह उदाहरण एक एल्म प्रोग्राम लिखने के लिए VSCode संपादक का उपयोग करता है और एल्म उत्तर का उपयोग करके इसे निष्पादित करता है।

Step 1 − Create a project folder - VariablesApp. Create a Variables.elm file in the project folder.

फ़ाइल में निम्न सामग्री जोड़ें।

module Variables exposing (..) //Define a module and expose all contents in the module
message:String -- type annotation
message = "Variables can have types in Elm"

कार्यक्रम एक मॉड्यूल चर को परिभाषित करता है। मॉड्यूल का नाम एल्म प्रोग्राम फ़ाइल के समान होना चाहिए। मॉड्यूल में सभी घटकों को उजागर करने के लिए (..) सिंटैक्स का उपयोग किया जाता है।

प्रोग्राम स्ट्रिंग के एक चर संदेश की घोषणा करता है ।

Step 2 − Execute the program.

  • एल्म REPL को खोलने के लिए VSCode टर्मिनल में निम्न कमांड टाइप करें।
elm repl
  • REPL टर्मिनल में निम्नलिखित एल्म कथन निष्पादित करें।
> import Variables exposing (..) --imports all components from the Variables module
> message --Reads value in the message varaible and prints it to the REPL 
"Variables can have types in Elm":String
>

चित्रण

निम्नलिखित उदाहरण की कोशिश करने के लिए एल्म आरईपीएल का उपयोग करें।

C:\Users\dell\elm>elm repl
---- elm-repl 0.18.0 ---------------------------------------
--------------------
:help for help, :exit to exit, more at <https://github.com/elm-lang/elm-repl>
-------------------------------------
------------------------------------------
> company = "TutorialsPoint"
"TutorialsPoint" : String
> location = "Hyderabad"
"Hyderabad" : String
> rating = 4.5
4.5 : Float

यहाँ, चर कंपनी और स्थान स्ट्रिंग चर हैं और रेटिंग एक फ्लोट चर है।

एल्म आरईपीएल चर के लिए प्रकार एनोटेशन का समर्थन नहीं करता है। यदि चर घोषित करते समय डेटा प्रकार को शामिल किया जाता है, तो निम्न उदाहरण एक त्रुटि फेंकता है।

C:\Users\dell\elm>elm repl
---- elm-repl 0.18.0 -----------------------------------------
------------------
:help for help, :exit to exit, more at <https://github.com/elm-lang/elm-repl>
----------------------------------------
----------------------------------------
> message:String
-- SYNTAX PROBLEM -------------------------------------------- repl-temp-000.elm

A single colon is for type annotations. Maybe you want :: instead? Or maybe you
are defining a type annotation, but there is whitespace before it?

3| message:String
^

Maybe <http://elm-lang.org/docs/syntax> can help you figure it out.

एल्म आरईपीएल का उपयोग करते समय एक लाइन ब्रेक डालने के लिए, नीचे दिखाए गए अनुसार \ सिंटैक्स का उपयोग करें -

C:\Users\dell\elm>elm repl
---- elm-repl 0.18.0 --------------------------------------
---------------------
:help for help, :exit to exit, more at <https://github.com/elm-lang/elm-repl>
------------------------------------------
--------------------------------------
> company \ -- firstLine
| = "TutorialsPoint" -- secondLine
"TutorialsPoint" : String

एक ऑपरेटर कुछ फ़ंक्शन को परिभाषित करता है जो डेटा पर किया जाएगा। जिन मूल्यों पर ऑपरेटर काम करते हैं उन्हें ऑपरेंड कहा जाता है। निम्नलिखित अभिव्यक्ति पर विचार करें

7 + 5 = 12

यहां, मान 7, 5 और 12 ऑपरेंड हैं, जबकि + और = ऑपरेटर हैं।

एल्म में प्रमुख ऑपरेटरों के रूप में वर्गीकृत किया जा सकता है -

  • Arithmetic
  • Relational
  • Logical

अंकगणितीय आपरेटर

मान लें कि चर a और b क्रमशः 7 और 2 हैं।

उदाहरण दिखाएं

अनु क्रमांक। ऑपरेटर विवरण उदाहरण
1 + (जोड़) ऑपरेंड का योग देता है a + b 9 है
2 - (घटाव) मूल्यों का अंतर लौटाता है एब 5 है
3 * (गुणा) मूल्यों का उत्पाद लौटाता है a * b 14 है
4 / (फ्लोट डिवीजन) विभाजन ऑपरेशन करता है और एक फ्लोट भागफल देता है a / b 3.5 है
5 // (पूर्णांक विभाजन) विभाजन ऑपरेशन करता है और पूर्णांक भागफल लौटाता है ए / बी 3 है
6 % (मापांक) विभाजन ऑपरेशन करता है और शेष को लौटाता है अ% ब 1 ह

संबंधपरक संकारक

रिलेशनल ऑपरेटर्स दो संस्थाओं के बीच संबंधों के प्रकार का परीक्षण या परिभाषित करते हैं। इन ऑपरेटरों का उपयोग दो या अधिक मूल्यों की तुलना करने के लिए किया जाता है। रिलेशनल ऑपरेटर्स एक बूलियन मान लौटाते हैं, अर्थात सही या गलत।

मान है कि a का मान 10 है और b का मान 20 है।

उदाहरण दिखाएं

अनु क्रमांक। ऑपरेटर विवरण उदाहरण
1 > से अधिक (a> b) गलत है
2 < के मुकाबले कम (a <b) सत्य है
3 > = इससे बड़ा या इसके बराबर (a> = b) गलत है
4 <= से कम या उसके बराबर (अ <= ख) सत्य है
5 == समानता (a == b) गलत है
6 ! = बराबर नहीं (a! = b) सत्य है

तुलनीय प्रकार

तुलना संचालक जैसे = = या <तुलनीय प्रकार के साथ काम करते हैं। इन्हें संख्याओं, वर्णों, तारों और सूचियों, टुपल्स के रूप में परिभाषित किया गया है। ऑपरेटर के दोनों किनारों पर तुलनीय प्रकार समान होना चाहिए।

अनु क्रमांक। तुलनीय प्रकार उदाहरण
1 संख्या 7> 2 सत्य देता है
2 चरित्र 'a' == 'b' गलत देता है
3 तार "हैलो" == "हैलो" सच देता है
4 टपल (1, "वन") == (1, "वन") ट्रू देता है
5 सूची [१,२] == [१,२] सत्य देता है

एल्म REPL खोलें और नीचे दिखाए गए उदाहरणों की कोशिश करें -

C:\Users\admin>elm repl
---- elm-repl 0.18.0 -----------------------------------------------------------
:help for help, :exit to exit, more at <https://github.com/elm-lang/elm-repl>
--------------------------------------------------------------------------------
> 7>2
True : Bool
> 7.0>2
True : Bool
> 7.0<2.0
False : Bool
> 'a' > 'b'
False : Bool
> 'a' < 'b'
True : Bool
> "a" < "b"
True : Bool
> (1,2) > (2,3)
False : Bool
> ['1','3'] < ['2','1']
True : Bool
>

लॉजिकल ऑपरेटर्स

लॉजिकल ऑपरेटर्स का उपयोग दो या दो से अधिक स्थितियों को मिलाने के लिए किया जाता है। लॉजिकल ऑपरेटर्स भी बूलियन वैल्यू लौटाते हैं।

उदाहरण दिखाएं

अनु क्रमांक। ऑपरेटर विवरण उदाहरण
1 && ऑपरेटर तभी सही लौटाता है, जब सभी अभिव्यक्तियाँ सही हो (10> 5) && (20> 5) सही है
2 || यदि ऑपरेटर निर्दिष्ट रिटर्न में से कम से कम एक सही है तो ऑपरेटर सही लौटाता है (१० <५) || (20> 5) सही है
3 नहीं ऑपरेटर अभिव्यक्ति के परिणाम का प्रतिलोम लौटाता है। उदाहरण के लिए:! (> 5) गलत है। नहीं (10 <5) सही है
4 XOR ऑपरेटर तभी सही लौटाता है, जब उसका एक इनपुट सही हो। यदि दोनों भाव सही हैं, तो ऑपरेटर गलत देता है। xor (10> 5) (20> 5) गलत है

निर्णय लेने की संरचनाओं के लिए आवश्यक है कि प्रोग्रामर एक या एक से अधिक परिस्थितियों को कार्यक्रम द्वारा मूल्यांकन या परीक्षण करने के लिए निर्दिष्ट करता है, साथ ही एक बयान या बयानों के साथ निष्पादित किया जाता है यदि स्थिति सच होने के लिए निर्धारित होती है, और वैकल्पिक रूप से, निष्पादित होने के लिए अन्य बयान हालत झूठी होने के लिए निर्धारित है।

नीचे दिखाया गया है, अधिकांश प्रोग्रामिंग भाषाओं में पाया जाने वाला एक विशिष्ट निर्णय लेने की संरचना का सामान्य रूप है

निर्देशों को निष्पादित करने से पहले एक निर्णय लेने वाली निर्माण एक स्थिति का मूल्यांकन करता है। एल्म में निर्णय लेने वाले निर्माणों को निम्नानुसार वर्गीकृत किया गया है -

अनु क्रमांक। बयान विवरण
1 अगर ... तो ... और बयान यदि कथन में एक बूलियन अभिव्यक्ति शामिल है, जिसके बाद यदि अभिव्यक्ति सही हो जाती है और जिसे अभिव्यक्ति के गलत होने पर निष्पादित किया जाता है, तो उसे निष्पादित किया जाता है।
2 बयान अगर नेस्टेड आप एक का उपयोग कर सकते हैं ... तो ... दूसरे के अंदर अगर।
3 मामला बयान मानों की सूची के विरुद्ध एक चर के मूल्य का परीक्षण करता है।

यदि ... तो ... और कथन

if…thenकोड के एक ब्लॉक निष्पादित होने से पहले निर्माण एक स्थिति का मूल्यांकन करता है। यदि बूलियन अभिव्यक्ति सही का मूल्यांकन करती है, तो तत्कालीन विवरण के अंदर कोड का ब्लॉक निष्पादित किया जाएगा। यदि बूलियन अभिव्यक्ति झूठी का मूल्यांकन करती है, तो अन्य विवरण के अंदर कोड का ब्लॉक निष्पादित किया जाएगा।

अन्य प्रोग्रामिंग भाषाओं के विपरीत, एल्म में हमें दूसरी शाखा प्रदान करनी चाहिए। अन्यथा, एल्म एक त्रुटि फेंक देगा।

वाक्य - विन्यास

if boolean_expression then statement1_ifTrue else statement2_ifFalse

चित्रण

REPL टर्मिनल में निम्न उदाहरण का प्रयास करें।

> if 10>5 then "10 is bigger" else "10 is small"
"10 is bigger" : String

नेस्टेड इफ

नेस्टेड यदि कथन कई स्थितियों के परीक्षण के लिए उपयोगी है। यदि कथन नीचे दिया गया है, तो एक नेस्टेड का सिंटैक्स -

if boolean_expression1 then statement1_ifTrue else if boolean_expression2 then statement2_ifTrue else statement3_ifFalse

चित्रण

एल्म आरईपीएल में निम्नलिखित उदाहरण का प्रयास करें -

> score=80
80 : number
> if score>=80 then "Outstanding" else if score > = 70 then "good" else "average"
"Outstanding" : String

केस का बयान

केस स्टेटमेंट का इस्तेमाल अगर और स्टेटमेंट को सरल बनाने के लिए किया जा सकता है। केस स्टेटमेंट का सिंटैक्स नीचे दिया गया है -

case variable_name of
   constant1 -> Return_some_value
   constant2 -> Return_some_value
   _ -> Return_some_value if none of the above values match

यदि एक वैरिएबल का मान स्थिरांक के पूर्वनिर्धारित सेट से मेल खाता है और संबंधित मान लौटाता है, तो केस स्टेटमेंट चेक करता है। ध्यान दें कि प्रत्येक मामले द्वारा लौटाया गया मान एक ही प्रकार का होना चाहिए। अगर चर मान किसी दिए गए स्थिरांक से मेल नहीं खाता है, तो नियंत्रण को * डिफ़ॉल्ट * (// _ द्वारा चिह्नित) पास कर दिया जाता है और संबंधित मान वापस कर दिया जाता है।

चित्रण

एल्म आरईपीएल में निम्नलिखित उदाहरण का प्रयास करें -

> n = 10
10 : number
> case n of \
| 0 -> "n is Zero" \
| _ -> "n is not Zero"
"n is not Zero" : String

उपरोक्त कोड स्निपेट यह जांचता है कि क्या n का मान शून्य है। नियंत्रण को डिफ़ॉल्ट रूप से पास किया जाता है, जो "n शून्य नहीं है" स्ट्रिंग लौटाता है।

एल्म एक कार्यात्मक प्रोग्रामिंग भाषा है। एल्म पारंपरिक लूपिंग निर्माणों के विकल्प के रूप में पुनरावृत्ति की अवधारणा का उपयोग करता है।

यह अध्याय पुनरावृत्ति की अवधारणा पर चर्चा करता है।

प्रत्यावर्तन

कुछ कंप्यूटर प्रोग्रामिंग भाषाएं खुद को कॉल करने के लिए एक मॉड्यूल या फ़ंक्शन की अनुमति देती हैं। इस तकनीक को रिकर्सन के रूप में जाना जाता है।

चित्रण

इस कार्यक्रम में, हम देखेंगे कि पांच बार हैलो प्रदर्शित करने के लिए रिकर्सन का उपयोग कैसे करें।

Step 1 − Create a file Loop.elm

एक मॉड्यूल लूप बनाएं और एक फ़ंक्शन को परिभाषित करें sayHello। Function sayHello इनपुट के रूप में पूर्णांक मान लेता है और एक स्ट्रिंग मान देता है।

module Loop exposing(..)
//function signature
sayHello:Int ->String
//function implementation
sayHello n =
   case n of
   1 -> "Hello:1 "
   _ -> "Hello:" ++ toString (n) ++ " " ++ sayHello(n-1)

फ़ंक्शन कहता हैहेल्लो जाँचता है कि क्या पैरामीटर पारित हुआ है 1. यदि पैरामीटर 1 है, तो फ़ंक्शन वापस आ जाएगा, अन्यथा यह एक स्ट्रिंग बना देगा हैलो और उसी फ़ंक्शन को कॉल करेगा।

Step 2 − Invoke sayHello from REPL

वर्तमान प्रोजेक्ट फ़ोल्डर (Loop.elm फ़ाइल का स्थान) से एल्म REPL खोलें।

//import the module Loop
> import Loop exposing(..)
//invoke the sayHello function with parameter value as 5
> sayHello 5
"Hello:5 Hello:4 Hello:3 Hello:2 Hello:1 Hello:0 " : String
>

चित्रण

निम्न उदाहरण पुनरावृत्ति का उपयोग करके n संख्याओं का योग प्रिंट करता है।

> sumOfNos n =\
| if n==0 then 0 \
| else (n) + sumOfNos (n-1)
<function> : number -> number1

एल्म आरईपीएल में, हमने एक फ़ंक्शन समऑफ़नोस बनाया जो एक इनपुट संख्या लेता है और 0 से उस संख्या तक सभी संख्याओं को जमा करता है।

उदाहरण के लिए, यदि हम 5 के रूप में इनपुट पास करते हैं, तो यह 1 + 2 + 3 + 4 + 5 का योग करेगा जो कि 15 है ।

> ssumOfNos 5
15 : number

कार्यक्रम का आउटपुट ऊपर दिखाया गया है।

कार्य एक एल्म कार्यक्रम के निर्माण खंड हैं। एक फ़ंक्शन किसी विशिष्ट कार्य को करने के लिए कथनों का एक समूह है।

फ़ंक्शंस प्रोग्राम को कोड के तार्किक ब्लॉकों में व्यवस्थित करते हैं। एक बार परिभाषित करने के बाद, फ़ंक्शंस को एक्सेस कोड कहा जा सकता है। यह कोड को पुन: प्रयोज्य बनाता है। इसके अलावा, फ़ंक्शन प्रोग्राम के कोड को पढ़ना और बनाए रखना आसान बनाते हैं।

एक समारोह का उपयोग करने के लिए कदम

एक फ़ंक्शन का उपयोग करने के तीन चरण हैं -

समारोह घोषणा

एक फ़ंक्शन घोषणापत्र एक फ़ंक्शन के नाम, रिटर्न प्रकार और मापदंडों के बारे में संकलक को बताता है। फ़ंक्शन घोषित करने का सिंटैक्स नीचे दिया गया है -

fn_name:data_type_of_the_parameters ->return_type

फ़ंक्शन की घोषणा निम्नलिखित निर्दिष्ट करती है -

  • समारोह का नाम।

  • डेटा प्रकार के पैरामीटर। यह वैकल्पिक है क्योंकि फ़ंक्शन में पैरामीटर हो सकते हैं या नहीं भी हो सकते हैं।

  • मान का डेटा प्रकार, जो फ़ंक्शन वापस आ जाएगा। एल्म में फ़ंक्शंस को हमेशा एक मूल्य वापस करना चाहिए क्योंकि एल्म एक कार्यात्मक प्रोग्रामिंग भाषा है। अन्य प्रोग्रामिंग भाषाओं के कार्यों के विपरीत, एल्म फ़ंक्शन किसी मान को वापस करने के लिए रिटर्न कीवर्ड का उपयोग नहीं करते हैं।

फंक्शन डेफिनिशन या फंक्शन इम्प्लीमेंटेशन

एक फ़ंक्शन परिभाषा फ़ंक्शन का वास्तविक निकाय प्रदान करती है। एक फ़ंक्शन परिभाषा निर्दिष्ट करती है कि एक विशिष्ट कार्य कैसे किया जाएगा। किसी फ़ंक्शन को परिभाषित करने का सिंटैक्स नीचे दिया गया है -

fn_name parameter1 parameter2 = statements

एक समारोह में आमंत्रित करना या कॉल करना

एक फ़ंक्शन को इसे निष्पादित करने के लिए बुलाया जाना चाहिए। किसी फ़ंक्शन को कॉल करने का सिंटैक्स नीचे दिया गया है -

fn_name parameter1 parameter2

चित्रण

निम्नलिखित कोड एक फ़ंक्शन अभिवादन को परिभाषित करता है। फ़ंक्शन एक स्ट्रिंग "हैलो" देता है।

> greet = \
| if True then \
| "Hello" \
| else \
| "GoodBye"
"Hello" : String
> greet
"Hello" : String

परिमेय कार्य

पैरामीटर एक फ़ंक्शन के मानों को पारित करने के लिए एक तंत्र है। फ़ंक्शन मंगलाचरण के समय पैरामीटर के मान फ़ंक्शन में पास किए जाते हैं।

चित्रण १

निम्न उदाहरण एक फ़ंक्शन को परिभाषित करता है fn_add । फ़ंक्शन दो संख्याओं को पैरामीटर के रूप में स्वीकार करता है और उनकी राशि लौटाता है। एल्म आरईपीएल में निम्नलिखित का प्रयास करें -

> fn_add x y = x+y
<function> : number -> number -> number
> fn_add 10 20
30 : number

चित्रण २

निम्नलिखित उदाहरण एक फ़ंक्शनहेल्लो को परिभाषित करता है। SayHello फ़ंक्शन पैरामीटर के रूप में स्ट्रिंग मान को स्वीकार करता है और वापस करता है।

> sayHello name = "Hello "++ name
<function> : String -> String
> sayHello "Tutorialspoint"
"Hello Tutorialspoint" : String
>

पाइप ऑपरेटर

पाइप ऑपरेटर को समझने के लिए |>, आइए एक उदाहरण पर विचार करें जहां हमारे पास अलग-अलग तारों की सूची है ["a", "b", "c"] । अब हमें एक ही तार की आवश्यकता है, जिसे अलग किया जाता है -

निम्न उदाहरण दिखाता है कि कैसे String.join के साथ ऐसा करना है

> String.join "-" ["a","b","c","d","e","f"]
"a-b-c-d-e-f" : String

पाइप ऑपरेटर का उपयोग करके एक ही कार्रवाई की जा सकती है |> पाइप ऑपरेटर का उपयोग कई फ़ंक्शन कॉल को चेन करने के लिए किया जा सकता है।

> ["a","b","c","d","e","f"] |> String.join "-"
"a-b-c-d-e-f" : String
> ["a","b","c","d","e","f"] |> List.reverse |> String.join "-"
"f-e-d-c-b-a" : String

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

यूनिकोड वर्णों के एक क्रम को एक स्ट्रिंग कहा जाता है। एल्म में, स्ट्रिंग दोहरे उद्धरण चिह्नों में संलग्न हैं । एक स्ट्रिंग पाठ का एक हिस्सा है जैसा कि नीचे दिखाया गया है।

> "TutorialsPoint"
"TutorialsPoint" : String
> location = "Hyderabad" --variable
"Hyderabad" : String
> location
"Hyderabad" : String
>

String Functions

Some common functions that can be used to query or manipulate string values are given below. Use REPL to try the examples given below.

Sr. No Method Description
1 isEmpty : String -> Bool checks string is empty
2 reverse : String -> String reverses a input string
3 length : String -> Int returns an integer length
4 append :String -> String -> String appends two string and returns a new string
5 append :String -> Sconcat : List String -> String appends a list of strings and returns a new string
6 split : String -> String -> List String splits an input string using a given separator, returns a string list
7 slice : Int -> Int -> String -> String returns a substring given a start , end index and input string
8 contains : String -> String -> Bool returns true if second string contains the first one
9 toInt : String -> Result.Result String Int parses a String to Integer
10 toInt : String -> Result.Result String Int parses a String to Integer
11 toFloat : String -> Result.Result String Float parses a String to float
12 fromChar : Char -> String creates a string from a given character.
13 toList : String -> List Char converts string to list of characters
14 fromList : List Char -> String converts a list of characters into a String
15 toUpper : String -> String converts input string to upper case
16 trim : String -> String gets rid of whitespace on both sides of a string.
17 filter : (Char -> Bool) -> String -> String filters set of characters from input string
18 map : (Char -> Char) -> String -> String transforms every character in an input string

isEmpty

This function can be used to determine if a string is empty. This function returns True if the supplied String is empty.

Syntax

String.isEmpty String_value

To check the signature of function, type the following in elm REPL −

> String.isEmpty
<function> : String -> Bool

Signature of the function shows Bool as return type and input type as String −

Illustration

> String.isEmpty ""
True : Bool
> String.isEmpty "Tutorialspoint"
False : Bool
> location = "Hyderabad"
"Hyderabad" : String
> String.isEmpty location
False : Bool

reverse

This function reverses a string.

Syntax

String.reverse String_value

To check the signature of function, type the following in elm REPL −

> String.reverse
<function> : String -> String

Signature of the function shows String as return type and input type as String −

Illustration

> String.reverse "TutorialsPoint"
"tnioPslairotuT" : String

length

This function returns the length of a string.

Syntax

String.length String_value

To check the signature of function, type the following in elm REPL −

> String.length
<function-> : String -> Int

Signature of the function shows Int as return type and input type as String.

Illustration

> String.length "Mohtashim"
9 : Int

append

This function returns a new string by appending two strings.

Syntax

String.append String_value1 String_value2

To check the signature of function, type the following in elm REPL −

> String.append
<function-> : String -> String -> String

Signature of shows two String input parameters and one String output parameter

Illustration

> String.append "Tutorials" "Point"
TutorialsPoint : String

concat

This function returns a new string by concatenating many strings into one.

Syntax

String.concat [String1,String2,String3]

To check the signature of function, type the following in elm REPL −

> String.concat
<function> : List String -> String

Signature of shows a List of String input parameter and String return type

Illustration

> String.concat ["Hello","Tutorials","Point"]
HelloTutorialsPoint : String

split

This function splits a string using a given separator.

Syntax

String.split string_seperator String_value

To check the signature of function, type the following in elm REPL −

> String.split
<function> : String -> String -> List String

Signature of shows two input String parameters and output as a list of string type.

Illustration

> String.split "," "Hello,Tutorials,Point"
["Hello","Tutorials","Point"] : List String

slice

This function returns a substring given a start and end index. Negative indexes are taken starting from the end of the list. The value of the index starts from zero.

Syntax

String.slice start_index end_index String_value

To check the signature of function, type the following in elm REPL −

> String.slice
<function> : Int -> Int -> String -> String

Signature of shows three input parameter and one return type.

Illustration

> String.slice 0 13 "TutorialsPoint"
"TutorialsPoin" : String

contains

This function returns a True if the second string contains the first one.

Syntax

String.contains string1 string2

To check the signature of function, type the following in elm REPL −

> String.contains
<function> : String -> String -> Bool

Signature of shows bool return type and two input parameters

Illustration

> String.contains "Point" "TutorialsPoint"
True : Bool

toInt

This function converts a string into an int.

Syntax

String.toInt string_value

To check the signature of function, type the following in elm REPL −

> String.toInt
<function> : String -> Result.Result String Int

Since toInt can return error, the return type is Result, which is String or Int.

Illustration

> String.toInt "20"
Ok 20 : Result.Result String Int
> String.toInt "abc"
Err "could not convert string 'abc' to an Int" : Result.Result String Int

toFloat

This function converts a string into a float.

Syntax

String.toFloat string_value

To check the signature of function, type the following in elm REPL −

> String.toFloat
<function> : String -> Result.Result String Float

Since toFloat can return error, the return type is Result, which is String or Float.

Illustration

> String.toFloat "20.50"
Ok 20.5 : Result.Result String Float
> String.toFloat "abc"
Err "could not convert string 'abc' to a Float" : Result.Result String Float

fromChar

This function creates a string from a given character.

Syntax

String.fromChar character_value

To check the signature of function type following in elm REPL −

> String.fromChar
<function> : Char -> String

The signature shows String as return type and input as Char type

Illustration

> String.fromChar 'c'
"c" : String

toList

This function converts a string to a list of characters.

Syntax

String.toList string_value

To check the signature of function, type the following in elm REPL −

> String.toList
<function> : String -> List Char

The signatures shows function returns a list of characters and takes input a string.

Illustration

> String.toList "tutorialspoint"
['t','u','t','o','r','i','a','l','s','p','o','i','n','t'] : List Char

fromList

This function converts a list of characters into a String.

Syntax

String.fromList list_of_characters

To check the signature of function, type the following in elm REPL −

> String.fromList
<function> : List Char -> String

The signatures shows function returns a list of characters and takes input a string.

Illustration

> String.fromList ['h','e','l','l','o']
"hello" : String

toUpper

This function converts a string to all upper case.

Syntax

String.toUpper String_value

To check the signature of function, type the following in elm REPL −

> String.toUpper
<function> : String -> String

Illustration

> String.toUpper "hello"
"HELLO" : String

toLower

This function converts a string to all lower case.

Syntax

String.toLower String_value

To check the signature of function, type the following in elm REPL −

> String.toLower
<function> : String -> String

Illustration

> String.toLower "AbCd"
"abcd" : String

trim

This function gets rid of whitespace on both sides of a string.

Syntax

String.trim String_value

To check the signature of function, type the following in elm REPL −

> String.trim
<function> : String -> String

Illustration

> String.trim "tutorialspoint "
"tutorialspoint" : String

filter

This function filters a set of characters from input String. Keep only the characters that pass the test.

Syntax

String.filter test_function string_value

To check the signature of function, type the following in elm REPL −

> String.filter
<function> : (Char -> Bool) -> String -> String

The signature shows filter takes two input parameters and returns a String. The first parameter is a function, which has input Char and returns Bool.

Illustration

In the example, we are passing Char.isUpper as parameter to filter method; it returns all upper-case characters as shown below.

> import Char
> String.filter Char.isUpper "abcDEF"
"DEF" : String

map

This function takes a String and transforms every character in a string.

Syntax

String.filter mapping_function string_value

To check the signature of function, type the following in elm REPL −

> String.map
<function> : (Char -> Char) -> String -> String

Illustration

The following example replaces the character o with @ −

> String.map (\c -> if c == 'o' then '@' else c) "TutorialsPoint"
"Tut@rialsP@int" : String

The List, Tuples and Record data structures can be used to store a collection of values.

This chapter discusses how to use List in Elm.

A List is a collection of homogeneous values. The values in a list must all be of the same data type.

Consider the following limitations while using variables to store values −

  • Variables are scalar in nature. In other words, at the time of declaration a variable can hold only one value. This means that to store n values in a program, n variable declarations will be needed. Hence, the use of variables is not feasible when one needs to store a larger collection of values.

  • Variables in a program are allocated memory in random order, thereby making it difficult to retrieve/read the values in the order of their declaration.

Syntax

List_name = [value1,value2,value3.....valuen]

Illustration

The following example shows how to use a List in Elm. Try this example in elm REPL −

> myList1 = [10,20,30]
[10,20,30] : List number
> myList2 = ["hello","world"]
["hello","world"] : List String

If we try adding values of different types into a list, the compiler will throw a type mismatch error. This is shown below.

> myList = [1,"hello"]
-- TYPE MISMATCH 
--------------------------------------------- 
repl-temp-000.elm

The 1st and 2nd entries in this list are different types of values.

4| [1,"hello"]
^^^^^^^
The 1st entry has this type:
   number
But the 2nd is:
   String

List operations

Following table shows the common operations on a List −

Sr. No Method Description
1 isEmpty : List a -> Bool checks if list is empty
2 reverse : List a -> Bool reverses input list
3 length : List a -> Int returns size of the list
4 maximum : List comparable -> Maybe.Maybe comparable returns maximum value
5 minimum : List comparable -> Maybe.Maybe comparable returns minimum value
6 sum : List number -> number returns sum of all elements in list
7 product : List number -> number checks if list is empty
8 sort : List comparable -> List comparable sorts list in ascending order
9 concat : List (List a) -> List a merges a bunch of list into one
10 append : List a -> List a -> List a merges two lists together
11 range : Int -> Int -> List Int returns a list of numbers from start to end
12 filter : (a -> Bool) -> List a -> List a filters list of values from input list
13 head : List a -> Maybe.Maybe a returns the first element from list
14 tail : : List a -> Maybe.Maybe (List a) returns all elements except the head

isEmpty

This function returns true if a list is empty.

Syntax

List.isEmpty list_name

To check the signature of function, type the following in elm REPL −

> List.isEmpty
<function> : List a -> Bool

Illustration

> List.isEmpty
<function> : List a -> Bool

> List.isEmpty [10,20,30]
False : Bool

reverse

This function reverses the list.

Syntax

List.reverse list_name

फ़ंक्शन के हस्ताक्षर की जांच करने के लिए, एल्म आरईपीएल में निम्नलिखित लिखें -

> List.reverse
<function> : List a -> List a

चित्रण

> List.reverse [10,20,30]
[30,20,10] : List number

लंबाई

यह फ़ंक्शन किसी सूची की लंबाई देता है।

वाक्य - विन्यास

List.length list_name

फ़ंक्शन के हस्ताक्षर की जांच करने के लिए, एल्म आरईपीएल में निम्नलिखित लिखें -

> List.length
<function> : List a -> Int

चित्रण

> List.length [10,20,30]
3 : Int

ज्यादा से ज्यादा

यह फ़ंक्शन गैर-रिक्त सूची में अधिकतम तत्व देता है।

वाक्य - विन्यास

List.maximum list_name

फ़ंक्शन के हस्ताक्षर की जांच करने के लिए, एल्म आरईपीएल में निम्नलिखित लिखें -

> List.maximum
<function> : List comparable -> Maybe.Maybe comparable

चित्रण

> List.maximum [10,20,30]
Just 30 : Maybe.Maybe number
> List.maximum []
Nothing : Maybe.Maybe comparable

न्यूनतम

यह फ़ंक्शन गैर-रिक्त सूची में न्यूनतम तत्व देता है।

वाक्य - विन्यास

List.minimum list_name

फ़ंक्शन के हस्ताक्षर की जांच करने के लिए, एल्म आरईपीएल में निम्नलिखित लिखें -

> List.minimum
<function> : List comparable -> Maybe.Maybe comparable

चित्रण

> List.minimum [10,20,30]
Just 10 : Maybe.Maybe number

योग

यह फ़ंक्शन किसी सूची में सभी तत्वों का योग देता है।

वाक्य - विन्यास

List.sum list_name

फ़ंक्शन के हस्ताक्षर की जांच करने के लिए, एल्म आरईपीएल में निम्नलिखित लिखें -

> List.sum
<function> : List number -> number

चित्रण

> List.sum [10,20,30]
60 : number

उत्पाद

यह फ़ंक्शन किसी सूची में सभी तत्वों के उत्पाद को लौटाता है।

वाक्य - विन्यास

List.product list_name

फ़ंक्शन के हस्ताक्षर की जांच करने के लिए, एल्म आरईपीएल में निम्नलिखित लिखें -

<function>  : List number ->  number

चित्रण

List.product [10,20,30]
6000 : number

तरह

यह फ़ंक्शन किसी सूची में निम्नतम से लेकर उच्चतम तक मानों को सॉर्ट करता है।

वाक्य - विन्यास

List.sort list_name

फ़ंक्शन के हस्ताक्षर की जांच करने के लिए, एल्म आरईपीएल में निम्नलिखित लिखें -

> List.sort
<function> : List comparable -> List comparable

चित्रण

> List.sort [10,20,30]
[10,20,30] : List number

concat

यह फ़ंक्शन किसी एकल सूची में सूचियों का एक समूह समेटता है।

वाक्य - विन्यास

List.concat [ [list_name1],[list_name2],[list_name3],.....[list_nameN] ]

फ़ंक्शन के हस्ताक्षर की जांच करने के लिए, एल्म आरईपीएल में निम्नलिखित लिखें -

> List.concat
<function> : List (List a) -> List a

चित्रण

> List.concat [[10,20], [30,40],[50,60]]
[10,20,30,40,50,60] : List number

संलग्न

यह फ़ंक्शन दो सूचियों को एक साथ रखता है।

वाक्य - विन्यास

List.append [list_name1] [list_name2]

फ़ंक्शन के हस्ताक्षर की जांच करने के लिए, एल्म आरईपीएल में निम्नलिखित लिखें -

> List.append
<function> : List a -> List a -> List a

चित्रण

> List.append [10,20] [30,40]
[10,20,30,40] : List number

++ ऑपरेटर का उपयोग किसी सूची को दूसरे में जोड़ने के लिए भी किया जा सकता है। यह नीचे दिए गए उदाहरण में दिखाया गया है -

> [10.1,20.2] ++ [30.3,40.4]
[10.1,20.2,30.3,40.4] : List Float

रेंज

यह फ़ंक्शन संख्याओं की सूची बनाता है, प्रत्येक तत्व एक से बढ़ रहा है। सबसे कम और सबसे अधिक संख्या जो सूची में होनी चाहिए, फ़ंक्शन को पास की जाती है।

वाक्य - विन्यास

List.range start_range end_range

फ़ंक्शन के हस्ताक्षर की जांच करने के लिए, एल्म आरईपीएल में निम्नलिखित लिखें -

> List.range
<function> : Int -> Int -> List Int

चित्रण

> List.range 1 10
[1,2,3,4,5,6,7,8,9,10] : List Int

फिल्टर

यह फ़ंक्शन इनपुट सूची से मानों के एक सेट को फ़िल्टर करता है। केवल वही मान रखें जो परीक्षा पास करते हैं।

वाक्य - विन्यास

List.filter test_function input_list

फ़ंक्शन के हस्ताक्षर की जांच करने के लिए, एल्म आरईपीएल में निम्नलिखित लिखें -

> List.filter
<function> : (a -> Bool) -> List a -> List a

चित्रण

निम्नलिखित उदाहरण एक इनपुट सूची से सभी संख्याओं को फ़िल्टर करता है

> List.filter (\n -> n%2==0) [10,20,30,55]
[10,20,30] : List Int

सिर

यह फ़ंक्शन इनपुट सूची से पहला तत्व देता है।

वाक्य - विन्यास

List.head input_list

फ़ंक्शन के हस्ताक्षर की जांच करने के लिए, एल्म आरईपीएल में निम्नलिखित लिखें -

> List.head
<function> : List a -> Maybe.Maybe a

चित्रण

> List.head [10,20,30,40]
Just 10 : Maybe.Maybe number
> List.head []
Nothing : Maybe.Maybe a

पूंछ

यह फ़ंक्शन सूची में पहले के बाद सभी तत्वों को लौटाता है।

वाक्य - विन्यास

List.tail input_list

फ़ंक्शन के हस्ताक्षर की जांच करने के लिए, एल्म आरईपीएल में निम्नलिखित लिखें -

> List.tail
<function> : List a -> Maybe.Maybe (List a)

चित्रण

> List.tail [10,20,30,40,50]
Just [20,30,40,50] : Maybe.Maybe (List number)
> List.tail [10]
Just [] : Maybe.Maybe (List number)
> List.tail []
Nothing : Maybe.Maybe (List a)

विपक्ष ऑपरेटर का उपयोग करना

विपक्ष ऑपरेटर (::) एक सूची के सामने एक तत्व जोड़ता है।

चित्रण

> 10::[20,30,40,50]
[10,20,30,40,50] : List number

जोड़ा जाने वाला नया तत्व और सूची में मौजूद मानों का डेटा-प्रकार मेल खाना चाहिए। कंपाइलर एक त्रुटि फेंकता है यदि डेटा प्रकार मेल नहीं खाते हैं।

> [1,2,3,4]::[5,6,7,8]
-- TYPE MISMATCH ---------------------------------
------------ repl-temp-000.elm

The right side of (::) is causing a type mismatch.

3| [1,2,3,4]::[5,6,7,8]
			  ^^^^^^^^^
(::) is expecting the right side to be a:

   List (List number)

But the right side is:

   List number
Hint: With operators like (::) I always check the left side first. If it seems fine, 
I assume it is correct and check the right side. So the 
problem may be in how the left and right arguments interact.

सूचियाँ अपरिवर्तनीय हैं

आइए देखें कि क्या एल्म में सूचियां अपरिवर्तनीय हैं। पहली सूची myList जब मान 1 के साथ सम्‍मिलित एक नई सूची बनाता है और myListCopy पर वापस आ जाता है । इसलिए, यदि हम प्रारंभिक सूची प्रदर्शित करते हैं, तो इसके मान नहीं बदले जाएंगे।

> myList = [10,20,30]
[10,20,30] : List number
> myListCopy = 1::myList
[1,10,20,30] : List number
> myList
[10,20,30] : List number
>myList == myListCopy
False : Bool

कई बार, विभिन्न प्रकारों के मूल्यों के संग्रह को संग्रहीत करने की आवश्यकता हो सकती है। एल्म हमें एक डेटा संरचना देता है जिसे ट्यूपल कहा जाता है जो इस उद्देश्य को पूरा करता है।

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

वाक्य - विन्यास

(data1,data2)

एक सरल उदाहरण नीचे दिखाया गया है -

> ("TuotrialsPoint",5,True,"Hyderabad")
("TuotrialsPoint",5,True,"Hyderabad") : ( String, number, Bool, String )

हमारे बाद के अनुभागों में, हम अलग-अलग टपल संचालन के बारे में जानेंगे।

प्रथम

यह ऑपरेशन टुपल से पहला मान निकालता है।

वाक्य - विन्यास

Tuple.first tuple_name
> Tuple.first
<function> : ( a1, a2 ) -> a1

चित्रण

> Tuple.first (10,"hello")
10 : number

दूसरा

second tuple ऑपरेशन एक tuple से दूसरा मान निकालता है।

वाक्य - विन्यास

Tuple.second tuple_name
> Tuple.second
<function> : ( a1, a2 ) -> a2

चित्रण

> Tuple.second (10,"hello")
"hello" : String

टुपल्स की सूची

एक सूची ट्यूपल्स को स्टोर कर सकती है। यदि किसी सूची के अंदर टुपल्स का उपयोग किया जाता है, तो सुनिश्चित करें कि वे सभी एक ही डेटा प्रकार के हैं और उनके समान पैरामीटर हैं।

चित्रण

> [("hello",20),("world",30)]
[("hello",20),("world",30)] : List ( String, number )

समारोह के साथ ट्यूपल

एक फ़ंक्शन ट्यूपल्स को वापस कर सकता है। इसके अलावा, ट्यूपल्स को कार्यों के मापदंडों के रूप में पारित किया जा सकता है।

चित्रण १

निम्न उदाहरण एक फ़ंक्शन को परिभाषित करता है fn_checkEven। यह फ़ंक्शन एक पूर्णांक मान को पैरामीटर के रूप में स्वीकार करता है और एक टपल लौटाता है।

> fn_checkEven no = \
   if no%2 == 0 then \
      (True,"The no is Even")\
   else \
      (False,"No is not even")
<function> : Int -> ( Bool, String )
> fn_checkEven 10
(True,"The no is Even") : ( Bool, String )
> fn_checkEven 11
(False,"No is not even") : ( Bool, String )
>

चित्रण २

निम्नलिखित एक कार्य के लिए एक पैरामीटर के रूप में एक गुच्छे से गुजरता है।

> fn_add (a,b) = \
| a+b
<function> : ( number, number ) -> number
> fn_add (10,20)
30 : number

फ़ंक्शन fn_add 2 संख्यात्मक मानों के साथ एक ट्यूपल लेता है और उनकी राशि लौटाता है।

Destructuring

विनाशकारी में व्यक्तिगत मूल्यों में एक टपल को तोड़ना शामिल है। तीन या अधिक तत्वों के साथ एक ट्यूपल में व्यक्तिगत मूल्यों तक पहुंचने के लिए, हम विनाशकारी का उपयोग करते हैं। यहां, हम प्रत्येक मान को अलग-अलग चर में एक टपल में निर्दिष्ट करते हैं। _ एक का उपयोग प्लेसहोल्डर्स को उन मानों के लिए परिभाषित कर सकता है जिन्हें अनदेखा या छोड़ दिया जाएगा।

चित्रण

> (first,_,_) = (10,20,30)
10 : number
> first
10 : number

चित्रण

इस उदाहरण में, हम wil का उपयोग करते हैं। विनाश के लिए ब्लॉक सिंटैक्स का उपयोग करें। लेट ब्लॉक में वेरिएबल्स होते हैं और ब्लॉक में एक्‍सप्रेशन होते हैं जिनका मूल्‍यांकन किया जाना चाहिए और मान जो लौटाया जाना चाहिए।

> t1 = (10,20,30)
(10,20,30) : ( number, number1, number2 )
> let \
(a,b,c) = t1 \
in\
a + b +c
60 : number

हम वेरिएबल एबीसी को लेट क्लॉज में घोषित कर रहे हैं और क्लॉज में इनका उपयोग कर रहे हैं।

एल्म में रिकॉर्ड डेटा संरचना का उपयोग कुंजी-मूल्य जोड़े के रूप में डेटा का प्रतिनिधित्व करने के लिए किया जा सकता है। एक रिकॉर्ड का उपयोग संबंधित डेटा को व्यवस्थित करने के लिए किया जा सकता है ताकि आसान पहुंच और डेटा को अपडेट किया जा सके। एल्म रिकॉर्ड जावास्क्रिप्ट में वस्तुओं के समान हैं। एक रिकॉर्ड में डेटा तत्वों को फ़ील्ड के रूप में जाना जाता है।

एक रिकॉर्ड को परिभाषित करना

रिकॉर्ड को परिभाषित करने के लिए निम्नलिखित सिंटैक्स का उपयोग करें -

वाक्य - विन्यास

record_name = {fieldname1 = value1, fieldname2 = value2....fieldnameN = valueN}

एक रिकॉर्ड कई प्रकार के डेटा को स्टोर कर सकता है। एक रिकॉर्ड में फ़ील्ड नामों को एल्म पहचानकर्ता के नामकरण के लिए सामान्य नियमों के अनुरूप होना चाहिए।

रिकॉर्ड मूल्यों तक पहुँचना

रिकॉर्ड में अलग-अलग फ़ील्ड्स तक पहुँचने के लिए निम्न सिंटैक्स का उपयोग करें।

वाक्य - विन्यास

record_name.fieldname

या

.fieldname record_name

चित्रण

एल्म REPL में निम्नलिखित प्रयास करें -

> company = {name="TutorialsPoint",rating=4.5}
{ name = "TutorialsPoint", rating = 4.5 } : { name : String, rating : Float }
> company.name
"TutorialsPoint" : String
> .rating company
4.5 : Float

सूची के साथ रिकॉर्ड का उपयोग करना

एक रिकॉर्ड एक सूची के अंदर संग्रहीत किया जा सकता है। रिकॉर्ड के सभी क्षेत्र मान एक ही प्रकार के होने चाहिए।

वाक्य - विन्यास

list_name = [ {field_name1 = value1},{field_name1 = value2}]

या

list_name = [record_name1, record_name2, record_name3....record_nameN]

चित्रण

एल्म आरईपीएल में निम्नलिखित प्रयास करें -

> [{name = "Mohtashim"},{name = "kannan"}]
[{ name = "Mohtashim" },{ name = "kannan" }] : List { name : String }
> record1 = {name = "FirstRecord"}
{ name = "FirstRecord" } : { name : String }
> record2 = {name = "SecondRecord"}
{ name = "SecondRecord" } : { name : String }
> recordList = [record1,record2]
[{ name = "FirstRecord" },{ name = "SecondRecord" }] : List { name : String }

एक रिकॉर्ड अपडेट करें

एल्म में रिकॉर्ड अपरिवर्तनीय हैं। जब कोई रिकॉर्ड अपडेट किया जाता है, तो अपडेट किए गए मानों के साथ एक नया रिकॉर्ड वापस आ जाता है। रिकॉर्ड अपडेट करते समय फ़ील्ड भिन्न प्रकार का मान रख सकती है।

वाक्य - विन्यास

{record_name | field_name1 = new_value1, field_name2 = new_value2,field_name3 = new_value3....field_nameN = new_valueN}

चित्रण

एल्म आरईपीएल में निम्नलिखित प्रयास करें -

> record1 = {name="FirstRecord"}
{ name = "FirstRecord" } : { name : String }
> record1_updated = {record1 | name = "FirstRecordUpdate"}
{ name = "FirstRecordUpdate" } : { name : String }
> record1
{ name = "FirstRecord" } : { name : String }
> record1 == record1_updated
False : Bool

चित्रण

निम्न उदाहरण एक रिकॉर्ड के कई क्षेत्रों को अद्यतन करता है। एल्म आरईपीएल में निम्नलिखित प्रयास करें -

> record3 = {a = 1,b = 2,c = 3,d = 4,e = 5}
{ a = 1, b = 2, c = 3, d = 4, e = 5 }
: { a : number, b : number1, c : number2, d : number3, e : number4 }
> record4 = {record3 | d=400 ,e=500}
{ a = 1, b = 2, c = 3, d = 400, e = 500 }
: { a : number2, b : number3, c : number4, d : number, e : number1 }
>

प्रकार उर्फ

एक रिकॉर्ड के लिए उपनाम अन्य स्कीमा को परिभाषित करता है। दूसरे शब्दों में, एक प्रकार उर्फ ​​परिभाषित करता है कि कौन से क्षेत्र रिकॉर्ड स्टोर कर सकते हैं और इन क्षेत्रों का मूल्य किस प्रकार का स्टोर कर सकते हैं। इसलिए, प्रोग्रामर मूल्यों को निर्दिष्ट करते समय किसी भी विशिष्ट विशेषता को याद करने की गलती नहीं करेगा।

वाक्य - विन्यास

type alias alias_name = {field_name1:data_type,field_name2:data_type,....field_nameN:data_type}

चित्रण

एल्म आरईपीएल में निम्नलिखित को निष्पादित करें -

> type alias Developer = { name:String,location:String,age:Int}
> dev1 = Developer "kannan" "Mumbai" 20
{ name = "kannan", location = "Mumbai", age = 20 } : Repl.Developer
> dev2 = Developer "mohtashim" "hyderabad" 20
{ name = "mohtashim", location = "hyderabad", age = 20 } : Repl.Developer
>

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

> dev3 = Developer "Bhagavati"
<function> : String -> Int -> Repl.Developer
We can invoke the function as shown below and pass to it the values for location and age fields.
> dev3 "Pune" 25
{ name = "Bhagavati", location = "Pune", age = 25 } : Repl.Developer

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

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

एल्म प्रोग्रामिंग भाषा निम्नलिखित तरीकों से त्रुटियों को संभालती है -

  • MayBe
  • Result

शायद

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

वाक्य - विन्यास

variable_name:MayBe data_type

MayBe प्रकार का एक चर में निम्नलिखित मान हो सकते हैं -

  • बस कुछ_वैल्यू - वैध डेटा होने पर इसका उपयोग किया जाता है।

  • कुछ भी नहीं - यह प्रयोग किया जाता है यदि मान अनुपस्थित या अज्ञात है। अन्य प्रोग्रामिंग भाषाओं में शून्य के बराबर कुछ भी नहीं है।

चित्रण

निम्न उदाहरण दिखाता है कि चर और फ़ंक्शन के साथ MayBe प्रकार का उपयोग कैसे करें।

Step 1 - एक बनाएँ MayBeDemo.elm फ़ाइल और इसमें निम्न कोड जोड़ें

-- MayBeDemo.elm
module MayBeDemo exposing(..)
import Maybe

--declaring a MayBe variable and assigning value to it
userName : Maybe String
userName = Just "Mohtashim"

--declaring a MayBe variable and assigning value to it
userAge :Maybe Int
userAge = Just 20

--declaring a MayBe variable and assigning value to it
userSalary:Maybe Float
userSalary = Nothing

--declaring a custom type
type Country = India | China | SriLanka

--defining a function that takes a String parameter as input and returns a value of type MayBe

getCountryFromString : String -> Maybe Country
getCountryFromString p =
case p of
   "India"
      -> Just India
   "China"
      -> Just China
   "SriLanka"
      -> Just SriLanka
   _
      -> Nothing

Step 2 - एल्म उत्तर में मॉड्यूल आयात करें और नीचे दिए गए अनुसार निष्पादित करें

E:\ElmWorks\ErroApp> elm repl
---- elm-repl 0.18.0 -----------------------------------------------------------
:help for help, :exit to exit, more at 
      
        -------------------------------------------------------------------------------- > import MayBeDemo exposing(..) > userName Just "Mohtashim" : Maybe.Maybe String > userAge Just 20 : Maybe.Maybe Int > userSalary Nothing : Maybe.Maybe Float > getCountryFromString "India" Just India : Maybe.Maybe MayBeDemo.Country > getCountryFromString "india" Nothing : Maybe.Maybe MayBeDemo.Country

फ़ंक्शन जाँचता है कि फ़ंक्शन को दिया गया मान भारत या चीन या श्री लंका है। यदि पैरामीटर्स का मान इनमें से किसी से मेल नहीं खाता है, तो यह कुछ भी नहीं लौटाता है।

परिणाम

एक उदाहरण पर विचार करें, जहां आवेदन को कुछ शर्त को मान्य करने की आवश्यकता है और यदि स्थिति संतुष्ट नहीं है तो त्रुटि को बढ़ाएं। इसे प्राप्त करने के लिए परिणाम प्रकार का उपयोग किया जा सकता है। यदि आवेदन स्पष्ट रूप से एक त्रुटि उठाना चाहता है और जो कुछ गलत हुआ है उसके बारे में विवरण लौटाता है, परिणाम प्रकार का उपयोग किया जाना चाहिए।

वाक्य - विन्यास

परिणाम प्रकार की घोषणा में दो पैरामीटर होते हैं - डेटा प्रकार की त्रुटि (आमतौर पर स्ट्रिंग) और परिणाम का डेटा प्रकार यदि सब कुछ ठीक हो जाता है।

type Result error_type data_value_type
= Ok data_value
| Err error_message

परिणाम प्रकार निम्नलिखित मानों में से एक है -

  • ओके some_value - रिप्रेंटेंट्स को वापस करने का परिणाम है

  • त्रुटि - अपेक्षित स्थिति संतुष्ट नहीं होने पर त्रुटि संदेश को वापस करने का प्रतिनिधित्व करता है।

चित्रण १

एल्म आरईपीएल में निम्नलिखित उदाहरण का प्रयास करें -

> String.toInt
<function> : String -> Result.Result String Int
-- successful result
> String.toInt "10"
Ok 10 : Result.Result String Int
-- unsuccessful result , Error
> String.toInt "a"
Err "could not convert string 'a' to an Int" : Result.Result String Int

यदि पैरामीटर पास है, तो String.toInt फ़ंक्शन पूर्णांक मान लौटाता है। यदि पैरामीटर एक संख्या नहीं है, तो फ़ंक्शन एक त्रुटि देता है।

चित्रण २

निम्न उदाहरण एक पैरामीटर के रूप में उम्र को स्वीकार करता है। यदि यह 0 और 135 के बीच है तो यह आयु देता है और यह एक उचित त्रुटि संदेश देता है।

Step 1 - एक ResultDemo.elm फ़ाइल बनाएं और इसमें निम्न कोड जोड़ें।

--ResultDemo.elm
module ResultDemo exposing(..)

userId : Result String Int
userId = Ok 10

emailId : Result String Int
emailId = Err "Not valid emailId"

isReasonableAge : String -> Result String Int
isReasonableAge input =
   case String.toInt input of
      Err r ->
         Err "That is not a age!"

   Ok age ->
      if age < 0 then
         Err "Please try again ,age can't be negative"
      else if age > 135 then
         Err "Please try agian,age can't be this big.."

   else
      Ok age

Step 2 - एल्म पैकेज में मॉड्यूल आयात करें और नीचे दिए अनुसार निष्पादित करें

E:\ElmWorks\ElmRepo\15_ErrorHandling\15_Code> elm repl
---- elm-repl 0.18.0 -----------------------------------------------------------
:help for help, :exit to exit, more at <https://github.com/elm-lang/elm-repl>
--------------------------------------------------------------------------------
> import ResultDemo exposing (..)
> userId
Ok 10 : Result.Result String Int
> emailId
Err "Not valid emailId" : Result.Result String Int
> isReasonableAge "10"
Ok 10 : Result.Result String Int
> isReasonableAge "abc"
Err "That is not a age!" : Result.Result String Int

इस अध्याय में, हम एल्म प्लेटफॉर्म में एप्लिकेशन बनाने के मानक तरीके पर चर्चा करेंगे। एल्म मॉडल-व्यू-कंट्रोलर पैटर्न के समान एक वास्तुशिल्प पैटर्न का उपयोग करता है।

निम्नलिखित एल्म वास्तुकला के चार मुख्य भाग हैं।

  • Model
  • View
  • Message
  • Update

एल्म वास्तुकला कैसे काम करती है

modelअनुप्रयोग स्थिति शामिल है। उदाहरण के लिए, यदि कोई एप्लिकेशन ग्राहकों की सूची प्रदर्शित करता है तो राज्य में प्रत्येक ग्राहक डेटा होगा। राज्य को प्रस्तुत करने योग्य तरीके से प्रदर्शित करने के लिए, एview/ html को जनरेट करना होगा। एक बार उपयोगकर्ता एक बटन दबाकर या किसी प्रपत्र में डेटा टाइप करके दृश्य के साथ इंटरैक्ट करता है, तो दृश्य नामक सिग्नल उत्पन्न करता हैmessages। संदेशों को पास किया जाता हैupdateविधि, जो संदेशों का मूल्यांकन करती है और उचित कार्रवाई करती है। इसलिए, अपडेट विधि एक नया मॉडल उत्पन्न करेगी।

नया मॉडल एक नया दृश्य उत्पन्न करता है। दृश्य उपयोगकर्ता से संदेशों को संकेत करने के लिए नई बातचीत का नेतृत्व करेगा, जो अपडेट फ़ंक्शन के लिए जाता है। इसके अलावा, फ़ंक्शन एक नया मॉडल बनाता है। तो, चक्र दोहराता है जैसा कि ऊपर चित्र में दिखाया गया है।

नमूना

मॉडल आवेदन की स्थिति से संबंधित है। एक मॉडल को परिभाषित करने का सिंटैक्स नीचे दिया गया है -

-- Model syntax

type alias Model = {
   property1:datatype,
   proptery2:datatype
...
}

एक मॉडल बनाने के लिए, हमें पहले उसमें आवश्यक सभी संपत्तियों के साथ एक टेम्पलेट बनाना होगा। प्रत्येक गुण एप्लिकेशन की स्थिति को निर्दिष्ट करता है।

राय

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

--View Syntax
view model =some_implementation

संदेश

संदेश अनुप्रयोग स्थिति को बदलने के लिए उपयोगकर्ता से एक अनुरोध है। संदेश अपडेट फ़ंक्शन के पैरामीटर के रूप में पारित किए जाते हैं।

--Message Syntax
type Message = Message1 |Message2 ...

सिंटैक्स एक प्रकार का संदेश दिखाता है। एल्म एप्लिकेशन राज्य को भेजे गए संदेशों के आधार पर संपादित करेगा। ये निर्णय अद्यतन विधि में किए गए हैं।

अपडेट करें

अपडेट फ़ंक्शन उन संदेशों की व्याख्या करता है, जो इसे पैरामीटर के रूप में पारित करते हैं, और मॉडल को अपडेट करते हैं।

--Update Syntax
update Message_type model =
   some_implementation

अद्यतन कार्य करता है Message और मापदंडों के रूप में मॉडल।

एक पैकेज मैनेजर एक कमांड-लाइन टूल है जो आपके एप्लिकेशन में पैकेजों को स्थापित करने, अपग्रेड करने, कॉन्फ़िगर करने और निकालने की प्रक्रिया को स्वचालित करता है।

जैसे जावास्क्रिप्ट में एक पैकेज मैनेजर होता है जिसे npm कहा जाता है, एल्म में एक पैकेज मैनेजर होता है जिसे एल्म-पैकेज कहा जाता है ।

पैकेज प्रबंधक निम्नलिखित तीन कार्य करता है -

  • एक एल्म आवेदन की जरूरत है कि सभी निर्भरता स्थापित करता है
  • कस्टम पैकेज प्रकाशित करता है
  • जब आप प्रकाशित और अपडेट करने के लिए तैयार हों तो अपने पैकेज का संस्करण निर्धारित करें।

एल्म पैकेज मैनेजर कमांड्स

निम्न तालिका विभिन्न एल्म पैकेज प्रबंधक आदेशों को सूचीबद्ध करती है -

अनु क्रमांक। आदेश वाक्य - विन्यास विवरण
1 इंस्टॉल एल्म-पैकेज स्थापित करें स्थानीय स्तर पर उपयोग करने के लिए पैकेज स्थापित करता है
2 प्रकाशित करना एल्म-पैकेज प्रकाशित केंद्रीय कैटलॉग में अपना पैकेज प्रकाशित करता है
3 टक्कर एल्म-पैकेज टक्कर एपीआई परिवर्तन के आधार पर संस्करण संख्याएं
4 diff एल्म-पैकेज अंतर दो एपीआई के बीच अंतर हो जाता है

अपने पैकेज को प्रकाशित करने के लिए, आपको GitHub पर स्रोत कोड होस्ट करने की आवश्यकता है और संस्करण को ठीक से git टैग के साथ लेबल किया गया है। निम्नलिखित उदाहरण से पता चलता है कि बाहरी निर्भरता को खींचने के लिए एल्म-पैकेज प्रबंधक का उपयोग कैसे करें।

चित्रण - svg पैकेज स्थापित करना

इस उदाहरण में, हम देखेंगे कि स्केलेबल वेक्टर ग्राफिक्स (SVG) को एल्म एप्लिकेशन में कैसे एकीकृत किया जाए।

Step 1 - एक फ़ोल्डर बनाएं elmSvgApp

Step 2 - निम्नलिखित कमांड का उपयोग करके svg पैकेज स्थापित करें -

elm-package install elm-lang/svg

Step 3- एक SvgDemo.elm फ़ाइल बनाएँ और नीचे दी गई सामग्री टाइप करें। हम 100x100 आयाम की आयत खींचने और रंग लाल भरने के लिए Svg मॉड्यूल का आयात करते हैं।

import Svg exposing (..)
import Svg.Attributes exposing (..)

main =
   svg
   [ width "120"
   , height "120"
   , viewBox "0 0 120 120"
   ]
   [ rect
      [ x "10"
      , y "10"
      , width "100"
      , height "100"
      , rx "15"
      , ry "15"
      ,fill "red"
      ]
      []
   ]

Step 4- अब एल्म मेक। \ SvgDemo.elm का उपयोग करके प्रोजेक्ट बनाएं। यह नीचे दिखाए अनुसार एक index.html उत्पन्न करेगा -

संदेश एल्म वास्तुकला में एक घटक है। ये घटक अनुप्रयोग के इंटरफेस के साथ उपयोगकर्ता की बातचीत के जवाब में व्यू द्वारा उत्पन्न होते हैं। संदेश एप्लिकेशन की स्थिति को बदलने के लिए उपयोगकर्ता के अनुरोधों का प्रतिनिधित्व करते हैं।

वाक्य - विन्यास

--Message Syntax
type Message = some_message1 |some_message2 ...|some_messageN

llustration

निम्नलिखित उदाहरण एक सरल काउंटर अनुप्रयोग है। उपयोगकर्ता द्वारा ऐड और सबट्रेक्ट बटन पर क्लिक करने पर एप्लिकेशन 1 से चर का मान बढ़ाता है और घटाता है।

आवेदन में 4 घटक होंगे। घटक नीचे वर्णित हैं -

संदेश

इस उदाहरण के लिए संदेश होंगे -

type Message = Add | Subtract

नमूना

मॉडल आवेदन की स्थिति का प्रतिनिधित्व करता है। काउंटर एप्लिकेशन में मॉडल परिभाषा नीचे दी गई है; काउंटर की प्रारंभिक स्थिति शून्य होगी।

model = 0

राय

दृश्य अनुप्रयोग के दृश्य तत्वों का प्रतिनिधित्व करता है। दृश्य में दो बटन (+) और (-) शामिल हैं। उपयोगकर्ता द्वारा क्रमशः + और - बटन पर क्लिक करने पर दृश्य जोड़ें और घटाना संदेश उत्पन्न होते हैं। तब मॉडल का संशोधित मूल्य दृश्य द्वारा प्रदर्शित किया जाता है।

view model =
-- invoke text function
h1[]
[   div[] [text "CounterApp from TutorialsPoint" ]
   ,button[onClick Subtract] [text "-"]
   ,div[][text (toString model)]
   ,button[onClick Add] [text "+"]
]

अपडेट करें

इस घटक में कोड होता है जिसे दृश्य द्वारा उत्पन्न प्रत्येक संदेश के लिए निष्पादित किया जाना चाहिए। यह नीचे दिए गए उदाहरण में दिखाया गया है -

update msg model =
case msg of
Add -> model+1
Subtract -> model-1

यह सब एक साथ डालें

Step 1- एक फ़ोल्डर MessageApp बनाएँ और MessageDemo.elm फ़ाइल

Step 2 - एल्म फ़ाइल में निम्न कोड जोड़ें -

import Html exposing (..)
import Html.Events exposing(onClick)

model = 0 -- Defining the Model

--Defining the View

view model =
   h1[]
   [  div[] [text "CounterApp from TutorialsPoint" ]
      ,button[onClick Subtract] [text "-"]
      ,div[][text (toString model)]
      ,button[onClick Add] [text "+"]
   ]

--Defining the Messages

type Message = Add | Subtract

--Defining Update

update msg model =
case msg of
   Add -> model+1
   Subtract -> model-1

-- Define the main method
main =
   beginnerProgram
   {
      model=model
      ,view=view
      ,update=update
   }

Step 3 - निष्पादित करें elm make commandटर्मिनल में। elm make command कोड संकलित करता है और ऊपर बनाई गई .elm फ़ाइल से एक HTML फ़ाइल बनाता है।

C:\Users\dell\elm\MessagesApp> elm make .\MessageDemo.elm
Some new packages are needed. Here is the upgrade plan.

   Install:
      elm-lang/core 5.1.1
      elm-lang/html 2.0.0
      elm-lang/virtual-dom 2.0.4

Do you approve of this plan? [Y/n] y
Starting downloads...

   ΓùÅ elm-lang/html 2.0.0
   ΓùÅ elm-lang/virtual-dom 2.0.4

ΓùÅ elm-lang/core 5.1.1
Packages configured successfully!
Success! Compiled 38 modules.
Successfully generated index.html

Step 4 - खोलें index.html और नीचे दिखाए अनुसार कार्य को सत्यापित करें -

एल्म - कमांड्स

पिछले अध्यायों में, हमने एल्म वास्तुकला के विभिन्न घटकों और उनके कार्यों पर चर्चा की। संदेश का उपयोग करते हुए उपयोगकर्ता और एप्लिकेशन एक दूसरे के साथ संवाद करते हैं।

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

निम्नलिखित आंकड़ा एक जटिल एल्म अनुप्रयोग के वर्कफ़्लो को दिखाता है -

उपयोगकर्ता दृश्य के साथ सहभागिता करता है। दृश्य उपयोगकर्ता की कार्रवाई के आधार पर एक उपयुक्त संदेश उत्पन्न करता है। अद्यतन घटक इस संदेश को प्राप्त करता है और एक कमांड चलाता है।

वाक्य - विन्यास

कमांड को परिभाषित करने का सिंटैक्स नीचे दिया गया है -

type Cmd msg

दृश्य द्वारा उत्पन्न संदेश कमांड को पास किया जाता है।

चित्रण

निम्न उदाहरण एक एपीआई के लिए अनुरोध करता है और एपीआई से परिणाम प्रदर्शित करता है।

एप्लिकेशन उपयोगकर्ता से एक नंबर स्वीकार करता है, इसे नंबर एपीआई में भेजता है। यह एपीआई संख्या से संबंधित तथ्यों को लौटाता है।

आवेदन के विभिन्न घटक इस प्रकार हैं -

Http मॉड्यूल

HTTP अनुरोधों को बनाने और भेजने के लिए एल्म के Http मॉड्यूल का उपयोग किया जाता है। यह मॉड्यूल कोर मॉड्यूल का हिस्सा नहीं है। हम इस पैकेज को स्थापित करने के लिए एल्म पैकेज प्रबंधक का उपयोग करेंगे।

एपीआई

इस उदाहरण में, एप्लिकेशन नंबर API से संवाद करेगा - "http://numbersapi.com/#42"।

राय

एप्लिकेशन के दृश्य में एक टेक्स्टबॉक्स और एक बटन होता है।

view : Model -> Html Msg
view model =
   div []
      [ h2 [] [text model.heading]
      ,input [onInput Input, value model.input] []
      , button [ onClick ShowFacts ] [ text "show facts" ]
      , br [] []
      , h3 [][text model.factText]
      ]

नमूना

मॉडल उपयोगकर्ता द्वारा दर्ज किए गए मूल्य और एपीआई द्वारा लौटाए जाने वाले परिणाम का प्रतिनिधित्व करता है।

type alias Model =
   { heading : String
   , factText : String
   , input :String
   }

संदेश

आवेदन में निम्नलिखित तीन संदेश हैं -

  • ShowFacts
  • Input
  • NewFactArrived

शो फैक्ट्स बटन पर क्लिक करने पर , शोफैक्ट मैसेज अपडेट विधि में पास हो जाता है। जब उपयोगकर्ता टेक्स्टबॉक्स में कुछ मूल्य टाइप करता है, तो इनपुट संदेश को अपडेट करने की विधि पारित की जाती है। अंत में, जब Http सर्वर की प्रतिक्रिया प्राप्त होती है, तो NewFactArrived संदेश अपडेट करने के लिए पास हो जाएगा।

type Msg
   = ShowFacts
   |Input String
   | NewFactArrived (Result Http.Error String)

अपडेट करें

अपडेट विधि एक टपल लौटाती है, जिसमें मॉडल और कमांड ऑब्जेक्ट होते हैं। जब उपयोगकर्ता शो फैक्ट्स बटन पर क्लिक करता है, तो संदेश उस अपडेट को पास कर दिया जाता है, जो तब नंबरएपीआई को कॉल करता है।

update : Msg -> Model -> (Model, Cmd Msg)
update msg model =
   case msg of
      Input newInput ->
      (Model "NumbersApi typing.." "" newInput ,Cmd.none)
      ShowFacts ->
         (model, getRadmonNumberFromAPI model.input)

      NewFactArrived (Ok newFact) ->
         (Model "DataArrived" newFact "", Cmd.none)

      NewFactArrived (Err _) ->
      (model, Cmd.none)

हेल्पर फंक्शन

सहायक फ़ंक्शन getRandomNumberFromAPI नंबरएपीआई को आमंत्रित करता है और उपयोगकर्ता द्वारा दर्ज की गई संख्या को पास करता है। एपीआई द्वारा लौटाए गए परिणाम का उपयोग मॉडल को अपडेट करने के लिए किया जाता है।

getRadmonNumberFromAPI : String->Cmd Msg
getRadmonNumberFromAPI newNo =
   let
      url =
         "http://numbersapi.com/"++newNo
   in
      Http.send NewFactArrived (Http.getString url)
अनु क्रमांक। तरीका हस्ताक्षर विवरण
1 Http.getString getString: स्ट्रिंग -> अनुरोध स्ट्रिंग GET अनुरोध बनाएं और प्रतिक्रिया निकाय को स्ट्रिंग के रूप में व्याख्या करें।
2 Http.send भेजें: (परिणाम त्रुटि a -> msg) -> अनुरोध a -> Cmd संदेश Http अनुरोध भेजें।

मुख्य

यह एल्म परियोजना का प्रवेश बिंदु है।

main =
   Html.program
      { init = init
      , view = view
      , update = update
      , subscriptions = subscriptions
      }

यह सब एक साथ डालें

Step 1 - फोल्डर CommandApp बनाएं और CommandDemo.elm को फाइल करें।

Step 2- कमांड एल्म पैकेज का उपयोग करके http मॉड्यूल इंस्टॉल करें एल्म-लैंग / http स्थापित करें ।

Step 2 - नीचे दिखाए अनुसार CommandDemo.elm के लिए सामग्री टाइप करें -

import Html exposing (..)
import Html.Attributes exposing (..)
import Html.Events exposing (..)
import Http

main =
   Html.program
      { init = init
      , view = view
      , update = update
      , subscriptions = subscriptions
      }

-- MODEL
type alias Model =
   { heading : String
   , factText : String
   , input :String
   }

init : (Model, Cmd Msg)
init =
   ( Model "NumbersAPI" "NoFacts" "42"-- set model two fields
   , Cmd.none -- not to invoke api initially
   )

-- UPDATE

type Msg
   = ShowFacts
   |Input String
   | NewFactArrived (Result Http.Error String)

update : Msg -> Model -> (Model, Cmd Msg)
update msg model =
   case msg of
      Input newInput ->
      (Model "NumbersApi typing.." "" newInput ,Cmd.none)
      ShowFacts ->
         (model, getRadmonNumberFromAPI model.input)

      NewFactArrived (Ok newFact) ->
         (Model "DataArrived" newFact "", Cmd.none)

      NewFactArrived (Err _) ->
         (model, Cmd.none)

- VIEW

view : Model -> Html Msg
view model =
   div []
      [ h2 [] [text model.heading]
      ,input [onInput Input, value model.input] []
      , button [ onClick ShowFacts ] [ text "show facts" ]
      , br [] []
      , h3 [][text model.factText]
      ]

-- SUBSCRIPTIONS

subscriptions : Model -> Sub Msg
subscriptions model =
   Sub.none

-- HTTP

getRadmonNumberFromAPI : String->Cmd Msg
getRadmonNumberFromAPI newNo =
   let
      url =
      "http://numbersapi.com/"++newNo
   in
      Http.send NewFactArrived (Http.getString url)

Step 4 - कमांड फायर करें।

C:\Users\dell\elm\CommandApp> elm make .\CommandDemo.elm

यह नीचे दिखाए गए अनुसार html फ़ाइल उत्पन्न करेगा।

एल्म - सदस्यता

पिछले अध्याय में, हमने चर्चा की कि एक दृश्य कमांड का उपयोग करते हुए अन्य घटकों के साथ बातचीत करता है। इसी तरह, एक घटक (उदाहरण के लिए WebSocket) सदस्यता का उपयोग कर एक दृश्य से बात कर सकता है। सदस्यता एक ऐसा तरीका है जिससे एल्म एप्लिकेशन को कीबोर्ड इवेंट्स, टाइमर इवेंट्स और वेबसॉकेट इवेंट्स जैसे बाहरी इनपुट प्राप्त हो सकते हैं।

निम्नलिखित आंकड़ा एक एल्म आवेदन में सदस्यता की भूमिका की व्याख्या करता है। उपयोगकर्ता संदेशों के माध्यम से एल्म एप्लिकेशन के साथ सहभागिता करता है। दिए गए एप्लिकेशन में WebSocket का उपयोग किया गया है और इसके संचालन के दो तरीके हैं -

  • क्लाइंट-साइड डेटा को कमांड के माध्यम से सॉकेट सर्वर पर भेजें
  • सदस्यता के माध्यम से सॉकेट सर्वर से कभी भी डेटा प्राप्त करें

वाक्य - विन्यास

सदस्यता को परिभाषित करने का सिंटैक्स नीचे दिया गया है -

type Sub msg

चित्रण

आइए एक सरल उदाहरण का उपयोग करते हुए सदस्यता को समझते हैं।

नीचे दिए गए उदाहरण में, एप्लिकेशन सर्वर को एक संदेश भेजता है। सर्वर एक इको सर्वर है, जो क्लाइंट को उसी संदेश के साथ प्रतिक्रिया देता है। आने वाले सभी संदेशों को बाद में एक सूची में प्रदर्शित किया जाता है। सर्वर से संदेशों को लगातार सुनने में सक्षम होने के लिए हम वेबसॉकेट (डब्ल्यूएसएस प्रोटोकॉल) का उपयोग करेंगे। WebSocket कमांड का उपयोग करते हुए सर्वर को उपयोगकर्ता इनपुट भेजेगा जबकि यह सर्वर से संदेश प्राप्त करने के लिए सदस्यता का उपयोग करेगा।

आवेदन के विभिन्न घटक नीचे दिए गए हैं -

इको सर्वर

इको सर्वर को wss प्रोटोकॉल का उपयोग करके एक्सेस किया जा सकता है। इको सर्वर एप्लिकेशन को उपयोगकर्ता इनपुट वापस भेजता है। एक इको सर्वर को परिभाषित करने के लिए कोड नीचे दिया गया है -

echoServer : String
echoServer =
"wss://echo.websocket.org"

नमूना

मॉडल उपयोगकर्ता इनपुट और सॉकेट सर्वर से आने वाले संदेशों की एक सूची का प्रतिनिधित्व करता है। मॉडल को परिभाषित करने का कोड नीचे दिया गया है -

type alias Model =
   { input : String
   , messages : List String
   }

संदेशों

संदेश प्रकार में उपयोगकर्ता से पाठ इनपुट लेने के लिए इनपुट शामिल होगा। जब उपयोगकर्ता WebSocket सर्वर पर संदेश भेजने के लिए बटन क्लिक करता है तो संदेश भेजें जाएगा। NewMessage का उपयोग तब किया जाता है जब संदेश इको सर्वर से आता है।

type Msg
   = Input String
   | Send
   | NewMessage String

राय

एप्लिकेशन के दृश्य में सर्वर पर उपयोगकर्ता इनपुट भेजने के लिए एक टेक्स्टबॉक्स और सबमिट बटन होता है। सर्वर से प्रतिक्रिया एक डिव टैग का उपयोग करके व्यू पर प्रदर्शित होती है ।

view : Model -> Html Msg
view model =
   div []
      [ input [onInput Input, value model.input] []
      , button [onClick Send] [text "Send"]
      , div [] (List.map viewMessage (List.reverse model.messages))
      ]

viewMessage : String -> Html msg
viewMessage msg =
   div [] [ text msg ]

अपडेट करें

अपडेट फ़ंक्शन संदेश और मॉडल घटकों को लेता है। यह संदेश प्रकार के आधार पर मॉडल को अपडेट करता है।

update : Msg -> Model -> (Model, Cmd Msg)
update msg {input, messages} =
   case msg of
      Input newInput ->
         (Model newInput messages, Cmd.none)

   Send ->
      (Model "" messages, WebSocket.send echoServer input)

   NewMessage str ->
      (Model input (str :: messages), Cmd.none)
अनु क्रमांक। तरीका हस्ताक्षर विवरण
1 WebSocket.listen सुनो: स्ट्रिंग -> (स्ट्रिंग -> संदेश) -> उप संदेश किसी वेबसैट पर आने वाले किसी भी संदेश की सदस्यता लेता है।
2 WebSocket.send भेजें: स्ट्रिंग -> स्ट्रिंग -> सीएमडी संदेश एक सर्वर पते के लिए एक wss अनुरोध भेजता है। यह महत्वपूर्ण है कि आप सुनने के साथ इस पते पर भी सदस्यता लें। यदि आप नहीं हैं, तो एक संदेश भेजने के लिए वेब सॉकेट बनाया जाएगा और फिर बंद कर दिया जाएगा।

अंशदान

सदस्यता फ़ंक्शन मॉडल ऑब्जेक्ट में लेता है। WebSocket सर्वर से संदेश प्राप्त करने के लिए, हम NewMessage के रूप में संदेश में पास होने वाले WebSocket.listen को कॉल करते हैं । जब सर्वर से एक नया संदेश आता है, तो अपडेट विधि कहा जाता है।

subscriptions : Model -> Sub Msg
subscriptions model =
WebSocket.listen echoServer NewMessage

मुख्य

मुख्य कार्य एल्म आवेदन के लिए प्रवेश बिंदु है जैसा कि नीचे दिखाया गया है।

main =
   Html.program
      { init = init
      , view = view
      , update = update
      , subscriptions = subscriptions
      }

यह सब एक साथ डालें

Step 1 - एक निर्देशिका, SubscriptionApp बनाएं और उसमें एक फ़ाइल, SubscriptionDemo.elm जोड़ें।

Step 2 - SubscriDemo.elm फ़ाइल में निम्न सामग्री जोड़ें -

import Html exposing (..)
import Html.Attributes exposing (..)
import Html.Events exposing (..)
import WebSocket

main =
   Html.program
      { init = init
      , view = view
      , update = update
      , subscriptions = subscriptions
      }

echoServer : String
echoServer =
   "wss://echo.websocket.org"

-- MODEL

type alias Model =
   { input : String
   , messages : List String
   }

init : (Model, Cmd Msg)
init =
   (Model "" [], Cmd.none)

-- UPDATE
type Msg
   = Input String
   | Send
   | NewMessage String

update : Msg -> Model -> (Model, Cmd Msg)
update msg {input, messages} =
   case msg of
      Input newInput ->
      (Model newInput messages, Cmd.none)

   Send ->
      (Model "" messages, WebSocket.send echoServer input)

   NewMessage str ->
      (Model input (str :: messages), Cmd.none)

-- SUBSCRIPTIONS
subscriptions : Model -> Sub Msg
subscriptions model =
   WebSocket.listen echoServer NewMessage

-- VIEW
view : Model -> Html Msg
view model =
   div []
      [ input [onInput Input, value model.input] []
      , button [onClick Send] [text "Send"]
      , div [] (List.map viewMessage (List.reverse model.messages))
      ]

viewMessage : String -> Html msg
viewMessage msg =
div [] [ text msg ]

Step 3 - एल्म पैकेज मैनेजर का उपयोग करके वेबसोकेट पैकेज स्थापित करें।

C:\Users\dell\elm\SubscriptionApp> elm-package install elm-lang/websocket

Step 4 नीचे दिए गए अनुसार index.html फ़ाइल बनाएँ और जनरेट करें।

C:\Users\dell\elm\SubscriptionApp> elm make .\SubscriptionDemo.elm

Step 5 - निष्पादन के बाद, निम्न आउटपुट उत्पन्न होगा -

ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2025 | All Rights Reserved