NIM (Programmiersprache)

Nim
Nim-logo.png
Das NIM Crown -Logo
Paradigmen Multi-Paradigma: zusammengestellt, gleichzeitig, prozedural, Imperativ, funktional, objektorientierter, Meta
Entworfen von Andreas Rumpf
Entwickler Nim Lang Team[1]
Erstmals erschienen 2008; Vor 14 Jahren
Stabile Version
1.6.6[2] Edit this on Wikidata / 5. Mai 2022; Vor 2 Monaten
Disziplin tippen Statisch,[3] stark,[4] gefolgert, strukturell
Zielfernrohr Lexikalisch
Implementierungssprache Nim (selbst gehostet)
Plattform IA-32, x86-64, ARM, Aarch64, Risc-v, Powerpc ...[5]
OS Plattformübergreifend[6]
Lizenz MIT[7][8]
Dateiname -Erweiterungen .nim, .nims, .nimble
Webseite nim-lang.org
Beeinflusst von
Ada, Modula-3, Lispeln, C ++, Objekt Pascal, Python, Oberon, Rost

Nim ist ein allgemeiner Zweck, Multi-Paradigma, statisch typisiert, zusammengestellt Systemprogrammiersprache,[9] Entworfen und entwickelt von einem Team um Andreas Rumpf. NIM ist so konzipiert, dass "effizient, ausdrucksstark und elegant" ist.[10] Unterstützung Metaprogrammierung, funktional, Nachrichtenübergang,[7] prozedural, und Objekt orientierte Programmierung Stile durch Bereitstellung mehrerer Funktionen wie z. Zeit kompilieren Codegenerierung, Algebraische Datentypen, a Fremdenfunktionsschnittstelle (Ffi) mit C, C ++, Ziel c, und JavaScript, und Unterstützung der Kompilierung derselben Sprachen.

Beschreibung

Nim wurde geschaffen, um eine Sprache so schnell wie c zu sein, so ausdrucksstark wie Python, und so erweiterbar wie Lispeln.

Nim wird statisch getippt.[11] Es unterstützt die Kompilierungszeit Metaprogrammierung Funktionen wie syntaktische Makros und Begriff Umschreiben Makros.[12] Term Rewriting Makros aktivieren Bibliothek Implementierungen gemeinsamer Datenstrukturen wie Bignums und Matrizen, die effizient implementiert werden sollen, als wären sie eingebaute Spracheinrichtungen.[13] Iteratoren werden unterstützt und können als erstklassige Einheiten verwendet werden,[12] wie können Funktionen ermöglichen, die Verwendung von zu ermöglichen Funktionelle Programmierung Methoden. Objektorientierte Programmierung wird durch unterstützt Nachlass und Mehrfachversand. Funktionen können allgemein sein, sie können überladen werden und Generika werden durch die Unterstützung von NIM für Typklassen weiter verbessert. Bedienerüberlastung wird auch unterstützt.[12] NIM enthält einstellbare Automatik Müllsammlung basierend auf aufgeschoben Referenzzählung mit Zykluserkennung, die auch vollständig ausgeschaltet werden können.[14]

[Nim] ... präsentiert ein äußerst originelles Design, das sich übergreift Pascal und Python und kompiliert C -Code oder JavaScript.[15]

-Andrew Binstock, Chefredakteur von Dr. Dobbs Journal, 2014

Ab Oktober 2021, Nim kompiliert C, C ++, JavaScript und Objective-C.[16]

Geschichte

Zweig Ausführung Veröffentlichungsdatum[17]
0.x Alte Version, nicht mehr gepflegt: 0,10.2 2014-12-29
Alte Version, nicht mehr gepflegt: 0.11.2 2015-05-04
Alte Version, nicht mehr gepflegt: 0,12.0 2015-10-27
Alte Version, nicht mehr gepflegt: 0,13.0 2016-01-18
Alte Version, nicht mehr gepflegt: 0,14,2 2016-06-09
Alte Version, nicht mehr gepflegt: 0,15,2 2016-10-23
Alte Version, nicht mehr gepflegt: 0,16,0 2017-01-08
Alte Version, nicht mehr gepflegt: 0,17,2 2017-09-07
Alte Version, nicht mehr gepflegt: 0,18,0 2018-03-01
Alte Version, nicht mehr gepflegt: 0,19,6 2019-05-13
Alte Version, nicht mehr gepflegt: 0,20,2 2019-06-17
1.0 Alte Version, nicht mehr gepflegt: 1.0.0 2019-09-23
Ältere Version, dennoch gepflegt: 1.0.10 2020-10-27
1.2 Alte Version, nicht mehr gepflegt: 1.2.0 2020-04-03
Ältere Version, dennoch gepflegt: 1.2.18 2022-02-09
1.4 Alte Version, nicht mehr gepflegt: 1.4.0 2020-10-16
Ältere Version, dennoch gepflegt: 1.4.8 2021-05-25
1.6 Alte Version, nicht mehr gepflegt: 1.6.0 2021-10-19
Aktuelle stabile Version: 1.6.6 2022-05-05
Legende:
Alte Version
Ältere Version, noch gepflegt
Letzte Version
Neueste Vorschau -Version
Zukünftige Veröffentlichung
Für jeden 0.x -Zweig ist nur die neueste Punktveröffentlichung aufgeführt.
Für spätere Zweige wird die erste und die neueste Point -Version aufgeführt.

Die erste Entwicklung von NIM wurde 2005 von Andreas Rumpf begonnen. Es wurde ursprünglich Nimrod benannt, als das Projekt 2008 veröffentlicht wurde.[18]: 4–11 Die erste Version des NIM Compiler wurde geschrieben Pascal Verwendung der Kostenloser Pascal Compiler.[19] Im Jahr 2008 wurde eine Version des in NIM geschriebenen Compilers veröffentlicht.[20] Der Compiler ist Kostenlose und Open-Source-Softwareund wird von einer Gemeinschaft von Freiwilligen entwickelt, die mit Andreas Rumpf zusammenarbeiten.[21] Die Sprache wurde offiziell umbenannt Nimrod zu Nim mit der Veröffentlichung von Version 0.10.2 im Dezember 2014.[22] Am 23. September 2019 wurde Version 1.0.0 von NIM veröffentlicht, was die Reifung der Sprache und ihrer Toolchain bedeutet.

Sprachdesign

Syntax

Die Syntax von nim ähnelt der von Python.[23] Codeblöcke und Nistanweisungen werden durch Verwendung von identifiziert Whitespace, laut dem Abseitsregel. Viele Schlüsselwörter sind identisch mit ihren Python -Äquivalenten, bei denen es sich hauptsächlich um englische Schlüsselwörter handelt, während andere Programmiersprachen normalerweise Interpunktion verwenden. Mit dem Ziel, seine Einflusssprachen zu verbessern, obwohl NIM unterstützt Vertiefung-Basierte Syntax wie Python, wurde zusätzliche Flexibilität eingeführt. Zum Beispiel eine Single Aussage kann mehrere Zeilen überspannen, wenn ein Komma oder Binärbetreiber ist am Ende jeder Zeile. Und NIM unterstützt benutzerdefinierte Operatoren.

Im Gegensatz zu Python implementiert NIM implementiert (native) statische Typisierung. Das Typs Typ von NIM ermöglicht eine einfache Konvertierung, Casting und bietet eine Syntax für die generische Programmierung. NIM BILDE BEISETBILDEN TYP -Klassen, die für mehrere Typen stehen können, und bietet mehrere solche Typklassen "außerhalb der Box". Typklassen ermöglichen es, mit mehreren Typen zu arbeiten, als ob sie ein einzelner Typ wären. Zum Beispiel:

  • Somesignedint - repräsentiert alle signierten Ganzzahltypen
  • Ein bisschen integer - repräsentiert alle ganzzahligen Typen, signiert oder nicht
  • Irgendwie - Repräsentiert alle grundlegenden zählbaren und geordneten Typen, mit Ausnahme der Nichtzahlnummer

Dieses Code -Beispiel zeigt die Verwendung von Typenklassen in NIM

# Lassen Sie uns eine Funktion deklarieren, die eine beliebige Art von Zahl nimmt und ihr Doppel anzeigt # In NIM -Funktionen mit Nebeneffekt werden "Proc" bezeichnet. Proc Timestwo(i: Somenumber) =   Echo i * 2   # Schreiben wir eine andere Funktion, die einen ordinalen Typ erfordert und zurückgibt # Das Doppel der Eingabe in seinem ursprünglichen Typ, wenn es sich um eine Zahl handelt; # oder gibt die Eingabe selbst zurück. # Wir verwenden einen generischen Typ (t) und genau, dass es nur ein Ordinal sein kann Func TOPY_IF_IS_NUMBER[T: Irgendwie](i: T): T =   Wenn T ist Somenumber: # A `WHERE IS EIN" IF`) während der Kompilierungszeit bewertet   Ergebnis = i * 2 # Sie können auch `return i * 2` schreiben   anders:   # Wenn der Ordinal keine Zahl ist, wird er in int umgewandelt,   # multipliziert mit zwei und konvertierte zu seinem basierten Typ   Ergebnis = (i.int * 2).T  Echo TOPY_IF_IS_NUMBER(67) # Übergibt eine INT an die Funktion Echo TOPY_IF_IS_NUMBER(67u8) # passt an uint8  Echo TOPY_IF_IS_NUMBER(Stimmt) # Passt an einem Bool (was auch ein Ordinal ist)

NIM ist fast vollständig stilvollerempfindlich; zwei Kennungen werden als gleich angesehen, wenn sie sich nur durch Kapitalisierung und Unterstrich unterscheiden, solange die ersten Zeichen identisch sind. Historisch gesehen war Nim voll und ganz Fall-unempfindlich (Die Kapitalisierung der Identifikatoren wurde vollständig ignoriert) und auch Unterstriche wurden vollständig ignoriert.[24]

Beeinflussen

NIM wurde von spezifischen Merkmalen vorhandener Sprachen beeinflusst, einschließlich der folgenden:

Einheitliche Funktionsaufrufsyntax

Nim unterstützt Einheitliche Funktionsaufrufsyntax (UFCS)[25] und die Gleichstellung der Identifikatorin, die ein großes Maß an Flexibilität bietet.

Beispielsweise macht jede dieser Zeilen den gleichen Aufruf, nur mit unterschiedlicher Syntax:

Echo "Hallo Welt" Echo("Hallo Welt") "Hallo Welt".Echo() "Hallo Welt".Echo "hallo".Echo(" Welt") "hallo".Echo " Welt"

Identifikatorgleichheit

Mit Ausnahme des ersten Briefes werden die Kennungen in NIM in unempfindlicher Weise verglichen, und Unterstriche werden ignoriert.

Beispiel:

Const Usehttps = Stimmt behaupten Usehttps == Usehttps behaupten Usehttps == Usehttps behaupten Use_https == Usehttps

Stropping

Das Stropping Die Funktion ermöglicht die Verwendung eines beliebigen Namens für Variablen oder Funktionen, auch wenn die Namen sind reservierte Wörter Für Schlüsselwörter. Ein Beispiel für Stropping ist die Fähigkeit, eine Variable benannt zu definieren wenn, ohne mit dem Keyword zu kämpfen wenn. Die Umsetzung von NIM wird über Backticks erreicht, sodass jedes reservierte Wort als Kennung verwendet werden kann.[26] 

Typ Typ = Objekt  `int`: int Lassen `Objekt` = Typ(`int`: 9) behaupten `Objekt` ist Typ behaupten `Objekt`.`int` == 9 var `var` = 42 Lassen `Lassen` = 8 behaupten `var` + `Lassen` == 50 Const `behaupten` = Stimmt behaupten `behaupten`

Compiler

Der NIM -Compiler emittiert schnell, optimiert C standardmäßig Code. Es vertieft das Kompilieren von Compiles-to-Object-Code an einen externen C-Compiler[27] Nutzung der bestehenden Compiler -Optimierung und -Regabilität. Viele C -Compiler werden unterstützt, einschließlich Klang, Microsoft Visual C ++ (MSVC), Mingw, und GNU Compiler -Sammlung (GCC). Der NIM -Compiler kann auch emittieren C ++, Ziel c, und JavaScript Code, um eine einfache Schnittstelle mit Anwendungsprogrammierschnittstellen zu ermöglichen (Interfaces für Anwendungen (Apis) in diesen Sprachen geschrieben;[9] Entwickler können einfach in NIM schreiben und dann zu jeder unterstützten Sprache kompilieren. Dies ermöglicht auch das Schreiben von Anwendungen für iOS und Android. Es gibt auch eine inoffizielle Llvm Backend, so die Verwendung des NIM-Compilers auf eigenständige Weise.[28]

Der NIM -Compiler ist Selbsthosting, was bedeutet, dass es in der NIM -Sprache geschrieben ist.[29] Der Compiler unterstützt das Cross-Compiling, sodass er Software für eines der unterstützten Betriebssysteme zusammenstellen kann, unabhängig von der Entwicklungsmaschine. Dies ist nützlich, um Anwendungen für eingebettete Systeme sowie für ungewöhnliche und obskure Computerarchitekturen zu erstellen.

Compiler -Optionen

Standardmäßig erstellt der NIM -Compiler a debuggen bauen.[30] Mit der Option -D: Veröffentlichung a Veröffentlichung Build kann erstellt werden, was für Geschwindigkeit optimiert ist und weniger Laufzeitüberprüfungen enthält.[30] Mit der Option -D: Gefahr Alle Laufzeitprüfungen können deaktiviert werden, wenn die maximale Geschwindigkeit gewünscht wird.[30]

Speicherverwaltung

NIM unterstützt mehrere Speicherverwaltungsstrategien, einschließlich der folgenden:[31]

  • --gc: Refc - Dies ist der Standard -GC. Es ist ein aufgeschobener Referenzzählung basierend Müllsammler Mit einem einfachen Mark & ​​Sweep -Backup GC, um Zyklen zu sammeln. Haufen sind thread-lokal.
  • -GC: Markandsweep -Einfacher Mark-and-Sweep-Basis Müllsammler. Haufen sind thread-lokal.
  • --gc: Boehm - Boehmbasiert MüllsammlerEs bietet einen gemeinsamen Haufen.
  • --gc: Geh – gehen's Müllsammlernützlich für die Interoperabilität mit gehen. Bietet einen gemeinsamen Haufen.
  • -GC: Bogen - Schmucklos Referenzzählung Mit Semantic -Optimierungen mit Bewegung bietet ein gemeinsamer Haufen. Es bietet eine deterministische Leistung für harte Echtzeitsysteme. Referenzzyklen verursachen Speicherlecks, achten Sie auf.
  • --gc: Orc - Gleich wie -GC: Bogen Fügt jedoch einen Zyklussammler basierend auf "Versuchsdeletion" hinzu. Leider macht es sein Leistungsprofil schwierig zu argumentieren, damit es für harte Echtzeitsysteme weniger nützlich ist.
  • -GC: Keine - keine Strategie zur Speicherverwaltung oder a Müllsammler. Das zugewiesene Gedächtnis wird einfach nie befreit, es sei denn, manuell von dem Code des Entwicklers befreit.

Entwicklungswerkzeuge

Gebündelt

Viele Werkzeuge werden mit dem NIM -Installpaket gebündelt, einschließlich:

Flink

Flink ist der Standard Paket-Manager Wird von NIM zum Verpacken von NIM -Modulen verwendet.[32] Es wurde zunächst von Dominik Picheta entwickelt, der auch ein zentraler NIM -Entwickler ist. Nimble wurde seit dem 27. Oktober 2015 als NIM -offizieller Paketmanager, der Version V0.12.0, aufgenommen.[33]

Flinke Pakete werden durch definiert von .flink Dateien, die Informationen über die Paketversion, Autor, Lizenz, Beschreibung, Abhängigkeiten und mehr enthalten.[18]: 132 Diese Dateien unterstützen eine begrenzte Teilmenge der NIM -Syntax namens Nimscript, wobei die Hauptbeschränkung der Zugriff auf den FFI ist. Diese Skripte ermöglichen die Änderung der Testprozeduren oder für benutzerdefinierte Aufgaben.

Die Liste der Pakete wird in einer JavaScript -Objektnotation gespeichert (JSON) Datei, auf die im NIM-Lang/Paket-Repository auf GitHub frei zugegriffen werden kann. Diese JSON -Datei bietet flink mit einer Zuordnung zwischen den Namen von Paketen und ihren Git- oder Mercurial -Repository -URLs.

Nimble kommt mit dem NIM -Compiler. Daher ist es möglich, die flinke Umgebung durch Laufen zu testen:flink -v. Dieser Befehl enthält die Versionsnummer, das Kompilieren von Datum und Uhrzeit und Git Hash von Flink. Nimble verwendet das Git -Paket, das für Flink verfügbar sein muss, um ordnungsgemäß zu funktionieren. Die NIMBLE-Befehlszeile wird als Schnittstelle zum Installieren, Entfernen (Deinstallieren) und Upgrade-Spatching-Modulpaketen verwendet.[18]: 130–131

C2nim

C2nim ist a Source-to-Source-Compiler (Transkompiler oder Transpiler), das verwendet werden soll C/C ++ Header, um neue NIM -Bindungen zu generieren.[34] Der Ausgang ist der menschlich-lesbare NIM-Code, der nach dem Übersetzungsprozess von Hand bearbeitet werden soll.

Koch

Koch ist ein Wartungsskript, mit dem NIM erstellt und HTML -Dokumentation bereitgestellt wird.[35]

Nimgrep

NimGrep ist ein generisches Werkzeug zum Manipulieren von Text. Es wird verwendet, um nach Regex, PEG -Mustern und Inhalten von Verzeichnissen zu suchen, und es kann zum Ersetzen von Aufgaben verwendet werden. Es ist enthalten, um bei der Suche nach NIMs stilunempfindlichen Kennungen zu helfen.[36]

Nimsugst

Nimsugest ist ein Tool, das jedem Quellcode -Editor hilft, abzufragen a .nim Quelldatei, um nützliche Informationen wie die Definition von Symbolen oder Vorschlägen für den Abschluss zu erhalten.[37]

niminst

Niminst ist ein Tool, um ein Installateur für ein NIM -Programm zu generieren.[38] Es erstellt .msi -Installateure für Windows über Inno Setup und installiert und deinstallieren Skripte für Linux, Mac OS, und Berkeley Software Distribution (BSD).

Nimpretty

Nimpretty ist ein Quellcode -Verschönerer, der zum Formatcode gemäß dem offiziellen NIM -Style -Handbuch verwendet wird.[39]

Testament

Testament ist ein fortschrittlicher automatischer, unittestes Läufer für NIM -Tests. Es wird bei der Entwicklung von NIM verwendet und bietet Prozessisolierungstests, generiert Statistiken zu Testfällen, unterstützt mehrere Ziele und simulierte Trockenruns, hat Protokollierung, kann HTML-Berichte erstellen, können Tests aus einer Datei überspringen und mehr.

Andere bemerkenswerte Werkzeuge

Einige bemerkenswerte Tools, die nicht im NIM -Paket enthalten sind, umfassen:

ausgewähnen

ausgewähnen wurde von Dominik Picheta, Schöpfer des Nimble Paket Manager, als Tool zur Installation und Verwendung mehrerer Versionen des NIM -Compilers entwickelt. Es lädt jede NIM -Stall- oder Entwicklungs -Compiler -Version aus der Befehlszeile herunter und ermöglicht das einfache Umschalten zwischen ihnen.[40]

nimpy

nimpy ist eine Bibliothek, die eine bequeme Python -Integration in NIM -Programme ermöglicht.[41]

Nimterop

Nimterop ist ein Tool, das sich auf die Automatisierung der Erstellung von C/C ++ - Wrappern konzentriert, die für die NIM -Fremdenfunktionsschnittstelle benötigt werden.[42]

Bibliotheken

Reine/unreine Bibliotheken

Reine Bibliotheken sind nur in NIM geschriebene Module. Dazu gehören keine Wrapper, um auf Bibliotheken zuzugreifen, die in anderen Programmiersprachen geschrieben wurden.

Unreine Bibliotheken sind Module von NIM -Code, die von externen Bibliotheken abhängen, die in anderen Programmiersprachen wie C geschrieben sind, wie C.

Standardbibliothek

Die NIM -Standardbibliothek enthält Module für alle grundlegenden Aufgaben, darunter:[43]

  • System- und Kernmodule
  • Sammlungen und Algorithmen
  • Saitenhandhabung
  • Zeithandhabung
  • Generische Betriebssystemdienste
  • Mathematikbibliotheken
  • Internetprotokolle und Unterstützung
  • Fäden
  • Parser
  • Dokumente
  • XML -Verarbeitung
  • XML- und HTML -Codegenerator
  • Hashing
  • Datenbankunterstützung (Postgresql, MySQL und SQLite)
  • Wrapper (Win32 API, POSIX)

Verwendung anderer Bibliotheken

Ein NIM -Programm kann jeden verwenden Bibliothek die in einem C-, C ++ - oder JavaScript -Programm verwendet werden können. Sprachbindungen existieren für viele Bibliotheken, einschließlich Gtk,[44][45] Qt QML,[46] wxWidgets,[47] Einfache Regieschicht (SDL) 2,[48][49] Kairo,[50] OpenGL,[51] Windows -API (Winapi),[52] Zlib, libzip, OpenSSL, Vulkan[53] und Locken.[54] Nim arbeitet mit PostgreSQL, Mysql, und Sqlite Datenbanken. Nim kann mit dem schnitteln Lua,[55] Julia,[56] Rost,[57] C#,[58] Typoskript,[59] und Python[60] Programmiersprachen.

Beispiele

Hallo Welt

Das "Hallo Welt!" Programm in nim:

Echo("Hallo Welt!") # Verfahren können ohne Klammern aufgerufen werden Echo "Hallo Welt!"

Eine andere Version von "Hallo Welt" ist ...

Stdout.schreiben("Hallo Welt!\n")

Fakultät

Programm, um die zu berechnen Fakultät einer positiven Ganzzahl unter Verwendung des iterativen Ansatzes:

importieren Strudel var n = 0 Versuchen:  Stdout.schreiben "Eingabe positive Ganzzahl -Zahl:"  n = Stdin.Zeile lesen.analysieren außer ValueError:  heben NewException(ValueError, "Sie müssen eine positive Zahl eingeben") var Tatsache = 1 zum i in 2..n:  Tatsache = Tatsache * i Echo Tatsache

Verwenden der Modulmathematik aus der Standardbibliothek von NIM:

importieren Mathematik Echo FAC(x)

Eine Zeichenfolge umkehren

Eine einfache Demonstration, die viele von NIMs Merkmalen zeigt.

Proc umkehren(s: Saite): Saite =  zum i in Countdown(s.hoch, 0):  Ergebnis.hinzufügen s[i] Lassen STR1 = "Umgekehrt!" Echo "Umgedreht: ", umkehren(STR1)

Eines der exotischeren Merkmale ist implizit Ergebnis Variable. Jedes Verfahren in NIM mit einem Nicht-Void-Rückgabetyp hat eine implizite Ergebnisvariable, die den zu zurückgegebenen Wert darstellt. In der für Schleife sehen wir einen Aufruf von Countdown Welches ist ein Iterator. Wenn ein Iterator weggelassen wird, versucht der Compiler, eine zu verwenden Artikel Iterator, wenn man für den angegebenen Typ definiert ist.

Grafische Benutzeroberfläche

Verwendung Gtk3 mit gobjektbeobachtung durch die GinTro Modul:

importieren GinTro/[gtk, Glib, Gobject, Gio] Proc AppActivate(App: Anwendung) =  Lassen Fenster = New ApplicationWindow(App)  Fenster.Titel = "GTK3 -Anwendung mit Gobject Introspection"  Fenster.Standard Größe = (400, 400)  zeige alles(Fenster) Proc hauptsächlich =  Lassen App = neue Bewerbung("org.gtk.example")  verbinden(App, "aktivieren Sie", AppActivate)  verwerfen Lauf(App) hauptsächlich()

Dieser Code erfordert, dass das GinTro -Modul funktioniert, das nicht Teil der Standardbibliothek ist. Um das Modul Gintro und viele andere zu installieren, können Sie das Werkzeug Nimble verwenden, das als Teil von NIM kommt. So installieren Sie das Gintro -Modul mit flink. Sie machen Folgendes:

Gintro installieren

Programmierparadigmen

Funktionelle Programmierung

Funktionelle Programmierung wird in nim durch unterstützt erstklassige Funktionen und Code ohne Nebenwirkungen Über das "Nosideffect" Pragma, das Schlüsselwort "func",[61] und das experimentelle Merkmal "strictfuncs".

Mit der aktiven Funktion "strictfuncs" wird NIM durchführen Nebeneffekt Analyse- und Erhöhung von Kompilierungsfehlern für Code, die dem Vertrag der NO -Erzeugung nicht befolgen Nebenwirkungen.

Im Gegensatz zu rein Funktionelle Programmierung Sprachen, nim ist a Multi-Paradigma Programmiersprache so Funktionelle Programmierung Einschränkungen werden auf funktionsfähiger Basis abgelehnt.

First Class -Funktionen

Nim unterstützt erstklassige Funktionen Durch die Speicherung von Funktionen in Variablen oder als Parameter übergeben werden, die von anderen Funktionen aufgerufen werden sollen.

Zum Beispiel:

importieren Sequtils Lassen PowerSoftwo = @[1, 2, 4, 8, 16, 32, 64, 128, 256] Echo(PowerSoftwo.Filter tun (x: int) -> bool: x > 32) Echo PowerSoftwo.Filter(Proc (x: int): bool = x > 32) Proc Greaterthan32(x: int): bool = x > 32 Echo PowerSoftwo.Filter(Greaterthan32)

Erzeugt die Ausgabe:

@[64, 128, 256] @[64, 128, 256] @[64, 128, 256]

[62]

Funktionen

Das Func Schlüsselwort führt eine Abkürzung für a vor Nosideffekt Pragma.

Func binäre Suche[T](a: OpenArray[T]; Elem: T): int

Ist kurz für:

Proc binäre Suche[T](a: OpenArray[T]; Elem: T): int {.Nosideffekt.}

[63]

Strenge Funcs

Seit Version 1.4 ist eine strengere Definition eines "Nebeneffekts" verfügbar. Zusätzlich zu der vorhandenen Regel, dass ein Nebeneffekt eine Funktion mit Nebenwirkungen aufruft, wird auch die folgende Regel durchgesetzt:

Jede Mutation an ein Objekt zählt als Nebeneffekt, wenn dieses Objekt über einen Parameter erreichbar ist, der nicht als a deklariert wird var Parameter.

Zum Beispiel:

{.Experimental-: "Strictfuncs".} Typ  Knoten = Ref Objekt  Le, Ri: Knoten  Daten: Saite Func Len(n: Knoten): int =  # Gültig: Len hat keine Nebenwirkungen  var es = n  während es ! = Null:  Inc. Ergebnis  es = es.Ri Func Mut(n: Knoten) =  Lassen m = n # ist die Anweisung, die die Mutation mit dem Parameter verbunden hat  m.Daten = "ja" # Die Mutation ist hier  # Fehler: 'Mut' kann Nebenwirkungen haben  # Ein von 'n' erreichbares Objekt ist potenziell mutiert

[64]

Objektorientierte Programmierung (OOP)

Metaprogrammierung

Schablone

Dies ist ein Beispiel für die Metaprogrammierung in NIM unter Verwendung seiner Vorlageneinrichtungen.

Schablone Gentype(Name, Feldname: ungetarn, Feldtyp: Typedesc) =  Typ  Name = Objekt  Feldname: Feldtyp Gentype(Prüfen, Foo, int) var x = Prüfen(Foo: 4566) Echo(x.Foo) # 4566

Das Gentype wird bei Compiles-Time und a angerufen Prüfen Typ wird erstellt.

Generisch

NIM unterstützt sowohl eingeschränkte als auch nicht eingeschränkte generische Programme. Generika können in Verfahren, Vorlagen und Makros verwendet werden. Sie werden nach dem Namen des Proc in quadratischen Klammern definiert, wie unten zu sehen.

Proc Addthese[T](a, b: T): T =  a + b Echo Addthese(1, 2) # 3 (von int type) Echo Addthese(uint8 1, uint8 2) # 3 (von Uint8)

Im Addthese, T ist der generische Typ, der Compiler akzeptiert alle Werte für diese Funktion, solange beide Parameter und der Rückgabewert vom gleichen Typ sind.

Man kann weiter klären, welche Typen die Prozedur durch Angabe einer Typklasse akzeptiert.[65]

Proc AddtheSenumbers[T: Somenumber](a, b: T): T =  a + b

AddtheSenumbersfunktioniert dann nur für Typen, die in der enthalten sind SomenumberSumentyp.

Makros

Makros können Teile des Codes zur Kompilierungszeit neu schreiben. NIM -Makros sind leistungsstark und können viele Operationen auf dem abstrakten Syntaxbaum ausführen.

Hier ist ein einfaches Beispiel, das ein Makro erstellt, das zweimal aufgerufen wird:

importieren Makros Makro zweimal(arg: ungetarn): ungetarn =  Ergebnis = zitieren tun:  `arg`  `arg` zweimal Echo "Hallo Welt!"

Das zweimal Makro in diesem Beispiel nimmt die Echo -Anweisung in Form eines abstrakten Syntaxbaums als Eingabe auf. In diesem Beispiel haben wir uns entschlossen, diesen Syntaxbaum zurückzugeben, ohne dass Manipulationen darauf angewendet wurden. Aber wir machen es zweimal, daher der Name des Makros. Das Ergebnis ist, dass der Code vom Makro umgeschrieben wird, um wie der folgende Code zum Kompilierzeit auszusehen:

Echo "Hallo Welt!" Echo "Hallo Welt!"

Fremdenfunktion Schnittstelle (FFI)

Der FFI von NIM wird verwendet, um Funktionen aufzurufen, die in den anderen Programmiersprachen geschrieben wurden, zu denen es kompiliert werden kann. Dies bedeutet, dass Bibliotheken, die in C, C ++, Objective-C und JavaScript geschrieben wurden, im NIM-Quellcode verwendet werden können. Man sollte sich bewusst sein, dass sowohl JavaScript- als auch C-, C ++-oder Objective-C-Bibliotheken nicht im selben Programm kombiniert werden können, da sie nicht so kompatibel mit JavaScript sind wie miteinander. Sowohl C ++ als auch Objective-C basieren auf C und kompatibel mit C, aber JavaScript ist inkompatibel als dynamische, clientseitige webbasierte Sprache.[18]: 226

Das folgende Programm zeigt die Leichtigkeit, mit der externer C -Code direkt in NIM verwendet werden kann.

Proc printf(Formatstr: cstring) {.Header: "<Stdio.h>", Varargs.} printf(" %s %d\n", "Foo", 5)

In diesem Code die printf Die Funktion wird in NIM importiert und dann verwendet.

Grundes Basisbeispiel mit 'console.log' direkt für die JavaScript Kompilierungsziel:

Proc Protokoll(Args: irgendein) {.Importjs: "console.log (@)", Varargs.} Protokoll(42, "Z", Stimmt, 3.14)

Der vom NIM -Compiler erstellte JavaScript -Code kann mit ausgeführt werden Node.js oder ein Webbrowser.

Parallelität

Um die Unterstützung der Threading in NIM zu aktivieren, sollte ein Programm kompiliert werden -Threads: on Befehlszeilenargument. Jeder Thread hat einen separaten Müll, der gehoben ist, und die Aufteilung des Speichers ist eingeschränkt, was bei der Effizienz hilft und die Rennbedingungen durch die Fäden stoppt.

importieren Schlösser var  TH.: Array[0..4, Faden[Tupel[a,b: int]]]  L: Sperren Proc Threadfunc(Intervall: Tupel[a,b: int]) {.Faden.} =  zum i in Intervall.a..Intervall.b:  erwerben(L) # Stdout sperren  Echo i  Veröffentlichung(L) initlock(L) zum i in 0..hoch(TH.):  Erstelle einen Thread(TH.[i], Threadfunc, (i*10, i*10+5)) JoinThreads(TH.)

Nim hat auch a Kanäle Modul, das das Übergeben von Daten zwischen Threads vereinfacht.

importieren OS Typ  Berechnung = Objekt  Ich würde*: int  Daten*: int  CalculationResult = Objekt  Ich würde*: int  Ergebnis*: int var task_queue: Kanal[Berechnung] var result_queue: Kanal[CalculationResult] Proc Workerfunc() {.Faden.} =  result_queue.offen()  während Stimmt:  var Aufgabe = task_queue.Recv()  result_queue.senden(CalculationResult(Ich würde: Aufgabe.Ich würde, Ergebnis: Aufgabe.Daten * 2)) var Arbeiterthread: Faden[Leere] Erstelle einen Thread(Arbeiterthread, Workerfunc) task_queue.offen() task_queue.senden(Berechnung(Ich würde: 1, Daten: 13)) task_queue.senden(Berechnung(Ich würde: 2, Daten: 37)) während Stimmt:  Echo "Erhielt Ergebnis:", reprieren(result_queue.Recv())

Parallelität

Nim unterstützt asynchrones IO über die Asyncdispatch Modul, das hinzufügt asynchron/wartet Syntax über das Makrosystem. Ein Beispiel für ein Asynchron http Server:

importieren Asynchttpserver, Asyncdispatch var Server = Newasynchttpserver() Proc CB(Req: Anfrage) {.Async.} =  erwarten Req.antworten(Http200, "Hallo Welt") warten auf Server.Dienen(Hafen(8080), CB)

Gemeinschaft

Nim hat eine aktive Gemeinschaft im selbst gehosteten, selbst entwickelten offiziellen Forum.[66] Darüber hinaus verwendet das Projekt ein Git -Repository, ein Bug -Tracker und ein Wiki, das von gehostet wird GitHub, wo sich die Gemeinschaft mit der Sprache befasst.[67]

Konventionen

Die erste NIM -Konferenz, Nimconf, fand am 20. Juni 2020 statt. Sie fand digital statt COVID-19, mit einem offenen Aufruf für Mitarbeitergespräche in Form von Youtube Videos.[68] Die Konferenz begann mit Sprachübersichten der NIM -Entwickler Andreas Rumpf und Dominik Picheta. Präsentationsthemen umfassten Gespräche über NIM -Web -Frameworks, Mobile Entwicklung, Internet der Dinge (IoT) Geräte und Spielentwicklung, einschließlich eines Gesprächs über das Schreiben von nim für Game Boy Advance.[69] Nimconf 2020 ist als YouTube -Wiedergabeliste erhältlich.[70]

Zusätzlich zu offiziellen Konferenzen wurde Nim auf verschiedenen anderen Konventionen vorgestellt. Eine Präsentation über NIM wurde am O'Reilly Open Source Convention (Oscon) im Jahr 2015.[71][72][73] Vier Redner vertraten NIM auf dem europäischen Treffen von Free- und Open -Source -Softwareentwicklern (European Developers (Fosdem) 2020, einschließlich des Schöpfers der Sprache, Andreas Rumpf.[74]

Siehe auch

Verweise

  1. ^ "Mitwirkende zu Nim-Lang/nim". Abgerufen 2022-03-23.
  2. ^ https://nim-lang.org/blog/2022/05/05/VERSION-166-relesed.html.
  3. ^ "Nim mit gutem Beispiel". GitHub. Abgerufen 2014-07-20.
  4. ^ Караджов, захари; Станиаров, борислав (2014). Метарораizin мане с nimrod. Varnaconf (Bulgarisch). Abgerufen 2014-07-27.
  5. ^ "Verpackung nim". Abgerufen 2022-03-23.
  6. ^ "NIM installieren". Abgerufen 2018-10-12.
  7. ^ a b "FAQ". nim-Lang.org. Abgerufen 2015-03-27.
  8. ^ "Copying.txt". GitHub. Abgerufen 2015-03-27.
  9. ^ a b Rumpf, Andreas (2014-02-11). "Nimrod: Eine neue Systemprogrammiersprache". Dr. Dobbs Journal. Abgerufen 2014-07-20.
  10. ^ "Die NIM -Programmiersprache". Nim-Lang.org. Abgerufen 2014-07-20.
  11. ^ Kehrer, Aaron (Akehrer) (2015-01-05). "NIM -Syntax". GitHub. Abgerufen 2015-01-05.
  12. ^ a b c "NIM -Handbuch". Nim-Lang.org. Abgerufen 2014-07-20.
  13. ^ "Strangeloop nim Präsentation". Archiviert von das Original 2014-07-13. Abgerufen 2015-04-30.
  14. ^ "Nims Müllsammler". Nim-Lang.org. Abgerufen 2018-01-10.
  15. ^ Binstock, Andrew (2014-01-07). "Der Aufstieg und Fall der Sprachen im Jahr 2013". Dr. Dobbs Journal. Abgerufen 2018-10-08.
  16. ^ NIM Compiler -Benutzerhandbuch
  17. ^ "Nim veröffentlicht". NIM -Projekt. Abgerufen 2020-01-26.
  18. ^ a b c d Picheta, Dominik (2017). Nim in Aktion. Manning Publikationen. ISBN 978-1617293436.
  19. ^ "NIM Pascal Quellen". GitHub. Abgerufen 2013-04-05.
  20. ^ "Nachrichten". Nim-Lang.org. Archiviert vom Original am 2016-06-26. Abgerufen 2016-06-11.
  21. ^ "Mitwirkende". GitHub. Abgerufen 2013-04-05.
  22. ^ Picheta, Dominik (2014-12-29). "Version 0.10.2 veröffentlicht". Nim-Lang.org. Abgerufen 2018-10-17.
  23. ^ Yegulalp, Serdar (2017-01-16). "NIM Sprache zeichnet sich aus dem Best of Python, Rost, Go und Lisp".. InfoWorld.
  24. ^ "NIM -Handbuch". nim-Lang.org. Abgerufen 2020-07-21.
  25. ^ "NIM -Handbuch: Methode Call Syntax". Abgerufen 2018-10-12.
  26. ^ Picheta, Dominik (DOM96); Wetherfordshire, Billingly (Fowlmouth); Felsing, Dennis (Def-); RAAF, Hans (Oderwat); Dunn, Christopher (CDUNN2001); Wizzardx (2017-10-25). "Tipps und Tricks". GitHub. Abgerufen 2018-10-17.
  27. ^ Rumpf, Andreas (2014-01-15). Nimrod: Ein neuer Ansatz zur Metaprogrammierung. Infoq. Das Ereignis findet um 2:23 Uhr statt. Abgerufen 2014-07-20.
  28. ^ Sieka, Jacek (2020-07-18), ARNETHEDUCK/NLVM, abgerufen 2020-07-21
  29. ^ Rumpf, Andreas (2018-10-12). "Nim Compiling". GitHub. Abgerufen 2018-10-17.
  30. ^ a b c "NIM Compiler -Benutzerhandbuch".
  31. ^ NIMs Speicherverwaltung
  32. ^ "Flink". GitHub. Abgerufen 2018-10-12.
  33. ^ "NIM V0.12.0 Release". GitHub. Abgerufen 2020-11-28.
  34. ^ "C2nim". GitHub. Abgerufen 2018-10-12.
  35. ^ "NIM -Wartungsskript". nim-Lang.org. Abgerufen 2021-11-16.
  36. ^ "NimGrep -Benutzerhandbuch". nim-Lang.org. Abgerufen 2021-11-16.
  37. ^ "NIM IDE Integration Guide". nim-Lang.org. Abgerufen 2021-11-16.
  38. ^ "NIMINST User Manual". nim-Lang.org. Abgerufen 2021-11-16.
  39. ^ "Tools mit nim verfügbar". nim-Lang.org. 2021-10-19. Archiviert vom Original am 2015-05-09. Abgerufen 2022-02-18.
  40. ^ "Auswähnen". GitHub. Abgerufen 2018-10-12.
  41. ^ Glukhov, Yuriy (2021-11-12), nimpy, abgerufen 2021-11-16
  42. ^ Nimterop/Nimterop, Nimterop, 2021-11-12, abgerufen 2021-11-16
  43. ^ NIM -Standardbibliothek
  44. ^ Installation, Die NIM-Programmiersprache, 2021-09-25, abgerufen 2021-11-16
  45. ^ Stefansalewski (2021-11-15), Hochstufe GTK4- und GTK3 -Bindungen für die NIM -Programmiersprache, abgerufen 2021-11-16
  46. ^ "Nimqml". GitHub.
  47. ^ "Wxnim". GitHub.
  48. ^ SDL2 für Nim, Die NIM-Programmiersprache, 2021-10-26, abgerufen 2021-11-16
  49. ^ Arabadzhi, Vladimir (2021-11-15), sdl2_nim 2.0.14.2, abgerufen 2021-11-16
  50. ^ Kairo, Die NIM-Programmiersprache, 2021-10-05, abgerufen 2021-11-16
  51. ^ OpenGL, Die NIM-Programmiersprache, 2021-11-14, abgerufen 2021-11-16
  52. ^ Station (2021-11-15), Winter, abgerufen 2021-11-16
  53. ^ "Vulkanim". GitHub.
  54. ^ "NIM Standard Library". NIM -Dokumentation. Archiviert von das Original Am 2015-04-06. Abgerufen 2015-04-04.
  55. ^ Lim, Andri (Jangko) (2018-10-17). "Nimlua". GitHub. Abgerufen 2018-10-17.
  56. ^ "Nimjl". GitHub.
  57. ^ "NBINDGEN". GitHub.
  58. ^ "cs2nim". GitHub.
  59. ^ "Ts2nim". GitHub.
  60. ^ Glukhov, Yuriy (2020-07-20), yglukhov/nimpy, abgerufen 2020-07-21
  61. ^ "NIM -Handbuch". nim-Lang.org. Abgerufen 2021-07-10.
  62. ^ "NIM mit Beispiel - First Class -Funktionen".
  63. ^ "NIM -Handbuch".
  64. ^ "Nim experimentelle Merkmale".
  65. ^ "NIM -Handbuch". nim-Lang.org. Abgerufen 2020-07-21.
  66. ^ "Nim Forum". nim-Lang.org. Abgerufen 2015-05-04.
  67. ^ "Primäres Quellcode -Repository und Fehler Tracker". GitHub. Abgerufen 2015-05-04.
  68. ^ "NIM Online -Konferenz 2020". Nim. Abgerufen 2020-11-28.
  69. ^ "Nimconf 2020". Nim. Abgerufen 2020-11-28.
  70. ^ "Nimconf 2020 Playlist". Youtube. Abgerufen 2020-11-28.
  71. ^ "Nim bei Oscon 2015". O'Reilly Open Source Convention (Oscon). O'Reilly Media. 2015-07-20. Abgerufen 2018-10-17.
  72. ^ Rumpf, Andreas; Swartz, Jason; Harrison, Matt. "Wesentliche Sprachen: Nim, Scala, Python". O’Reilly. O'Reilly Media. Abgerufen 2018-10-17.
  73. ^ Rumpf, Andreas (2015-10-26). Oscon 2015 - NIM: Ein Überblick. Youtube (Video). Abgerufen 2018-10-12.
  74. ^ "Veranstaltungen". fosdem.org. Abgerufen 2020-02-17.

Externe Links