नेमर्ले

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

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

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

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

विशेषताएं

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

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

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

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

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 </वाक्यविन्यास हाइलाइट>

प्रकार

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

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

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
}

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

<वाक्यविन्यास लैंग = निमेरल> मैक्रो @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का उपयोग करें।

आईडीई

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

ऐड-इन्स और एक्सटेंशन(विस्तार) का उपयोग करके नेमर्ले को विजुअल स्टूडियो (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 += () => राइटलाइन (कैल्क किया गया); // घटनाएँ और प्रतिनिधि
 }

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

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

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

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

<वाक्यविन्यास लैंग = निमेरल> रीडरलूप निष्पादित करें (पहले नाम का चयन करें, कर्मचारी से अंतिम नाम जहां पहला नाम = $ 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(रीडरलूप निष्पादित करें) मैक्रो आपको मैन्युअल(स्वनिर्मित) रूप से अंकित करने के लिए सामान्यतः समतुल्य संहिता उत्पन्न करेगा। इसके अतिरिक्त, यह जाँचने के लिए संकलन समय पर डेटाबेस से जुड़ता है कि आपकी एसक्यूएल जिज्ञासा वास्तव में समझ में आती है।

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

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

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

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

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

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

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

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

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

<वाक्यविन्यास प्रकाश लैंग = एएसपीएक्स-सीएस> <%@ पृष्ठ भाषा = नेमर्ले %> <स्क्रिप्ट रनैट = सर्वर>

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

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

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

<एचटीएमएल>

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

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

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

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

पी इनवोक

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

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

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

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

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

 सार्वजनिक स्थैतिक मुख्य (): शून्य
 {
 _ = डालता है (टेस्ट);
 _ = _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