अमृत

नमस्कार, आज मैं आपको BeamVM (या ErlangVM) के लिए आधुनिक प्रोग्रामिंग भाषा के बारे में बताऊंगा।
पहला भाग मूल बातें करने के लिए एक अपूर्ण परिचय है, और लेख का दूसरा भाग सरल उदाहरणों के साथ दिखाता है जो भाषा की मुख्य विशेषताएं हैं जो erlang डेवलपर के लिए नई हैं।

दो साल पहले, अमृत का 0.1 संस्करण जारी किया गया था, जिसे पहले ह्रासोसिटी के लिए पेश किया गया था।

उद्धरण:

“एर्लैंग अपनी क्षमताओं में एक अनूठा मंच है, और इसके बावजूद, भाषा अभी भी विदेशी है। इसके कई कारण हैं। उदाहरण के लिए, तंग अंकगणित, असामान्य वाक्यविन्यास, कार्यक्षमता। ये दोष नहीं हैं। ये केवल ऐसी चीजें हैं जो अधिकांश प्रोग्रामर के साथ काम नहीं कर सकते हैं या नहीं करना चाहते हैं। ”

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

अमृत ​​में नया:

• रूबी की तरह वाक्य रचना (रूबी में पसंद नहीं शब्दार्थ)
• प्रोटोकॉल बहुरूपता
• metaprogramming
• मानकीकृत पुस्तकालय
• "फर्स्ट क्लास शेल"
• और बहुत, बहुत अधिक

एक ही समय में, यह एरलांग बीम-कोड में संकलित करता है; अमृत ​​भी आपको डेटा प्रकारों को परिवर्तित करने की आवश्यकता के बिना इरलैंग मॉड्यूल को कॉल करने की अनुमति देता है, इसलिए एरालांग कोड को कॉल करते समय कोई प्रदर्शन जुर्माना नहीं है।

इसे आज़माने के लिए, आप इसे गीथूब से डाउनलोड कर सकते हैं:

$ git clone https://github.com/elixir-lang/elixir.git $ cd elixir $ make test 

या precompiled संस्करण स्थापित करें।

और फेडोरा, मैक ओएस या आर्क लिनक्स के मालिकों के लिए, आप पैकेज मैनेजर के माध्यम से अमृत स्थापित कर सकते हैं:

• मैक ओएस एक्स के लिए होमब्रे
  

  1.  $ brew tap homebrew/versions $ brew install erlang-r16 

  2. यदि erlang का पिछला संस्करण स्थापित है, तो आपको erlang के नए संस्करण को लिंक करने की आवश्यकता है:
     

      $ brew uninstall erlang $ brew link erlang-r16 

  3. अमृत ​​स्थापित करें:
     

      $ brew update $ brew install elixir 

     
     
  
  
• फेडोरा 17+ और फेडोरा रॉहाइड: सुडोम यम-एल अमृत
• आर्क लिनक्स: अमृत के माध्यम से उपलब्ध अमृत: yaourt -S अमृत

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

टिप्पणी:

 # This is a commented line 

इसके अलावा, "# =>" अभिव्यक्ति का अर्थ दिखाता है:

 1 + 1 # => 2 

कंसोल से उदाहरण:

 $ bin/iex defmodule Hello do def world do IO.puts "Hello World" end end Hello.world 

अमृत ​​में डेटा प्रकार erlang में समान हैं:

 1 # integer 0x1F # integer 1.0 # float :atom # atom / symbol {1,2,3} # tuple [1,2,3] # list <<1,2,3>> # binary 

एलींगिर में स्ट्रिंग्स, जैसा कि एलांग-ई में है, को सूचियों या बाइनरी के माध्यम से दर्शाया जा सकता है:

 'I am a list' "I am a binary or a string" name = "World" "Hello, #{name}" # => string interpolation 

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

A में मल्टी-लाइन स्ट्रिंग्स भी हैं:

 """ This is a binary spawning several lines. """ 

फ़ंक्शन कॉल, हम पहले से ही मॉड्यूल के लिए ऊपर देख चुके हैं, लेकिन यह संभव है कि, कोष्ठक को छोड़ दें:

 div(10, 2) div 10, 2 

अमृत ​​के लिए एक अच्छी प्रोग्रामिंग शैली की सिफारिश की जाती है, यदि आप कोष्ठक को छोड़ देते हैं, तो मैक्रो का उपयोग करते समय।
मानक पुस्तकालय में कोडिंग स्टाइल का कहना है कि कॉल फ़ंक्शन के लिए कोष्ठक होना चाहिए।

अमृत ​​में चर अभी भी अपरिवर्तनीय हैं, लेकिन आप पुनर्मूल्यांकन कर सकते हैं:

 x = 1 x = 2 

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

 {x, x} = {1,2} # => ** (MatchError) no match of right hand side value: {1,2} {a, b, [c | _]} = {1,2,["a", "b", "c"]} # => a = 1 b = 2 c = "a" a = 1 # => 1 a = 2 # => 2 ^a = 3 # => ** (MatchError) no match of right hand side value: 3 

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

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

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

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

 defmodule Hello do def world do IO.puts "Hello World" end end 

हम इसे एक फ़ाइल में साफ करते हैं और इसे इस तरह संकलित करते हैं:

 $ elixirc hello.ex 

या हम कंसोल पर कॉपी करते हैं, और हमारा मॉड्यूल वहां संकलित है। किसी भी मामले में, हम ध्यान से देखते हैं कि संकलन के दौरान क्या होता है। फिलहाल कुछ खास नहीं।

आइए हमारे उदाहरण को थोड़ा बदलें:

 defmodule Hello do IO.puts "Hello Compiler" def world do IO.puts "Hello World" end end 

अब, संकलन के दौरान, हम "हेलो कंपाइलर" देख सकते हैं।

अब संकलन के आधार पर अपने मॉड्यूल में कुछ बदलने की कोशिश करते हैं:

 defmodule Hello do if System.get_env("MY_ENV") == "1" do def world do IO.puts "Hello World with my Variable = 1" end else def world do IO.puts "Hello World" end end end 

अब, यदि हम कोड संकलित करते हैं, तो हम इसे कैसे संकलित करते हैं, इसके आधार पर हम देख सकते हैं:

 $ elixirc hello.ex $ iex iex> Hello.world # => "Hello World" 

या, यदि हम अपने मॉड्यूल को इस तरह संकलित करते हैं, तो हमें अपने फ़ंक्शन की एक और कार्रवाई मिलती है:

 $ MY_ENV=1 elixirc hello.ex $ iex iex> Hello.world # => "Hello World with my Variable = 1" 

और अब, चलो कुछ और दिलचस्प करने की कोशिश करते हैं, उदाहरण के लिए, कोड उत्पन्न करते हैं।
Erlang कोड में आप अक्सर यह या समान कोड पा सकते हैं:

 my_function(bad_type) -> 1; my_function(bad_stat) -> 2; ....... my_function(1) -> bad_type; my_function(2) -> bad_stat; ..... 

उदाहरण के लिए, हम एक फ़ंक्शन प्राप्त करना चाहते हैं जिसे हम इस तरह उपयोग करेंगे:

 Hello.mapper(:bad_type) # => 1 Hello.mapper(:bad_stat) # => 2 Hello.mapper(1) # => :bad_type ..... 

अमृत ​​में, हम दोहराए बिना समान फ़ंक्शन गति प्राप्त कर सकते हैं यदि हम संकलन के समय में समान कार्य उत्पन्न करते हैं:

 list = [{:bad_type, 1}, {:bad_stat, 2}] lc {type, num} inlist list do def my_function(unquote(type)), do: unquote(num) def my_function(unquote(num)), do: unquote(type) end) 

lc inlist do एक सूची संपीड़न है अमृत भाषा में, उपयोग उदाहरण:

 lc a inlist [1,2,3], do: a * 2 # => [2,4,6] 

अब, सूची संपीड़न का उपयोग करते हुए, हमने दो फ़ंक्शन प्रत्येक उत्पन्न किए हैं (या फ़ंक्शन के लिए मेल खाते हैं)।

एक उदाहरण वास्तविक कोड से लिया गया है:
एक तरीका और दूसरा तरीका
और दोनों दिशाओं में, अमृत पर

स्वयं अमृत में, आप भी देख सकते हैं, उदाहरण के लिए, यहाँ:
github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/string.ex#L478-L486

मैक्ज़ इन एलिक्ज़िर-ए एक्ट इन क्लोजर (लिस्प प्रोग्रामर्स घर पर महसूस करेंगे), आप किसी भी कोड में इसका एएसटी देख सकते हैं:

 quote do: 1+1 # => {:+,[context: Elixir, import: Kernel],[1,1]} quote do: {1,2,3,4} # => {:"{}",[],[1,2,3,4]} quote do: sum(1,2) # => {:sum,[],[1,2]} quote do: sum(1, 2 + 3, 4) # => {:sum,[],[1,{:+,[context: Elixir, import: Kernel],[2,3]},4]} 

जैसा कि आप उदाहरणों से देख सकते हैं, एएसटी में तीन तत्व होते हैं: {नाम, मेटा, दलीलें}
अब, हमारी पहली मैक्रो लिखने की कोशिश करें:

 defmodule MyMacro do defmacro unless(clause, options) do quote do: if(!unquote(clause), unquote(options)) end end 

अब हमारे मैक्रो का उपयोग करें:

 require MyMacro MyMacro.unless 2 < 1, do: 1 + 2 

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

 defmodule TestRegex do def myregex_test do :re.run("abc", "([az]+)", [{:capture, :all_but_first, :list}]) end end 

और अब, ऊपर हमारे ज्ञान का उपयोग करके, हम रेगेक्स संकलन बना सकते हैं, जिससे हमारा रनटाइम कोड तेजी से हो सकता है:

 defmodule TestRegexOptimized do {:ok, regex} = :re.compile("([az]+)") escaped_regex = Macro.escape(regex) def myregex_test do :re.run("abc", unquote(escaped_regex), [{:capture, :all_but_first, :list}]) end end 

इस उदाहरण में, हमने फ़ंक्शन के बाहर एक नियमित अभिव्यक्ति संकलित की है। Macro.escape का उपयोग करना (मैक्रो मॉड्यूल में कई अन्य उपयोगी कार्य हैं) हमने अपने फ़ंक्शन में पहले से संकलित नियमित अभिव्यक्ति सम्मिलित की, फिर भी कोड में एक पठनीय संस्करण है। वास्तव में, नियमित अभिव्यक्ति वाले एक अमृत में आपको ऐसा करने की आवश्यकता नहीं है, क्योंकि% r मैक्रो पहले से ही आपके लिए ऐसा करता है, इस पर निर्भर करता है कि क्या आप तुरंत नियमित अभिव्यक्ति संकलित कर सकते हैं।

इस प्रकार, हम अपने कार्य की गति की तुलना कर सकते हैं:

 Enum.map(1..1000, fn(_) -> elem(:timer.tc(TestRegex, :myregex_test, []), 0) end) |> List.foldl(0, &1 + &2) # => 4613 Enum.map(1..1000, fn(_) -> elem(:timer.tc(TestRegexOptimized, :myregex_test, []), 0) end) |> List.foldl(0, &1 + &2) # => 3199 

बहुरूपता:

 list = [{:a, 1}, {:b, 2}, {:c, 3}, {:d, 4}, {:e, 5}, {:f, 6}, {:g, 7}, {:h, 8}, {:k, 9}] Enum.map(list, fn({a, x}) -> {a, x * 2} end) dict = HashDict.New(list) Enum.map(dict, fn({a, x}) -> {a, x * 2} end) file = File.iterator!("README.md") lines = Enum.map(file, fn(line) -> Regex.replace(%r/"/, line, "'") end) File.write("README.md", lines) 

उदाहरण दिखाता है कि हम Enumerable प्रोटोकॉल को लागू करने वाले किसी भी डेटा प्रकार पर Enum लाइब्रेरी का उपयोग कर सकते हैं।

प्रोटोकॉल के लिए कार्यान्वयन प्रोटोकॉल की परवाह किए बिना, कहीं भी स्थित हो सकता है: मुख्य बात यह है कि संकलित कोड स्थित है जहां बीईएमवीएम इसे पा सकता है (जो कि: source.get_path में है)। यानी उदाहरण के लिए, आप अपने डेटा प्रकारों के लिए उनके कोड को बदले बिना मौजूदा पुस्तकालयों का विस्तार कर सकते हैं।

एक और दिलचस्प अंतर्निहित प्रोटोकॉल एक्सेस प्रोटोकॉल है - शीर्ष सूची के उदाहरण के रूप में प्रतीक-मूल्य लें:

 list = [{:a, 1}, {:b, 2}, {:c, 3}, {:d, 4}, {:e, 5}, {:f, 6}, {:g, 7}, {:h, 8}, {:k, 9}] list[:a] # => 1 

हम बाइनरी ट्री के साथ एक बहुत ही सरल उदाहरण देंगे, जो ट्री के रिकॉर्ड में होगा, और हमारे ट्री के लिए हम एक्सेस प्रोटोकॉल को भी लागू करेंगे।

 defmodule TreeM do def has_value(nil, val), do: nil def has_value({{key, val}, _, _}, key), do: val def has_value({_, left, right}, key) do has_value(left, key) || has_value(right, key) end end defrecord Tree, first_node: nil defimpl Access, for: Tree do def access(tree, key), do: TreeM.has_value(tree.first_node, key) end 

अब, उसी तरह, हम एक्सेस प्रोटोकॉल के माध्यम से अपने मूल्यों को पा सकते हैं।

 tree = Tree.new(first_node: {{:a, 1}, {{:b, 2}, nil, nil}, {{:c, 3}, nil, nil}}) tree[:a] # => 1 

प्रोटोकॉल बहुरूपता देते हैं।

और अब, थोड़ा सा सिन्सेटैक्ट चीनी, जो कुछ स्थितियों में कोड लिखना और पढ़ना आसान बनाता है।
[{: a, 1}] को इस तरह लिखा जा सकता है: [a: 1]

उसी तरह, आपको अक्सर निर्माण लिखना पड़ता है जैसे:
func3 (func2 (func1 (list))), इस तथ्य के बावजूद कि func1 फ़ंक्शन को पहले कहा जाएगा, हम पहले func3 लिखते हैं या इस मामले में चर दर्ज करना चाहिए:

 file = File.iterator!("README.md") lines = Enum.map(file, fn(line) -> Regex.replace(%r/"/, line, "'") end) File.write("README.md", lines) 

पाइपलाइन (|>>) ऑपरेटर का उपयोग करके, हम अपने उदाहरण को इस तरह से फिर से लिख सकते हैं:

 lines = File.iterator!("README.md") |> Enum.map(fn(line) -> Regex.replace(%r/"/, line, "'") end) File.write("README.md", lines) 

अमृत ​​पुस्तकालय में, मानकीकृत विषय पहला तर्क है। और यह संभव बनाता है।>> ऑपरेटर की मदद से, जो अगली कॉल में फ़ंक्शन के पहले तर्क के रूप में पिछली कार्रवाई के परिणाम को समझता है, और अधिक समझने योग्य, कॉम्पैक्ट और अनुक्रमिक कोड लिखने के लिए।

इसके अलावा, हम इस उदाहरण को सरल मामलों में करी या हिस्सेदार का उपयोग करके सरल कर सकते हैं:

 lines = File.iterator!("README.md") |> Enum.map( Regex.replace(%r/"/, &1, "'") ) File.write("README.md", lines) 

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