Erlang Language ट्यूटोरियल
Erlang भाषा के साथ आरंभ करना

टिप्पणियों

संस्करण

नमस्ते दुनिया

Erlang में "हैलो वर्ल्ड" एप्लिकेशन लिखते समय आपको दो बातें जाननी होंगी:

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

पहला आवेदन स्रोत कोड:

एक नई फ़ाइल बनाएं hello.erl जिसमें निम्नलिखित हैं:

-module(hello).
-export([hello_world/0]).

hello_world() ->
  io:format("Hello, World!~n", []).

आइए इस पर एक त्वरित नज़र डालें कि इसका क्या अर्थ है:

• -module(hello). सभी erlang फ़ंक्शन एक मॉड्यूल के अंदर मौजूद हैं। मॉड्यूल का उपयोग अनुप्रयोगों के निर्माण के लिए किया जाता है, जो मॉड्यूल का एक संग्रह है। यह पहली पंक्ति इस मॉड्यूल की पहचान करना है, जिसका नाम है हैलो । मॉड्यूल की तुलना जावा के पैकेज से की जा सकती है
• -export([hello_world/0]). संकलक को बताता है जो "सार्वजनिक" (जब ओओ भाषाओं की तुलना में) बनाने के लिए कार्य करता है, और प्रासंगिक फ़ंक्शन की योग्यता । फ़ंक्शन को ले जाने वाले तर्कों की संख्या है। चूंकि erangang में 1 तर्क के साथ एक फ़ंक्शन को 2 तर्क के साथ एक से भिन्न फ़ंक्शन के रूप में देखा जाता है, भले ही नाम बिल्कुल समान हो। यानी, hello_world/0 उदाहरण के लिए hello_world/1 से पूरी तरह से अलग कार्य है।
• hello_world() यह फ़ंक्शन का नाम है। -> फ़ंक्शन के कार्यान्वयन (निकाय) में संक्रमण को इंगित करता है। इसे "hello_world () के रूप में परिभाषित किया जा सकता है ..."। ध्यान दें कि VM में hello_world() (कोई तर्क नहीं) की पहचान hello_world/0 द्वारा की गई है, और hello_world(Some_Arg) रूप में hello_world/1 ।
• io:format("Hello, World!~n", []) मॉड्यूल io , फ़ंक्शन format/2 फ़ंक्शन को कहा जाता है, जो मानक आउटपुट के लिए फ़ंक्शन है। ~n एक प्रारूप निर्दिष्टकर्ता है जिसका अर्थ है कि एक नई पंक्ति मुद्रित करना। [] आउटपुट स्ट्रिंग में प्रारूप विनिर्देशकों द्वारा इंगित करने के लिए चर की एक सूची है, जो इस मामले में कुछ भी नहीं है।
• सभी erlang स्टेटमेंट a के साथ समाप्त होने चाहिए . (डॉट)।

एर्लैंग में, एक फ़ंक्शन में अंतिम विवरण का परिणाम वापस आ जाता है।

अब, चलो हमारे आवेदन चलाते हैं:

फ़ाइल निर्देशिका hello.erl फ़ाइल के समान निर्देशिका से erlang शेल प्रारंभ करें:

$ erl

आपको एक संकेत मिलना चाहिए जो कुछ इस तरह दिखता है (आपका संस्करण अलग हो सकता है):

Eshell V8.0  (abort with ^G)
1>

अब निम्नलिखित कमांड दर्ज करें:

1> c(hello).
{ok,hello}
2> hello:hello_world().
Hello, World!
ok

आइए एक-एक करके हर पंक्ति को देखें:

• c(hello) - यह कमांड फंक्शन c को atom hello कहती है। यह प्रभावी रूप से Erlang को फ़ाइल hello.erl को खोजने के लिए कहता है, इसे एक मॉड्यूल में संकलित करें ( hello.beam नामक फ़ाइल निर्देशिका में उत्पन्न होगी) और इसे पर्यावरण में लोड करें।
• {ok, hello} - यह फ़ंक्शन c ऊपर कॉल करने का परिणाम है। यह एक टपल है जिसमें एक परमाणु ok और एक परमाणु hello । Erlang फ़ंक्शंस आमतौर पर या तो {ok, Something} या {error, Reason} वापस लौटते हैं।
• hello:hello_world() - यह मॉड्यूल hello से एक फ़ंक्शन hello_world() कहता है।
• Hello, World! - यह हमारा फंक्शन प्रिंट करता है।
• ok - यह वही है जो हमारा कार्य लौटा है। चूंकि Erlang एक कार्यात्मक प्रोग्रामिंग भाषा है, इसलिए प्रत्येक फ़ंक्शन कुछ देता है । हमारे मामले में, भले ही हमने hello_world() में कुछ भी वापस नहीं किया है, उस फ़ंक्शन में अंतिम कॉल io:format(...) और वह फ़ंक्शन ok लौटा, जो बदले में हमारा फ़ंक्शन वापस आ गया है।

मॉड्यूल

एक एरलैंग मॉड्यूल एक फाइल है, जिसमें जोड़े गए कार्यों को एक साथ जोड़ा जाता है। इस फ़ाइल में आमतौर पर .erl एक्सटेंशन होता है।

hello.erl नाम के साथ एक "हैलो वर्ल्ड" मॉड्यूल नीचे दिखाया गया है

-module(hello).
-export([hello_world/0]).

hello_world() ->
  io:format("Hello, World!~n", []).

फ़ाइल में, मॉड्यूल नाम घोषित करना आवश्यक है। जैसा कि पंक्ति 1 में दिखाया गया है। मॉड्यूल का नाम और फ़ाइल का नाम .erl एक्सटेंशन समान होना चाहिए।

समारोह

फ़ंक्शन निर्देशों का एक सेट है, जो एक साथ समूहीकृत होते हैं। ये समूहीकृत निर्देश एक साथ कुछ कार्य करते हैं। एर्लैंग में, सभी फ़ंक्शन एक वैल्यू लौटाएंगे जब उन्हें कॉल किया जाएगा।

नीचे एक फ़ंक्शन का एक उदाहरण है जो दो नंबर जोड़ता है

add(X, Y)-> X + Y.

यह फ़ंक्शन एक्स और वाई मूल्यों के साथ एक ऐड ऑपरेशन करता है और परिणाम देता है। फ़ंक्शन का उपयोग नीचे के रूप में किया जा सकता है

add(2,5).

फ़ंक्शन घोषणाओं में एक अर्धविराम द्वारा अलग किए गए कई खंड शामिल हो सकते हैं। इनमें से प्रत्येक खंड में तर्क का मूल्यांकन पैटर्न मिलान द्वारा किया जाता है। निम्न फ़ंक्शन 'टपल' लौटाएगा यदि तर्क फॉर्म में एक टपल है: {test, X} जहाँ X का कोई मान हो सकता है। यह 'सूची' लौटाएगा, यदि तर्क प्रपत्र ["परीक्षण", X] में लंबाई 2 की सूची है, और यह किसी अन्य मामले में '{त्रुटि, "कारण"}' लौटाएगा:

function({test, X}) -> tuple;
function(["test", X]) -> list;
function(_) -> {error, "Reason"}.

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

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

function_name(Argument) when Guard1; Guard2; ... GuardN -> (...).

फ़ंक्शन 'फ़ंक्शन_नाम' का मूल्यांकन केवल तभी किया जाएगा, जब गार्ड अनुक्रम सही होगा। Follwing फ़ंक्शन सही तभी लौटेगा जब तर्क X उचित श्रेणी में हो (0..15):

in_range(X) when X>=0; X<16 -> true;
in_range(_) -> false.

सूची की समझ

सूची की समझ मौजूदा सूची के आधार पर एक सूची बनाने के लिए एक वाक्यात्मक निर्माण है।
एरांग में एक सूची की समझ का रूप है [Expr || Qualifier1, ..., QualifierN] ।
जहां क्वालीफायर या तो जेनरेटर Pattern <- ListExpr या फ़िल्टर जैसे integer(X) या तो true या false मूल्यांकन false ।

निम्न उदाहरण एक जनरेटर और दो फिल्टर के साथ एक सूची समझ दिखाता है।

[X || X <- [1,2,a,3,4,b,5,6], integer(X), X > 3].

परिणाम एक सूची है जिसमें केवल 3 से अधिक पूर्णांक हैं।

[4,5,6]

एर्लांग शेल को शुरू करना और रोकना

Erlang खोल शुरू

UNIX सिस्टम पर आप कमांड erl साथ कमांड प्रॉम्प्ट से Erlang शेल शुरू करते हैं

उदाहरण:

$ erl
Erlang/OTP 18 [erts-7.0] [source] [64-bit] [smp:8:8] [async-threads:10] [hipe] [kernel-poll:false]

Eshell V7.0  (abort with ^G)
1> 

जब आप खोलना शुरू करते हैं, तो पाठ आपको इरलांग के किस संस्करण के बारे में जानकारी के साथ-साथ इरलांग प्रणाली के बारे में अन्य उपयोगी जानकारी भी बताता है।

विंडोज़ पर शेल शुरू करने के लिए आप विंडोज़ स्टार्ट मेनू में एरलैंग-आइकन पर क्लिक करें।

एर्लांग खोल को रोकना

आपके द्वारा टाइप किए गए erangang शेल के नियंत्रित निकास के लिए:

Erlang/OTP 18 [erts-7.0] [source] [64-bit] [smp:8:8] [async-threads:10] [hipe] [kernel-poll:false]

Eshell V7.0  (abort with ^G)
1> q().

आप UNIX सिस्टम पर Ctrl + C या Windows पर Ctrl + ब्रेक दबाकर एर्लैंग शेल से भी बाहर निकल सकते हैं, जो आपको निम्नलिखित पर लाता है:

Erlang/OTP 18 [erts-7.0] [source] [64-bit] [smp:8:8] [async-threads:10] [hipe] [kernel-poll:false]

Eshell V7.0  (abort with ^G)
1> 
BREAK: (a)bort (c)ontinue (p)roc info (i)nfo (l)oaded
       (v)ersion (k)ill (D)b-tables (d)istribution

यदि आप एक (गर्भपात के लिए) दबाते हैं तो आप सीधे शेल से बाहर निकल जाएंगे।

एरालांग खोल से बाहर निकलने के अन्य तरीके हैं: init:stop() जो q() या erlang:halt() के समान काम करता है।

पैटर्न मिलान

एर्लांग में सबसे आम संचालन में से एक पैटर्न मिलान है। फंक्शन डिक्लेरेशन और case जैसे कंट्रोल-फ्लो स्ट्रक्चर्स में वैरिएबल को वैल्यू असाइन करते समय और स्टेटमेंट receive समय इसका इस्तेमाल किया जाता है। एक पैटर्न मैचिंग ऑपरेशन के लिए कम से कम 2 भागों की आवश्यकता होती है: एक पैटर्न, और एक शब्द जो पैटर्न से मेल खाता है।

एरांग में एक चर असाइनमेंट इस तरह दिखता है:

X = 2.

अधिकांश प्रोग्रामिंग भाषा में इस ऑपरेशन का शब्दार्थ सीधा है: एक मान ( 2 ) को अपनी पसंद के नाम (चर - इस मामले में X ) से X । एरलैंग में थोड़ा अलग दृष्टिकोण है: बाएं हाथ की तरफ पैटर्न ( X ) से दाएं हाथ की तरफ ( 2 ) शब्द से मिलान करें। इस स्थिति में, प्रभाव समान होता है: चर X अब मान 2 लिए बाध्य है। हालाँकि, पैटर्न मिलान के साथ आप अधिक संरचित कार्य करने में सक्षम हैं।

{Type, Meta, Doc} = {document, {author, "Alice"}, {text, "Lorem Ipsum"}}.

यह मिलान संचालन, दाहिने हाथ की ओर की अवधि की संरचना का विश्लेषण करके, और बाईं ओर सभी चर को शब्द के उपयुक्त मानों पर लागू करने के लिए किया जाता है, ताकि बाईं ओर दाईं ओर बराबर हो जाए। इस उदाहरण में Type शब्द के लिए बाध्य है: document , Meta से {author, "Alice"} और Doc से {text, "Lorem Ipsum"} । इस विशेष उदाहरण में चर: Type , Meta और Doc को अनबाउंड माना जाता है, ताकि प्रत्येक चर का उपयोग किया जा सके।

बाध्य चर का उपयोग करके पैटर्न मिलान भी बनाया जा सकता है।

Identifier = error.

चर Identifier अब मूल्य error लिए बाध्य है। निम्नलिखित पैटर्न मिलान ऑपरेशन काम करता है, क्योंकि संरचना मेल खाती है, और बाध्य चर Identifier पास शब्द के उपयुक्त दाहिने हाथ की तरह एक ही मूल्य है।

{Identifier, Reason} = {error, "Database connection timed out."}.

एक पैटर्न मैचिंग ऑपरेशन विफल हो जाता है, जब राइट हैंड साइड टर्म और लेफ्ट हैंड साइड पैटर्न के बीच मिसमैच होता है। निम्न मिलान विफल हो जाएगा, क्योंकि Identifier मान error लिए बाध्य है, जिसके दाहिने हाथ की ओर शब्द की कोई उचित अभिव्यक्ति नहीं है।

{Identifier, Reason} = {fail, "Database connection timed out."}.
> ** exception error: no match of right hand side value {fail,"Database ..."}