नेमर्ले

Nemerle

Paradigm	Multi-paradigm: aspect-oriented, event-driven, functional, generic, imperative, meta, object-oriented, reflective
परिवार	C#
द्वारा डिज़ाइन किया गया	Kamil Skalski, Michał Moskal, Prof. Leszek Pacholski, Paweł Olszta at Wrocław University
Developer	JetBrains (formerly) RSDN
पहली प्रस्तुति	2003 (2003)
Stable release	1.2.507.0 / 6 August 2016 (2016-08-06)
टाइपिंग अनुशासन	Inferred, nominal, static, strong
प्लेटफॉर्म	CLI
फ़ाइल नाम एक्सटेंशनएस	.n
वेबसाइट	nemerle.org
Major implementations
Nemerle
Influenced by
C#, Lisp, ML

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

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

नेमेर्ले का नाम आर्कमेज नेमेर्ले के नाम पर रखा गया है, जो उर्सुला के. ले गिनी द्वारा फंतासी उपन्यास Earthsea का एक जादूगर में एक पात्र है।

विशेषताएं

Nemerle की सबसे उल्लेखनीय विशेषता प्रोग्रामिंग की शैलियों को मिलाने की क्षमता है जो ऑब्जेक्ट-ओरिएंटेड और कार्यात्मक हैं। प्रोग्राम को ऑब्जेक्ट-ओरिएंटेड कॉन्सेप्ट्स जैसे क्लासेस और नेमस्पेस का उपयोग करके संरचित किया जा सकता है, जबकि विधियों को (वैकल्पिक रूप से) एक कार्यात्मक शैली में लिखा जा सकता है। अन्य उल्लेखनीय विशेषताओं में सम्मिलित हैं:

• शक्तिशाली प्रकार का अनुमान
• एक लचीला मेटाप्रोग्रामिंग सबप्रणाली (मैक्रो (कंप्यूटर विज्ञान) का उपयोग करके)
• C#, Java (प्रोग्रामिंग लैंग्वेज), और C++ की शैली में ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग (OOP) के लिए पूर्ण समर्थन
• एमएल (प्रोग्रामिंग भाषा), OCaml, और हास्केल (प्रोग्रामिंग भाषा) की शैली में कार्यात्मक प्रोग्रामिंग के लिए पूर्ण समर्थन, इन विशेषताओं के साथ:
  • उच्च क्रम के कार्य
  • पैटर्न मिलान
  • बीजगणितीय प्रकार
  • स्थानीय कार्य
  • tuples और अनाम प्रकार
  • कार्यों का आंशिक अनुप्रयोग

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

अनुमान टाइप करें

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]

<वाक्यविन्यास लैंग = निमेरल>

डेफ एक्स = 1; // इंट मेरी सूची को परिभाषित करें = सूची (); // सामान्य सूची [टी], टाइप टी को अगली पंक्ति में उपयोग से घटाया जाता है myList.Add (एक्स); // कंपाइलर टी के प्रकार को घटाता है जैसे कि मेरी सूची प्रकार [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
  };

<वाक्यविन्यास लैंग = निमेरल>

डेफ एक्स =

 {// x = 3 के समान
   डीईएफ़ वाई = 1;
   डेफ जेड = 2;
   y + z // यह अंतिम कथन एक ब्लॉक रिटर्न वैल्यू है
 };

डेफ एक्स =

 if (DateTime.Now.DayOfWeek == DayOfWeek.Monday) // if, using, try भी भाव हैं
    सोमवार
 अन्य
    दूसरे कल ;

def x = int.Parse (कुछ स्ट्रिंग) आज़माएं

       पकड़ो { | स्वरूप अपवाद () => 0};

डीईएफ़ एक्स = रिटर्नब्लॉक:

 {
   foreach (मैं [1, 2, 3] में)
     जब (मैं > 2)
       रिटर्नब्लॉक (सत्य); // बाहर निकलें ब्लॉक (एक्स = सच)

   असत्य // x = असत्य
 };

</वाक्यविन्यास हाइलाइट>

टुपल्स

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

<वाक्यविन्यास लैंग = निमेरल>

डेफ के = (1, एक); // के: (इंट * स्ट्रिंग) डीईएफ़ (ए, बी) = के; // ए = 1, बी = एक </वाक्यविन्यास हाइलाइट>

पैटर्न मिलान

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

<वाक्यविन्यास लैंग = निमेरल>

डीईएफ़ परिणाम = मैच (संख्या) {

 | 0 => शून्य
 | 1 => एक
 | x जब x <0 => ऋणात्मक
 | _ => एक से अधिक

} </वाक्यविन्यास हाइलाइट>

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

<वाक्यविन्यास लैंग = निमेरल>

System.Console का उपयोग करना; // कक्षाएं और मॉड्यूल (स्थैतिक वर्ग) नामस्थान में रखे जा सकते हैं def अगला (x) { x + 1}; // x तर्क के प्रकार और अन्य फ़ंक्शन तर्कों को उपयोग से घटाया जा सकता है

डीईएफ़ मल्टी (एक्स, वाई) {एक्स * वाई};

डीईएफ़ फिबोनैकी (मैं) {

 | 0 => 0
 | 1 => 1
 | अन्य => फाइबोनैचि (i - 1) + फाइबोनैचि (i - 2)

};

राइटलाइन (अगला (9)); // 10 कंसोल के समान। राइटलाइन (अगला (9)); राइटलाइन (मल्टी (2, 2)); // 4 राइटलाइन (फाइबोनैचि (10)); // 55 </वाक्यविन्यास हाइलाइट>

प्रकार

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

<वाक्यविन्यास लैंग = निमेरल>

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

भिन्न आरजीबीरंग {
  | लाल
  | पीला
  | हरा
  | अलग {
      लाल : फ्लोट;
      हरा: तैरना;
      नीला : तैरना;
    }
}

</वाक्यविन्यास हाइलाइट>

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

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

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
}

यदि मैक्रो उदाहरण:

<वाक्यविन्यास लैंग = निमेरल> मैक्रो @if (cond, e1, e2) सिंटैक्स (यदि, (, cond,), e1, वैकल्पिक (;), और, e2) {

 /*
   <[ ]> अर्ध-उद्धरण के एक क्षेत्र को परिभाषित करता है, नेमेरल कंपाइलर इसमें कोड को बदल देता है
   एएसटी के लिए, ऐसे परिवर्तन कुछ सीमा तक सी # में संकलित अभिव्यक्ति के समान हैं
 */
 <[
   मैच ($ cond: बूल)
   {
     | सच => $e1
     | _ => $e2
   }
 ]>

}

// कोड में इस मैक्रो का उपयोग करना: डीईएफ़ मैक्स = यदि (ए> बी) एक और बी; // एक संकलन समय के समय ऊपरी रेखा को इसमें बदल दिया जाएगा: डीईएफ़ मैक्स = मैच (ए> बी) {

 | सच => ए
 | _ => बी

} </वाक्यविन्यास हाइलाइट>

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

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

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

<वाक्यविन्यास लैंग = नेमर्ले> System.Console का उपयोग करना;

[कुक्स]

कक्षा फूबार {

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
  }
}

 सार्वजनिक स्थैतिक मुख्य (): शून्य {
   राइटलाइन (हैलो)
 }

 स्थिर फू (एक्स: इंट): शून्य {
   यदि (एक्स == 3) {
     डीईएफ़ वाई = एक्स * 42;
     फू (एक्स)
   } अन्य {
     [एक्स]। नक्शा (मजेदार (एक्स) {
       एक्स * 2
     })
   }
 }

 स्टेटिक बार (): int {
   डेफ फू = 2 + 7 * 13;
   फू
 }

}

</वाक्यविन्यास हाइलाइट>

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

के रूप में फिर से लिखा जा सकता है:

<वाक्यविन्यास लैंग = नेमर्ले> System.Console का उपयोग करना;

[कुक्स] \ वर्ग फूबार

 सार्वजनिक स्थैतिक मुख्य (): शून्य
   राइटलाइन (हैलो)

 स्थिर फू (एक्स: इंट): शून्य
   यदि (एक्स == 3)
     डीईएफ़ वाई = एक्स * 42;
     फू (एक्स)
   अन्य
     [एक्स]। नक्शा (मजेदार (एक्स) {
       एक्स * 2
     })

 स्टेटिक बार (): इंट
   डेफ फू = 2 + 7 * 13
   फू
 

</वाक्यविन्यास हाइलाइट>

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

<वाक्यविन्यास लैंग = नेमर्ले>

// यह संकलित नहीं होगा ...

स्टेटिक बार (): इंट

 डेफ फू = 2
    + 7
    * 13
 फू

मिलान

 | ए
 | आ => 1
 | बी
 | बी बी => 2
 | _ => 0

// किन्तु यह होगा:

स्टेटिक बार (): इंट

 डेफ फू = 2 \
    + 7 \
    * 13
 फू

मिलान

 | ए  \
 | आ => 1
 | बी  \
 | बी बी => 2
 | _ => 0

</वाक्यविन्यास हाइलाइट>

// 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.

आईडीई

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

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

उदाहरण

हैलो, विश्व!

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

<वाक्यविन्यास लैंग = निमेरल> क्लास हैलो {

 स्थैतिक मुख्य (): शून्य
 {
   System.Console.WriteLine (हैलो, विश्व!);
 }

} </वाक्यविन्यास हाइलाइट>

या अधिक बस:

<वाक्यविन्यास लैंग = निमेरल> System.Console.WriteLine (हैलो, विश्व!); </वाक्यविन्यास हाइलाइट>

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

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

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

स्ट्रिंग स्वरूपण मैक्रो $ संकेतन का उपयोग करके चर को स्ट्रिंग जोड़तोड़ के लिए सरल करता है: <वाक्यविन्यास लैंग = निमेरल> def s = $ संख्या $i है; // वेरिएबल i का मान डालें जहाँ $i रखा गया है def s = $ $x + $y = $(x+y); // $(...) का उपयोग गणना करने या सदस्यों तक पहुंचने के लिए किया जा सकता है </वाक्यविन्यास हाइलाइट>

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

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

<वाक्यविन्यास लैंग = निमेरल> [संरचनात्मक समानता] // IEquatable [नमूना] प्रयुक्त करें। तत्व तुलना समानता का उपयोग करके नेट इंटरफ़ेस। वर्ग नमूना {

  [मेमोइज़] // पहले मूल्यांकन परिणाम याद रखें
  सार्वजनिक स्थैतिक कुछ लंबा मूल्यांकन (): int
  {
      MathLib.CalculateNthPrime(10000000)
  }

  [निर्भरता संपत्ति] // WPF निर्भरता संपत्ति
  सार्वजनिक निर्भरता संपत्ति नमूना {प्राप्त करें; तय करना; }
  
  सार्वजनिक स्थैतिक मुख्य (): शून्य
  {

/* सिंटैक्स मैक्रो json कोड उत्पन्न करता है: जॉब्जेक्ट.ऑब्जेक्ट ([(ए, जेवैल्यू.नंबर (कुछ लंबे मूल्यांकन ())), (बी, जेवैल्यू.नंबर (कुछ लंबे मूल्यांकन () + 1))])

• /

      def jObject = json {a: SomeLongEvaluations(); बी: (कुछ लंबे मूल्यांकन () + 1)}

// ऑब्जेक्ट इनिशियलाइज़ेशन मैक्रो <- सी # कर्ली ब्रैकेट्स ऑब्जेक्ट इनिशियलाइज़ेशन का विकास है

      def k = डायग्नोस्टिक्स.प्रोसेस () <-
      {
         StartInfo <- // सीटीआर कॉल के बिना आंतरिक वस्तुओं के गुणों में प्रवेश कर सकता है
         {
             फ़ाइलनाम = calc.exe;
             UseShellExecute = सच;
         }
         Exited += () => राइटलाइन (कैल्क किया गया); // घटनाएँ और प्रतिनिधि
      }

      पढ़ने के लिए लाइन();
  }

} </वाक्यविन्यास हाइलाइट>

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

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

<वाक्यविन्यास लैंग = निमेरल> ExecuteReaderLoop (पहले नाम का चयन करें, कर्मचारी से अंतिम नाम जहां पहला नाम = $ myparm, dbcon,

 {
   राइटलाइन ($ नाम: $firstname $lastname )
 });

</वाक्यविन्यास हाइलाइट>

के अतिरिक्त

<वाक्यविन्यास लैंग = निमेरल> स्ट्रिंग एसक्यूएल = पहले नाम का चयन करें, कर्मचारी से अंतिम नाम जहां पहला नाम =: ए; (NpgsqlCommand dbcmd = new NpgsqlCommand (sql, dbcon, dbtran) का उपयोग करके) {

 dbcmd.Parameters.Add (ए, myparm);

 (NpgsqlReader रीडर = dbcmd.ExecuteReader ()) का उपयोग करना
 {
    जबकि (पाठक। पढ़ें ())
    {
       वर प्रथम नाम = पाठक.GetString (0);
       var अंतिम नाम = पाठक। गेटस्ट्रिंग (1);
       कंसोल.राइटलाइन (नाम: {0} {1}, पहला नाम, अंतिम नाम)
    }
 }

} </वाक्यविन्यास हाइलाइट>

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

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

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

<वाक्यविन्यास लैंग = नेमर्ले> मैक्रो रिवर्सफॉर (i, start, body) सिंटैक्स ( ford , ( , i ; , start ) , body) {

  <[ for ($i = $begin; $i >= 0; $i--) $body ]>

} </वाक्यविन्यास हाइलाइट>

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

फोर्ड (आई; एन) प्रिंट (आई);

=== ASP.NET === के साथ Nemerle Nemerle को या तो सीधे ASP.NET में एम्बेड किया जा सकता है: <वाक्यविन्यास प्रकाश लैंग = एएसपीएक्स-सीएस> <%@ पृष्ठ भाषा = Nemerle%> <स्क्रिप्ट रनैट = सर्वर>

   पेज_लोड (_: ऑब्जेक्ट, _: इवेंटआर्ग): शून्य {
       Message.Text = $ आप पिछली बार इस पेज पर पहुंचे थे: $(DateTime.Now);
   }

   EnterBtn_Click(_ : वस्तु, _ : EventArgs): शून्य {
       Message.Text = $ Hi $(Name.Text), ASP.NET में आपका स्वागत है! ;
   }

</स्क्रिप्ट>

<एचटीएमएल>

   <शरीर>
       <फॉर्म रनैट = सर्वर>
           कृपया अपना नाम अंकित करें: <एएसपी: टेक्स्टबॉक्स आईडी = नाम रनैट = सर्वर />
           <एएसपी: बटन ऑनक्लिक = एंटरबीटीएन_क्लिक टेक्स्ट = रनैट अंकित करें = सर्वर />

<asp:लेबल आईडी= संदेश रनैट= सर्वर />

       </रूप>
   </शरीर>

</html> </वाक्यविन्यास हाइलाइट> ... या एक अलग फ़ाइल में संग्रहीत और एक पंक्ति के साथ अंकित किया गया: <वाक्यविन्यास प्रकाश लैंग = एएसपीएक्स-सीएस> <%@ पृष्ठ भाषा = Nemerle Src= test.n Inherits= Test %> </वाक्यविन्यास हाइलाइट>

पी इनवोक

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

<वाक्यविन्यास प्रकाश लैंग = csharp> प्रणाली का उपयोग करना; System.Runtime.InteropServices का उपयोग करना;

क्लास प्लेटफार्म इनवोकटेस्ट {

   [DllImport( msvcrt.dll )]
   सार्वजनिक बाहरी स्थैतिक डालता है (सी: स्ट्रिंग): int;

   [DllImport( msvcrt.dll )]
   आंतरिक बाहरी स्थिर _flushall (): int;

   सार्वजनिक स्थैतिक मुख्य (): शून्य
   {
       _ = डालता है (टेस्ट);
       _ = _flushall ();
   }

} </वाक्यविन्यास हाइलाइट>

अग्रिम पठन

• Publications about Nemerle 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 "Nemerle 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)
• Nemerle Forum
• Nemerle presentation on Microsoft Research SSCLI RFP II Capstone 2005 workshop
• Nemerle at 99 Bottles of Beer