नेमर्ले

From Vigyanwiki

नेमर्ले सामान्य-उद्देश्य, उच्च स्तरीय, वैधानिक रूप से स्थिर लिखी गयी प्रोग्रामिंग भाषा है। कॉमन लैंग्वेज इन्फ्रास्ट्रक्चर (.NET/Mono) का उपयोग करने वाले प्लेटफार्मों के लिए रूपांकित किया गया है। यह कार्यात्मक प्रोग्रामिंग , वस्तु-उन्मुख, पक्ष-उन्मुख प्रोग्रामिंग , चिंतनशील प्रोग्रामिंग और अनिवार्य प्रोग्रामिंग सुविधाएँ प्रदान करता है। इसमें साधारण सी-शार्प अर्थात सी#-जैसे सिंटैक्स और शक्तिशाली मेटाप्रोग्रामिंग प्रणाली है।

जून 2012 में, जांच सॉफ्टवेयर विकास क्षेत्र जेटब्रेन्स द्वारा नेमर्ले के मुख्य विकासकर्ताओं को काम पर रखा गया था। यह समूह नाइट्रा(नित्रा) को विकसित करने पर ध्यान केंद्रित कर रहा था, जो आधुनिक और नई प्रोग्रामिंग भाषाओं को प्रयुक्त करने के लिए रूपरेखा है।[1][2][3] नेमर्ले भाषा और नाइट्रा दोनों को जेटब्रेन्स द्वारा छोड़ दिया गया अथवा इन्हें बंद कर दिया गया है; नाइट्रा को 2017 के बाद से इसके मूल रचनाकारों द्वारा अपडेट नहीं किया गया है और नेमर्ले को अब पूरी तरह से रूसी सॉफ्टवेयर विकास नेटवर्क, जेटब्रेन्स से स्वतंत्र रूप से बनाए रखा गया है, चूंकि अभी तक कोई बड़ा अपडेट जारी नहीं किया गया है और विकास बहुत धीमी गति से आगे बढ़ रहा है। जेटब्रेन्स द्वारा वर्षों से न तो नेमेर्ले और न ही नाइट्रा का उल्लेख या संदर्भ दिया गया है।

विशेषताएं

नेमर्ले की सबसे उल्लेखनीय विशेषता प्रोग्रामिंग की शैलियों को मिलाने की क्षमता है जो वस्तु उन्मुख और क्रियाशील हैं। प्रोग्राम को वस्तु उन्मुख अवधारणाएँ जैसे वर्गों और नाम-स्थान का उपयोग करके संरचित किया जा सकता है, अपितु विधियों को कार्यात्मक शैली में लिखा जा सकता है। अन्य उल्लेखनीय विशेषताओं में सम्मिलित बिंदु निम्नवत हैं:

उच्च-स्तरीय प्रोग्रामिंग भाषा जावा है। मेटाप्रोग्रामिंग प्रणाली क्रमादेशकों से संभवतानुसार भार उठाने के लिए उच्च-स्तरीय दृष्टिकोण लेते हुए , महान संकलक विस्तारशीलता , डोमेन-विशिष्ट भाषाओं को एम्बेड करने , आंशिक मूल्यांकन और पक्ष-उन्मुख प्रोग्रामिंग की अनुमति देता है। भाषा प्राचलिक बहुरूपता, अज्ञात फंक्शन, विस्तार विधियों आदि सहित सभी कॉमन लैंग्वेज इन्फ्रास्ट्रक्चर(सीएलआई) मानक सुविधाओं को जोड़ती है। .NET/Mono प्लेटफार्म में सम्मिलित पुस्तकालयों तक पहुँचना सी# जितना सरल है।

प्रकार का निष्कर्ष

def x = 1;           // int
def myList = List(); // generic List[T], type T is deduced from the usage in the next line
myList.Add(x);       // compiler deduces type of T as int making myList type of List[int]

सब अभिव्यक्ति है

def x =
  { // similar to x = 3
    def y = 1;
    def z = 2;
    y + z   // this last statement is a block return value
  };

def x =
  if (DateTime.Now.DayOfWeek == DayOfWeek.Monday)  // if, using, try are also expressions
    "Monday"
  else
    "other day";

def x = try int.Parse(someString)
        catch { | FormatException() => 0 };

def x = returnBlock : 
  {
    foreach (i in [1, 2, 3])
      when (i > 2)
        returnBlock(true); // exit block (x = true)

    false // x = false
  };

टुपल्स

def k = (1, "one"); // k : (int * string)
def (a, b) = k; // a = 1, b = "one"

प्रतिरूप मिलान

def result = match (number)
{
  | 0            => "zero"
  | 1            => "one"
  | x when x < 0 => "negative"
  | _            => "more than one"
}
Other pattern matching examples

Type matching with variable binding: 

def check (o : object) {
  match (o) 
  {
    | i is int    => $"An int: $i"
    | s is string => $"A string: $(s.ToUpper())"
    | _           => "Object of another type"
  }
}

Tuple pattern matching: 

match (tuple) 
{
  | ( 42, _ ) => "42 on first position"
  | ( _, 42 ) => "42 on second position"
  | ( x, y )  => $"( $x, $y )"
}

Regexp matching: 

using Nemerle.Text;
regexp match (str) {
  | "a+.*"                          => printf("a\n");
  | @"(?<num : int>\d+)-\w+"        => printf("%d\n", num + 3);
  | "(?<name>(Ala|Kasia))? ma kota" =>
     match (name) 
     {
       | Some (n) => printf("%s\n", n)
       | None     => printf("noname?\n")
     }

  | _                               => printf("default\n");
}

कार्यात्मक प्रकार और स्थानीय फंक्शन

using System.Console; // classes and modules (static classes) can be put in namespaces
def next(x) { x + 1 }; // the type of x argument and other function arguments can be deduced from usage

def mult(x, y) { x * y };

def fibonacci(i)
{
  | 0     => 0
  | 1     => 1
  | other => fibonacci(i - 1) + fibonacci(i - 2)
};

WriteLine(next(9));        // 10  similar to "Console.WriteLine(next(9));" 
WriteLine(mult(2, 2));     // 4
WriteLine(fibonacci(10)); // 55

प्रकार

प्रकार(एसएमएल और ओकैमल में डेटा प्रकार या योग प्रकार कहा जाता है) कई अलग-अलग प्रकार के डेटा को व्यक्त करने के रूप हैं: 

variant RgbColor {
   | Red
   | Yellow
   | Green
   | Different {
       red : float;
       green : float;
       blue : float;
     }
 }

मेटाप्रोग्रामिंग

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

macro @if (cond, e1, e2)
syntax ("if", "(", cond, ")", e1, Optional (";"), "else", e2)
{
  /*
    <[ ]> defines an area of quasi-quotation, the Nemerle compiler transforms the code in it 
    to an AST, such transformations are somewhat similar to an Expression compiling in C#
  */
  <[
    match ($cond : bool)
    {
      | true => $e1
      | _ => $e2
    }
  ]>
}

// using this macro in code:
def max = if (a > b) a else b;
// during a compile time the upper line will be transformed to this:
def max = match (a > b)
{
  | true => a
  | _    => b
}

ब्रेसलेस सिंटैक्स

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

निम्नलिखित कर्ली-ब्रेस स्निपेट:

using System.Console;

[Qux]
class FooBar {
  public static Main(): void {
    WriteLine("Hello")
  }

  static Foo (x: int): void {
    if (x == 3) {
      def y = x * 42;
      Foo (x)
    } else {
      [x].Map (fun (x) {
        x * 2
      })
    }
  }

  static Bar(): int {
    def foo = 2 + 7 * 13;
    foo
  }
}

इसे अन्य रूप में इस निम्न प्रकार फिर से लिखा जा सकता है:

using System.Console;

[Qux] \
class FooBar
  public static Main(): void
    WriteLine("Hello")

  static Foo (x: int): void
    if (x == 3) 
      def y = x * 42;
      Foo (x)
    else
      [x].Map (fun (x) {
        x * 2
      })

  static Bar(): int
    def foo = 2 + 7 * 13
    foo

विशेष रूप से, बैकस्लैश \ का उपयोग किए बिना कई पंक्तियों में मैचों में अभिव्यक्तियों या वैकल्पिक खंडों को तोड़ना संभव नहीं है:

// This will not compile ...

static Bar(): int
  def foo = 2 
     + 7 
     * 13
  foo

match (s)
  | "a"
  | "aa" => 1
  | "b"
  | "bb" => 2
  | _ => 0
 
// But this will:

static Bar(): int
  def foo = 2 \ 
     + 7 \
     * 13
  foo

match (s)
  | "a" \
  | "aa" => 1
  | "b" \
  | "bb" => 2
  | _ => 0

इस सिंटैक्स को सक्रिय करने के लिए, उपयोगकर्ता को जोड़ना होगा फ़ाइल के शीर्ष पर #pragma indent या संकलक विकल्प-iका उपयोग करते है।

आईडीई

नेमर्ले को एकीकृत विकास पर्यावरण(आईडीई) विजुअल स्टूडियो 2008 में एकीकृत किया जा सकता है। इसमें विजुअल स्टूडियो 2008 शेल (विजुअल स्टूडियो एक्सप्रेस संस्करण की तरह) और SharpDevelop (लिंक टू प्लगइन सोर्स कोड) पर आधारित पूरी तरह से मुफ्त आईडीई भी है।[4]

ऐड-इन्स और एक्सटेंशन का उपयोग करके नेमर्ले को विजुअल स्टूडियो (2017 तक) में भी एकीकृत किया जा सकता है।[5]

उदाहरण

हैलो, विश्व!

पारंपरिक हैलो वर्ल्ड! प्रोग्राम अधिक सी #-जैसी फैशन में कार्यान्वित किया जा सकता है:

class Hello
{
  static Main () : void
  {
    System.Console.WriteLine ("Hello, world!");
  }
}

या अधिक सरलता से:

System.Console.WriteLine("Hello, world!");

मैक्रोज़ के उदाहरण

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

स्ट्रिंग स्वरूपण

स्ट्रिंग स्वरूपण मैक्रो $ संकेतन का उपयोग करके चर को स्ट्रिंग नष्ट और निर्माण के लिए सरल करता है:

def s = $"The number is $i"; //insert the value of the variable i where $i is placed 
def s = $"$x + $y = $(x+y)"; // $(...) can be used to make calculations or access members

घोषणात्मक कोड जेनरेशन

संरचनात्मक समानता, मेमोइज़, जेसन, और मैक्रोज़ हैं जो संकलन समय में कोड उत्पन्न करते हैं। चूंकि उनमें से कुछ(संरचनात्मक समानता, मेमोइज़) सी# विशेषताओं की तरह दिख सकते हैं, संकलन के समय, उन्हें संकलक द्वारा जांचा जाएगा और उनके मैक्रोज़ द्वारा पूर्वनिर्धारित तर्क का उपयोग करके उपयुक्त कोड में बदल दिया जाएगा।

[StructuralEquality] // Implement IEquatable[Sample] .Net interface using by element comparison equality.
class Sample
{
   [Memoize]  // remember first evaluation result 
   public static SomeLongEvaluations() : int  
   {
       MathLib.CalculateNthPrime(10000000)
   }

   [DependencyProperty] // WPF dependency property
   public DependencyPropertySample { get; set; }
   
   public static Main() : void
   {
/* syntax macro "json" generates code: 
JObject.Object([("a", JValue.Number(SomeLongEvaluations())), ("b", JValue.Number(SomeLongEvaluations() + 1))])
*/
       def jObject = json { a: SomeLongEvaluations(); b: (SomeLongEvaluations() + 1)} 
// object initialization macro "<-" is development of C# curly brackets object initialization
       def k = Diagnostics.Process() <- 
       {
          StartInfo <- // can init inner objects properties without ctor call
          {
              FileName = "calc.exe";
              UseShellExecute = true;
          }   
          Exited += () => WriteLine("Calc done"); // events and delegates
       }

       ReadLine();
   }
}

डेटाबेस पहुंच

एसक्यूएल के लिए नेमर्ले मैक्रोज़ का उपयोग करके आप लिख सकते हैं:

ExecuteReaderLoop("SELECT firstname, lastname FROM employee WHERE firstname = $myparm", dbcon,
  {
    WriteLine ($"Name: $firstname $lastname")
  });

इसके अतिरिक्त:

string sql = "SELECT firstname, lastname FROM employee WHERE firstname = :a";
using (NpgsqlCommand dbcmd = new NpgsqlCommand (sql, dbcon, dbtran))
{
  dbcmd.Parameters.Add("a", myparm);

  using (NpgsqlReader reader = dbcmd.ExecuteReader())
  {
     while(reader.Read()) 
     {
        var firstname = reader.GetString (0);
        var lastname = reader.GetString (1);
        Console.WriteLine ("Name: {0} {1}", firstname, lastname)
     }
  }
}

और यह केवल लाइब्रेरी में कुछ संचालन छुपा नहीं रहा है, किंतु क्वेरी स्ट्रिंग को समझने के लिए संकलक द्वारा किया गया अतिरिक्त कार्य, वहां उपयोग किए जाने वाले चर, और स्तम्भ डेटाबेस से लौटाए गए हैं। ExecuteReaderLoop (रीडरलूप निष्पादित करें) मैक्रो आपको मैन्युअल(स्वनिर्मित) रूप से अंकित करने के लिए सामान्यतः समतुल्य कोड उत्पन्न करेगा। इसके अतिरिक्त, यह जाँचने के लिए संकलन समय पर डेटाबेस से जुड़ता है कि आपकी एसक्यूएल क्वेरी वास्तव में समझ में आती है।

नई भाषा का निर्माण

नेमर्ले मैक्रोज़ के साथ आप भाषा में कुछ नए सिंटैक्स भी प्रस्तुत कर सकते हैं:

macro ReverseFor (i, begin, body)
syntax("ford", "(", i, ";", begin, ")", body)
{
   <[ for ($i = $begin; $i >= 0; $i--) $body ]>
}

ford(EXPR; EXPR) EXPR सिंटैक्स को प्रस्तुत करते हुए एक मैक्रो को परिभाषित करता है और इसका उपयोग किया जा सकता है:

ford (i ; n) print (i);

एएसपी.नेट के साथ नेमेर्ले

नेमर्ले को या तो सीधे एएसपी.नेट(ASP.NET) में एम्बेड किया जा सकता है:

<%@ Page Language="Nemerle" %>
<script runat="server">

    Page_Load(_ : object, _ : EventArgs) : void {
        Message.Text = $"You last accessed this page at: $(DateTime.Now)";
    }

    EnterBtn_Click(_ : object, _ : EventArgs) : void {
        Message.Text = $"Hi $(Name.Text), welcome to ASP.NET!";
    }

</script>

<html>
    <body>
        <form runat="server">
            Please enter your name: <asp:TextBox ID="Name" runat="server" />
            <asp:Button OnClick="EnterBtn_Click" Text="Enter" runat="server" />

            <p><asp:Label ID="Message" runat="server" /></p>
        </form>
    </body>
</html>

..अथवा एक अलग फ़ाइल(लिखित पत्र) में संग्रहीत और एक पंक्ति के साथ अंकित किया गया:

<%@ Page Language="Nemerle" Src="test.n" Inherits="Test" %>

पी इनवोक

नेमेर्ले वास्तविक प्लेटफार्म पुस्तकालय का लाभ उठा सकता है। सिंटैक्स सी# और अन्य .नेट भाषाओं के समान है। यहाँ सबसे सरल उदाहरण है:

using System;
using System.Runtime.InteropServices;

class PlatformInvokeTest
{
    [DllImport("msvcrt.dll")]
    public extern static puts(c : string) : int;

    [DllImport("msvcrt.dll")]
    internal extern static _flushall() : int;

    public static Main() : void
    {
        _ = puts("Test");
        _ = _flushall();
    }
}

संदर्भ

  1. ↑ "Twitter / orangy: We've decided to bring Nemerle". Twitter.com. Retrieved 2013-09-05.
  2. ↑ "JetBrains .NET Tools Blog » JetBrains and Nemerle". Blogs.jetbrains.com. 2012-06-27. Retrieved 2013-09-05.
  3. ↑ "Google Discussiegroepen". Retrieved 2013-09-05.
  4. ↑ Nemerle Studio Microsoft Setup Installer can be installed after installing Visual Studio Shell 2008 Isolated
  5. ↑ Visual Studio 2010 add-in

अग्रिम पठन

बाहरी संबंध

Retrieved from ‘https://www.vigyanwiki.in/index.php?title=नेमर्ले&oldid=108623’