Nemerle - Nemerle

Nemerle
ParadigmaMulti-paradigma: funkční, rozkazovací způsob, meta, objektově orientovaný
NavrhlKamil Skalski, Michał Moskal, prof. Leszek Pacholski, Paweł Olszta at Vratislavská univerzita
VývojářJetBrains
Poprvé se objevil2003; Před 17 lety (2003)
Stabilní uvolnění
1.2.507.0[1] / 6. srpna 2016; Před 4 lety (2016-08-06)
Psací disciplínaOdvozeno, nominální, statický, silný
PlošinaCLI
Přípony názvu souboru.n
webová stránkanemerle.org
Hlavní, důležitý implementace
Nemerle
Ovlivněno
C#, Lisp, ML

Nemerle je univerzální, vysoká úroveň, staticky napsané programovací jazyk určené pro platformy využívající Společná jazyková infrastruktura (.SÍŤ /Mono ). To nabízí funkční, objektově orientovaný a rozkazovací způsob funkce. Má to jednoduché C# -jako syntaxe a silný metaprogramování Systém. V červnu 2012 byli hlavní vývojáři společnosti Nemerle najati čeština software developerská společnost JetBrains. Tým se zaměřuje na vývoj Nitry, rámce pro implementaci existujících a nových programovacích jazyků. Tento rámec bude pravděpodobně použit k vytvoření budoucích verzí Nemerle.[2][3][4]

Nemerle je pojmenována po Archmage Nemmerle, postavě ve fantasy románu Čaroděj ze Země podle Ursula K. Le Guin.

Funkce

Nejpozoruhodnější vlastností Nemerle je schopnost kombinovat styly programování, které jsou objektově orientovaný a funkční. Programy mohou být strukturovány pomocí objektově orientovaných konceptů, jako jsou třídy a jmenné prostory, zatímco metody lze (volitelně) psát ve funkčním stylu. Mezi další pozoruhodné funkce patří:

Systém metaprogramování umožňuje skvělé překladač rozšiřitelnost, vkládání jazyky specifické pro doménu, dílčí hodnocení, a aspektově orientované programování, přičemž vysoká úroveň přístup, jak co nejvíce zvednout břemeno od programátorů. Jazyk kombinuje vše Společná jazyková infrastruktura (CLI) standardní funkce, včetně parametrický polymorfismus, lambdy, metody rozšíření atd. Přístup ke knihovnám obsaženým v platformách .NET nebo Mono je stejně snadný jako v C #.

Odvození typu

def X = 1;           // intdef můj seznam = Seznam(); // obecný seznam [T], typ T je odvozen z použití v dalším řádkumůj seznam.Přidat(X);       // kompilátor odvodí typ T jako int při vytváření typu myList ze seznamu [int]

Všechno je výraz

def X =  { // podobně jako x = 3    def y = 1;    def z = 2;    y + z   // tento poslední příkaz je návratová hodnota bloku  };def X =  -li (Čas schůzky.Nyní.Den v týdnu == Den v týdnu.pondělí)  // pokud, using, try jsou také výrazy    "Pondělí"  jiný    "jiný den";def X = Snaž se int.Analyzovat(someString)        chytit { | FormatException() => 0 };def X = returnBlock :   {    pro každého (i v [1, 2, 3])      když (i > 2)        returnBlock(skutečný); // výstupní blok (x = true)    Nepravdivé // x = false  };

N-tice

def k = (1, "jeden"); // k: (int * řetězec)def (A, b) = k; // a = 1, b = "jeden"

Shoda vzoru

def výsledek = zápas (číslo){  | 0            => "nula"  | 1            => "jeden"  | X když X < 0 => "negativní"  | _            => "víc než jeden"}
Další příklady shody vzorů

Shoda typu s variabilní vazbou:

def šek (Ó : objekt) {  zápas (Ó)   {    | i je int    => $ "Int: $ i"    | s je tětiva => $ "Řetězec: $(s.Tsvrchní())"    | _           => "Objekt jiného typu"  }}

Párování vzorů n-tice:

zápas (n-tice) {  | ( 42, _ ) => „42 na první pozici“  | ( _, 42 ) => „42 na druhé pozici“  | ( X, y )  => $"( $ x, $ r )"}

Regexp shoda:

použitím Nemerle.Text;regulární výraz zápas (str) {  | „a +. *“                          => printf(„a  n“);  | @ "(?   d +) -  w +"        => printf("% d  n", počet + 3);  | "(?  (Ala | Kasia))? ma kota" =>     zápas (název)      {       | Nějaký (n) => printf("% s  n", n)       | Žádný     => printf("noname?  n")     }  | _                               => printf("výchozí  n");}

Funkční typy a místní funkce

použitím Systém.Řídicí panel; // třídy a moduly (statické třídy) lze umístit do jmenných prostorůdef další(X) { X + 1 }; // typ argumentu x a další argumenty funkce lze odvodit z použitídef mult(X, y) { X * y };def fibonacci(i){  | 0     => 0  | 1     => 1  | jiný => fibonacci(i - 1) + fibonacci(i - 2)};WriteLine(další(9));        // 10 podobně jako „Console.WriteLine (next (9));“ WriteLine(mult(2, 2));     // 4WriteLine(fibonacci(10)); // 55

Varianty

Varianty (nazývané datové typy nebo typy součtů v SML a OCaml) jsou formy vyjádření dat několika různých druhů:

 varianta RgbColor {   | Červené   | Žlutá   | Zelená   | Odlišný {       Červené : plovák;       zelená : plovák;       modrý : plovák;     } }

Metaprogramování

Makerový systém společnosti Nemerle umožňuje vytvářet, analyzovat a upravovat programový kód během kompilace. Makra lze použít ve formě volání metody nebo jako nový jazykový konstrukt. Mnoho konstrukcí v rámci jazyka je implementováno pomocí maker (if, for, foreach, while, using etc.).

"-li"příklad makra:

makro @li (kond, e1, e2)syntax ("li", "(", kond, ")", e1, Volitelný (";"), "jiný", e2){  /*    <[]> definuje oblast kvazi-citace, kompilátor Nemerle v ní transformuje kód     na AST, takové transformace jsou poněkud podobné Expression kompilaci v C #  */  <[    zápas ($ kond : bool)    {      | skutečný => $ e1      | _ => $ e2    }  ]>}// použití tohoto makra v kódu:def max = -li (A > b) A jiný b;// během kompilace bude horní řádek transformován na toto:def max = zápas (A > b){  | skutečný => A  | _    => b}

IDE

Nemerle lze integrovat do integrované vývojové prostředí (IDE) Visual Studio 2008. Má také zcela zdarma IDE založené na prostředí Visual Studio 2008 Shell[5] (jako Edice Visual Studio Express ) a SharpDevelop (odkaz na zdrojový kód pluginu ).

Nemerle lze také integrovat do Visual Studio 2010 pomocí doplňku.[6]

Příklady

Ahoj světe!

Tradiční Ahoj světe! lze implementovat způsobem podobnějším C #:

třída Ahoj{  statický Hlavní () : prázdnota  {    Systém.Řídicí panel.WriteLine ("Ahoj světe!");  }}

nebo jednodušeji:

Systém.Řídicí panel.WriteLine("Ahoj světe!");

Příklady maker

Makra umožňují generování standardní kód s přidanými statickými kontrolami prováděnými kompilátorem. Snižují množství kódu, který musí být psán ručně, zvyšují bezpečnost generování kódu a umožňují programům generovat kód s kontrolami kompilátoru, zatímco zdrojový kód je relativně malý a čitelný.

Formátování řetězce

Makro pro formátování řetězců zjednodušuje proměnné na manipulaci s řetězci pomocí $ notace:

def s = $ "Číslo je $ i"; // vložte hodnotu proměnné i, kde je $ i umístěn def s = $"$ x + $ r = $(X+y)"; // $ (...) lze použít k výpočtům nebo přístupu ke členům

Deklarativní generování kódu

Strukturální rovnost, Zapamatovat si, JSON, a s jsou makra, která generují kód v době kompilace. Ačkoli někteří z nich (Strukturální rovnost, Zapamatovat si) mohou vypadat jako atributy C #, během kompilace budou prozkoumány kompilátorem a transformovány do příslušného kódu pomocí logiky předdefinované jejich makry.

[StructuralEquality] // Implementace IEquatable [Ukázka] .Net rozhraní pomocí rovnosti porovnání prvků.třída Vzorek{   [Memoize]  // zapamatuje si první výsledek hodnocení    veřejnost statický Některá dlouhá hodnocení() : int     {       MathLib.CalculateNthPrime(10000000)   }   [DependencyProperty] // Vlastnost závislosti WPF   veřejnost DependencyPropertySample { dostat; soubor; }      veřejnost statický Hlavní() : prázdnota   {/ * syntaxe makra "json" generuje kód: JObject.Object ([("a", JValue.Number (SomeLongEvaluations ())), ("b", JValue.Number (SomeLongEvaluations () + 1))])*/       def jObject = JSON { A: Některá dlouhá hodnocení(); b: (Některá dlouhá hodnocení() + 1)} // makro inicializace objektu "<-" je vývoj inicializace objektu složených závorek C #       def k = Diagnostika.Proces() <-        {          StartInfo <- // může inicializovat vlastnosti vnitřních objektů bez volání ctor          {              Název souboru = "calc.exe";              UseShellExecute = skutečný;          }             Natěšený += () => WriteLine(„Calc done“); // události a delegáti       }       ReadLine();   }}

Přístupnost databáze

Používání maker Nemerle pro SQL můžeš psát:

ExecuteReaderLoop(„VYBRAT křestní jméno, příjmení FROM zaměstnance WHERE křestní jméno = $ myparm“, dbcon,  {    WriteLine ($ "Jméno: $ křestní jméno$ příjmení")  });

namísto

tětiva sql = "VYBRAT křestní jméno, příjmení FROM zaměstnance WHERE křestní jméno =: a";použitím (NpgsqlCommand dbcmd = Nový NpgsqlCommand (sql, dbcon, dbtran)){  dbcmd.Parametry.Přidat("A", myparm);  použitím (NpgsqlReader čtenář = dbcmd.ExecuteReader())  {     zatímco(čtenář.Číst())      {        var jméno = čtenář.GetString (0);        var příjmení = čtenář.GetString (1);        Řídicí panel.WriteLine („Název: {0} {1}“, jméno, příjmení)     }  }}

a to není jen skrytí některých operací v knihovně, ale další práce prováděná kompilátorem pro pochopení řetězce dotazu, tam použitých proměnných a sloupců vrácených z databáze. Makro ExecuteReaderLoop vygeneruje kód zhruba ekvivalentní tomu, co byste museli zadat ručně. Kromě toho se připojuje k databázi v době kompilace, aby zkontroloval, zda váš dotaz SQL opravdu dává smysl.

Nové jazykové konstrukce

S makry Nemerle můžete také do jazyka zavést novou syntaxi:

makro ReverseFor (i, start, body)syntax ("ford", "(", i, ";", start, ")", tělo) {<[pro ($ i = $ begin; $ i> = 0; $ i--) $ tělo]>}

definuje makro představující ford (EXPR; EXPR) EXPR syntaxe a lze je použít jako

brod (i; n) tisk (i);

Nemerle s ASP.NET

Nemerle lze buď zabudovat přímo do ASP.NET:

<%@ Strana Jazyk="Nemerle" %> runat ="server">    Page_Load(_ : objekt, _ : EventArgs) : prázdnota {        Zpráva.Text = $„Tuto stránku jste naposledy navštívili v: $ (DateTime.Now)“;    }    EnterBtn_Click(_ : objekt, _ : EventArgs) : prázdnota {        Zpráva.Text = $„Ahoj $ (Name.Text), vítejte na ASP.NET!“;    }</script><html>    <body>         runat ="server">            Zadejte své jméno:  ID ="Název" runat ="server" />             OnClick =„EnterBtn_Click“ Text =„Enter“ runat ="server" />            
  ID ="Zpráva" runat ="server" />
        </form>    </body></html>

... Nebo uloženy v samostatném souboru a zadány jediným řádkem:

<%@ Strana Jazyk="Nemerle" Src="test.n" Dědí="Test" %>

PInvoke

Nemerle může využívat výhod knihoven nativní platformy. Syntaxe je velmi podobná C # a dalším jazykům .NET. Zde je nejjednodušší příklad:

použitím Systém;použitím System.Runtime.InteropServices;třída PlatformInvokeTest{    [DllImport ("msvcrt.dll")]    veřejnost externí statický uvádí(C : tětiva) : int;    [DllImport ("msvcrt.dll")]    vnitřní externí statický _flushall() : int;    veřejnost statický Hlavní() : prázdnota    {        _ = uvádí("Test");        _ = _flushall();    }}

Reference

  1. ^ Nemerle 1.2.507.0
  2. ^ „Twitter / orangy: Rozhodli jsme se přivést Nemerleho“. Twitter.com. Citováno 2013-09-05.
  3. ^ "Blog nástrojů JetBrains .NET» JetBrains a Nemerle ". Blogs.jetbrains.com. 27. 06. 2012. Citováno 2013-09-05.
  4. ^ „Google Discussiegroepen“. Groups.google.com. Citováno 2013-09-05.
  5. ^ Instalační program Microsoft Setup Nemerle Studio lze nainstalovat po instalaci Visual Studio Shell 2008 izolovaný
  6. ^ Doplněk Visual Studio 2010

Další čtení

externí odkazy