नेमर्ले

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

जून 2012 में, जांच सॉफ्टवेयर विकास क्षेत्र जेटब्रेन्स द्वारा नेमर्ले के मुख्य विकासकर्ताओं को काम पर रखा गया था। यह समूह नाइट्रा(नित्रा) को विकसित करने पर ध्यान केंद्रित कर रहा था, जो आधुनिक और नई प्रोग्रामिंग भाषाओं को प्रयुक्त करने के लिए रूपरेखा है। नेमर्ले भाषा और नाइट्रा दोनों को जेटब्रेन्स द्वारा छोड़ दिया गया है अथवा इन्हें बंद कर दिया गया है; नाइट्रा को 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 या तीव्र विकास(लिंक टू प्लगइन सोर्स संहिता ) पर आधारित पूरी तरह से मुफ्त आईडीई भी है।

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

उदाहरण

हैलो, विश्व!

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

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();
    }
}

अग्रिम पठन

• Publications about नेमर्ले in RSDN Magazine, Russian official science magazine
• Moskal, Michał (27 June 2005). "Type Inference with Deferral" (PDF). Institute of Computer Science, University of Wrocław. {{cite journal}}: Cite journal requires |journal= (help)
• Presentation "नेमर्ले is notable" by Denis Rystsov
• Article "Unconventional languages for unconventional supercomputers" by Andrey Adinetz

बाहरी संबंध

• Official website
• GitHub project and repository (new development)
• Google Code project and repository (old development)
• नेमर्ले Forum
• नेमर्ले presentation on Microsoft Research SSCLI RFP II Capstone 2005 workshop
• नेमर्ले at 99 Bottles of Beer