Nim (programovací jazyk) - Nim (programming language)

Nim
Nim-logo.png
Logo koruny Nim
Paradigmata Multi-paradigma : kompilované , souběžné , procedurální , imperativní , funkční , objektově orientované
Navrhl Andreas Rumpf
Vývojář Tým Nim Lang [1]
Poprvé se objevil 2008 ; Před 13 lety ( 2008 )
Stabilní uvolnění
1.6.0  Upravte to na Wikidata / 19. října 2021 ; Před 0 dny ( 19. října 2021 )
Kázeň při psaní Statický , silný , odvozený , strukturální
Rozsah Lexikální
Plošina IA-32 , x86-64 , ARM , Aarch64 , RISC-V , PowerPC ... [2]
OS Cross-platform
Licence MIT
Rozšíření názvu souboru .nim, .nims, .nimble
webová stránka nim-lang .org
Ovlivněn
Ada , Modula-3 , Lisp , C ++ , Object Pascal , Python , Oberon , Rust [3]

Nim je nezbytně nutné , general-purpose , multi-paradigma , staticky napsaný a expresivní , systémy zkompilovaný programovací jazyk , navržený a vyvinutý Andreas Rumpf. Je navržen tak, aby byl „efektivní, expresivní a elegantní“, podporující metaprogramování , funkční , předávání zpráv , procedurální a objektově orientované programovací styly tím, že poskytuje několik funkcí, jako je generování časového kódu kompilace , algebraické datové typy , rozhraní cizích funkcí ( FFI) s C , C ++ , Objective-C a JavaScript a podporující kompilaci do stejných jazyků.

Popis

Nim byl vytvořen tak, aby byl jazyk tak rychlý jako C, expresivní jako Python a rozšiřitelný jako Lisp .

Nim je staticky napsaný. Podporuje funkce metaprogramování při kompilaci, jako jsou syntaktická makra a makra pro přepisování termínů . Makra pro přepisování termínů umožňují efektivní implementaci knihovních implementací běžných datových struktur, jako jsou bignumy a matice, jako by to byla vestavěná jazyková zařízení. Iterátory jsou podporovány a mohou být použity jako entity první třídy, stejně jako funkce, což umožňuje použití metod funkčního programování . Objektově orientované programování je podporováno dědičností a vícenásobným odesláním . Funkce mohou být obecné, mohou být přetížené a generika jsou dále vylepšena podporou Nim pro třídy typů. Podporováno je také přetížení operátora . Nim zahrnuje laditelné automatické shromažďování odpadků na základě odloženého počítání referencí s detekcí cyklu , které lze také úplně vypnout.

[Nim] ... představuje nejoriginálnější design, který se rozprostírá na pascalech a Pythonu a kompiluje do kódu C nebo JavaScriptu.

-  Andrew Binstock, editor-in-šéf of Dr. Dobb Journal 2014

Od října 2021 Nim kompiluje do jazyků C, C ++, JavaScript a Objective-C.

Dějiny

Verze Datum vydání
Stará verze, již není udržována: 0.10.2 29. 12. 2014
Stará verze, již není udržována: 0.11.2 2015-05-04
Stará verze, již není udržována: 0.12.0 27. 10. 2015
Stará verze, již není udržována: 0,13,0 2016-01-18
Stará verze, již není udržována: 0,14,2 2016-06-09
Stará verze, již není udržována: 0,15,2 23. 10. 2016
Stará verze, již není udržována: 0,16,0 2017-01-08
Stará verze, již není udržována: 0,17,2 2017-09-07
Stará verze, již není udržována: 0,18,0 2018-03-01
Stará verze, již není udržována: 0,19,6 13. 05. 2019
Stará verze, již není udržována: 0,20,2 17. června 2019
Stará verze, již není udržována: 1.0.0 23. 9. 2019
Starší verze, ale stále udržovaná: 1.0.10 27. 10. 2020
Stará verze, již není udržována: 1.2.0 2020-04-03
Starší verze, ale stále udržovaná: 1.2.12 2021-04-21
Stará verze, již není udržována: 1.4.0 16. 10. 2020
Starší verze, ale stále udržovaná: 1.4.8 2021-05-25
Aktuální stabilní verze: 1.6.0 2021-10-19
Legenda:
Stará verze
Starší verze, stále udržovaná
Nejnovější verze
Nejnovější verze náhledu
Budoucí vydání
Pro každou větev 0.x je uvedena pouze nejnovější bodová verze.
Pro pozdější větve je uvedena první a nejnovější bodová verze.

Počáteční vývoj společnosti Nim zahájil v roce 2005 Andreas Rumpf. Původně se jmenoval Nimrod, když byl projekt zveřejněn v roce 2008. První verze kompilátoru Nim byla napsána v Pascalu pomocí kompilátoru Free Pascal . V roce 2008 byla vydána verze kompilátoru napsaná v Nim. Kompilátor je bezplatný a open-source software a je vyvíjen komunitou dobrovolníků spolupracujících s Andreasem Rumpfem. Jazyk byl oficiálně přejmenován z Nimrod na Nim s vydáním verze 0.10.2 v prosinci 2014. 23. září 2019 byla vydána verze 1.0.0 Nim, což znamenalo zrání jazyka a jeho řetězce nástrojů.

Jazykový design

Syntax

Syntaxe Nim se podobá syntaxi Pythonu . Bloky kódu a vnořovací příkazy jsou identifikovány pomocí mezer, podle pravidla pro ofsajd . Mnoho klíčových slov je identických s jejich ekvivalenty v Pythonu, což jsou většinou anglická klíčová slova, zatímco jiné programovací jazyky obvykle používají interpunkci. S cílem zlepšit své vlivové jazyky, přestože Nim podporuje syntaxi založenou na odsazení, jako je Python, zavedl další flexibilitu; na další řádek lze přerušit příkazy čárkou nebo binárním operátorem. Nim navíc podporuje uživatelem definované operátory.

Nim je téměř plně necitlivý na styl; dva identifikátory jsou považovány za stejné, pokud se liší pouze velkými písmeny a podtržítky, pokud jsou první znaky totožné. Historicky Nim plně nerozlišoval velká a malá písmena (což znamená, že velká písmena a podtržítka identifikátorů byla plně ignorována).

Vliv

Nim byl ovlivněn specifickými vlastnostmi stávajících jazyků, včetně následujících:

Syntaxe volání jednotné funkce

Nim podporuje Uniform Function Call Syntax (UFCS) a rovnost identifikátorů, což poskytuje velkou míru flexibility při používání.

Například každý z těchto řádků provádí stejné volání, pouze s jinou syntaxí:

echo "hello world"
echo("hello world")
"hello world".echo()
"hello world".echo
"hello".echo(" world")
"hello".echo " world"

Rovnost identifikátorů

S výjimkou prvního písmene jsou identifikátory v Nim porovnávány způsobem, který nerozlišuje velká a malá písmena, a podtržítka jsou ignorována.

Příklad:

const useHttps = true
assert useHttps == useHttps
assert useHTTPS == useHttps
assert use_https == useHttps

Ořezávání

Funkce ořezávání umožňuje použití libovolného názvu pro proměnné nebo funkce, i když jsou názvy vyhrazenými slovy pro klíčová slova. Příkladem stropování je schopnost definovat proměnnou pojmenovanou ifbez střetu s klíčovým slovem if. Implementace Nim tohoto je dosažena pomocí backticks, což umožňuje použití jakéhokoli vyhrazeného slova jako identifikátoru.

type Type = object
  `int`: int

let `object` = Type(`int`: 9)
assert `object` is Type
assert `object`.`int` == 9

var `var` = 42
let `let` = 8
assert `var` + `let` == 50

const `assert` = true
assert `assert`

Překladač

Kompilátor Nim ve výchozím nastavení vysílá rychlý, optimalizovaný kód C. Odráží kód kompilace na objekt externímu kompilátoru C, aby využil stávající optimalizaci a přenositelnost kompilátoru. Podporováno je mnoho kompilátorů C, včetně Clang , Microsoft Visual C ++ (MSVC), MinGW a GNU Compiler Collection (GCC). Kompilátor Nim může také vydávat kód C ++ , Objective-C a JavaScript, což umožňuje snadné propojení s aplikačními programovacími rozhraními ( API ) napsanými v těchto jazycích; vývojáři mohou jednoduše psát v Nim a poté kompilovat do jakéhokoli podporovaného jazyka. To také umožňuje psaní aplikací pro iOS a Android . K dispozici je také neoficiální backend LLVM , který umožňuje použití kompilátoru Nim samostatně.

Kompilátor Nim je vlastní hostitel , což znamená, že je napsán v jazyce Nim. Kompilátor podporuje křížové kompilace, takže je schopen kompilovat software pro jakýkoli z podporovaných operačních systémů, bez ohledu na vývojový stroj. To je užitečné pro kompilaci aplikací pro vestavěné systémy a pro neobvyklé a nejasné počítačové architektury.

Možnosti kompilátoru

Ve výchozím nastavení kompilátor Nim vytvoří sestavení ladění . S možností release build může být vytvořen, který je optimalizován pro rychlost a obsahuje méně kontroly runtime. Pokud je požadována maximální rychlost, lze pomocí této možnosti deaktivovat všechny běhové kontroly. -d:release-d:danger

Správa paměti

Nim podporuje více strategií správy paměti, včetně následujících:

  • --gc:refc- Toto je výchozí GC. Je to oddělovač odpadků založený na počítání referencí s jednoduchým záložním GC Mark & ​​Sweep za účelem shromažďování cyklů. Haldy jsou lokální.
  • --gc:markAndSweep-Jednoduchý popelář na bázi Mark-And-Sweep . Haldy jsou lokální.
  • --gc:boehm- Sběrač odpadků založený na Boehmu , nabízí sdílenou hromadu.
  • --gc:go- Go 's popelář , užitečné pro interoperabilitu s Go . Nabízí sdílenou hromadu.
  • --gc:arc- Počítání referenčních referencí se sémantickými optimalizacemi tahů, nabízí sdílenou hromadu. Nabízí deterministický výkon pro tvrdé systémy v reálném čase. Referenční cykly způsobují úniky paměti, pozor.
  • --gc:orc- Stejné jako, --gc:arcale přidává kolektor cyklu na základě „zkušebního odstranění“. Bohužel je kvůli tomu obtížně uvažovat o jeho výkonnostním profilu, takže je méně užitečný pro tvrdé systémy v reálném čase.
  • --gc:none- Žádná strategie správy paměti ani odpadkový koš . Přidělená paměť se jednoduše nikdy neuvolní, pokud ji ručně neuvolní kód vývojáře.

Vývojové nástroje

Svázaný

S instalačním balíčkem Nim je dodáváno mnoho nástrojů, včetně:

Hbitý

Nimble je standardní správce balíčků, který Nim používá k balení modulů Nim. Původně byl vyvinut Dominikem Pichetou, který je také hlavním vývojářem Nim. Nimble je od 27. října 2015, vydání v0.12.0, zahrnut jako oficiální správce balíčků Nim.

Balíčky Nimble jsou definovány .nimblesoubory, které obsahují informace o verzi balíčku, autorovi, licenci, popisu, závislostech a další. Tyto soubory podporují omezenou podmnožinu syntaxe Nim zvanou NimScript, přičemž hlavním omezením je přístup k FFI. Tyto skripty umožňují změnu testovacího postupu nebo psaní vlastních úkolů.

Seznam balíků je uložen v souboru JSON (JavaScript Object Notation ), který je volně přístupný v úložišti nim-lang/packages na GitHubu. Tento soubor JSON poskytuje Nimble mapování mezi názvy balíčků a jejich adresami URL úložiště Git nebo Mercurial.

Nimble je dodáván s kompilátorem Nim. Proto je možné testovat čiperný prostředí spuštěním: nimble -v. Tento příkaz odhalí číslo verze, datum a čas kompilace a hbitý Git hash. Nimble používá balíček Git, který musí být k dispozici, aby Nimble správně fungoval. Příkazový řádek Nimble se používá jako rozhraní pro instalaci, odebrání (odinstalaci) a aktualizaci-opravy modulů balíčků.

c2nim

c2nim je kompilátor typu source-to-source (transcompiler nebo transpiler), který pomáhá generovat nové vazby překladem kódu ANSI C do kódu Nim. Výstupem je Nim kód čitelný pro člověka, který je určen k ruční optimalizaci po procesu překladu.

DrNim

DrNim je nástroj, který kombinuje frontend kompilátoru Nim s motorem proof Z3, aby bylo možné ověřit a validovat software napsaný v Nim. Nim je dodáván se zdrojovým kódem DrNim, ale vyžaduje kompilaci pomocí Koch, který je také součástí Nim.

Koch

Skript údržby, který se používá k sestavení Nim a poskytnutí dokumentace HTML.

Nimgrep

Nimgrep je obecný nástroj pro manipulaci s textem. Používá se k vyhledávání regexů, vzorů kolíků a obsahu adresářů a lze jej použít k nahrazení úkolů.

Nimsuggest

Nimsuggest je nástroj, který pomáhá libovolnému editoru zdrojového kódu dotazovat .nimzdrojový soubor na získání užitečných informací, jako je definice symbolů nebo návrhy na dokončení.

Niminst

Niminst je nástroj pro generování instalačního programu pro program Nim. Vytváří instalační programy .msi pro Windows pomocí Inno Setup a instaluje a odinstaluje skripty pro Linux , macOS a Berkeley Software Distribution (BSD).

Nenákladný

Nimpretty je zkrášlovač zdrojového kódu, který se používá k formátování kódu podle oficiálního průvodce stylem Nim.

Testament

Testament je pokročilý automatický běžec Unittests pro testy Nim. Používá se při vývoji Nim, nabízí testy izolace procesů, generuje statistiky o testovacích případech, podporuje více cílů a simulované suché běhy, má protokolování, může generovat zprávy HTML, přeskakovat testy ze souboru a další.

Další pozoruhodné nástroje

Některé pozoruhodné nástroje, které nejsou součástí balíčku Nim, zahrnují:

Choosenim

Choosenim byl vyvinut Dominikem Pichetou, tvůrcem správce balíčků Nimble, jako nástroj umožňující instalaci a používání více verzí kompilátoru Nim. Stahuje jakoukoli stabilní verzi Nim nebo verzi kompilátoru vývoje z příkazového řádku, což umožňuje snadné přepínání mezi nimi.

Nimfix

Nimfix je nástroj pro převod částí starého stylu kódu Nimrod na kód Nim. Od roku 2019 je ve verzi beta .

pas2nim

pas2nim je nástroj přeložit Object Pascal obaly na Nim kódu. pas2nim hrál důležitou roli v Nimově časové ose, protože byl použit k překladu původních zdrojů Pascal kompilátoru Nim. Podporováno je pouze to, co se snadno mapuje na Nim; Volné třídy ve stylu Pascal a Delphi nejsou podporovány, stejně jako některé další obtížně přeložitelné funkce. Od října 2020 je vývoj a údržba na pas2nim většinou zastavena.

py2nim

py2nim je nástroj používaný k překladu kódu Pythonu do idiomatického kódu Nim. V roce 2020 se jeho vývoj zastavil.

Knihovny

Čisté/nečisté knihovny

Čisté knihovny jsou moduly napsané pouze v Nim. Neobsahují žádné obaly pro přístup ke knihovnám napsaným v jiných programovacích jazycích.

Nečisté knihovny jsou moduly kódu Nim, které závisí na externích knihovnách, které jsou napsány v jiných programovacích jazycích, jako je C.

Standardní knihovna

Standardní knihovna Nim obsahuje moduly pro všechny základní úkoly, včetně:

  • Systémové a základní moduly
  • Sbírky a algoritmy
  • Zpracování řetězců
  • Zpracování času
  • Obecné služby operačního systému
  • Matematické knihovny
  • Internetové protokoly a podpora
  • Navlékání
  • Analyzátory
  • Docutils
  • Zpracování XML
  • Generátor kódu XML a HTML
  • Hashování
  • Podpora databáze (PostgreSQL, MySQL a SQLite)
  • Obálky (Win32 API, POSIX)

Využití jiných knihoven

Program Nim může používat libovolnou knihovnu, kterou lze použít v programu C, C ++ nebo JavaScript. Jazykové vazby existují pro mnoho knihoven, včetně GTK+ , Qt QML, wxWidgets , Simple DirectMedia Layer (SDL) 2, Cairo , OpenGL , Windows API (WinAPI), zlib , libzip , OpenSSL , Vulkan a cURL . Nim pracuje s databázemi PostgreSQL , MySQL a SQLite . Nim může komunikovat s programovacími jazyky Lua , Julia , Rust , C Sharp , TypeScript a Python .

Příklady

Ahoj světe

"Hello, World!" program v Nim:

echo("Hello, world!")
# Procedures can be called with no parentheses
echo "Hello, World!"

Další verze vytváření „Hello World“ je ...

stdout.write("Hello, world!\n")

Faktoriál

Program pro výpočet faktoriálu kladného celého čísla pomocí iteračního přístupu:

import strutils

var n = 0
try:
  stdout.write "Input positive integer number: "
  n = stdin.readline.parseInt
except ValueError:
  raise newException(ValueError, "You must enter a positive number")

var fact = 1
for i in 2..n:
  fact = fact * i

echo fact

Použití modulu matematiky ze standardní knihovny Nim:

import math
echo fac(x)

Obrácení řetězce

Jednoduchá ukázka ukazující mnoho Nimových funkcí.

proc reverse(s: string): string =
  for i in countdown(s.high, 0):
    result.add s[i]

let str1 = "Reverse This!"
echo "Reversed: ", reverse(str1)

Jednou z exotičtějších funkcí je implicitní resultproměnná. Každá procedura v Nim s nevratným návratovým typem má implicitní proměnnou výsledku, která představuje hodnotu, která má být vrácena. Ve smyčce for vidíme vyvolání, countdownkteré je iterátorem. Pokud je iterátor vynechán, kompilátor se pokusí použít itemsiterátor, pokud je pro zadaný typ definován.

Grafické uživatelské prostředí

Použití GTK 3 s introspekcí gobject prostřednictvím modulu gintro :

import gintro/[gtk, glib, gobject, gio]

proc appActivate(app: Application) =
  let window = newApplicationWindow(app)
  window.title = "GTK3 application with gobject introspection"
  window.defaultSize = (400, 400)
  showAll(window)

proc main =
  let app = newApplication("org.gtk.example")
  connect(app, "activate", appActivate)
  discard run(app)

main()

Tento kód vyžaduje, aby fungoval modul gintro, který není součástí standardní knihovny. K instalaci modulu gintro a mnoha dalších můžete použít nástroj nimble, který je součástí nim. Chcete -li nainstalovat modul gintro s hbitým, postupujte takto:

nimble install gintro

Programovací paradigmata

Funkcionální programování

Funkční programování je v Nim podporováno prostřednictvím prvotřídních funkcí a kódu bez vedlejších účinků prostřednictvím pragma `noSideEffect`, klíčového slova` func` a experimentální funkce `strictFuncs`.

Když je povolena funkce `strictFuncs`, bude Nim provádět analýzu vedlejších účinků a vyvolávat chyby při kompilaci kódu, který nedodržuje smlouvu o produkci žádných vedlejších účinků .

Na rozdíl od čistě funkčních programovacích jazyků je Nim programovací jazyk s více paradigmaty , takže omezení funkčního programování jsou volitelná na základě funkcí podle funkcí.

Prvotřídní funkce

Nim podporuje prvotřídní funkce tím, že umožňuje ukládání funkcí do proměnných nebo jejich předávání jako parametrů vyvolávaných jinými funkcemi.

Například:

import sequtils

let powersOfTwo = @[1, 2, 4, 8, 16, 32, 64, 128, 256]

echo(powersOfTwo.filter do (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)

Produkuje výstup:

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

Funkce

funcKlíčové slovo představuje zkratku pro noSideEffectPragma.

func binarySearch[T](a: openArray[T]; elem: T): int

Je zkratka pro:

proc binarySearch[T](a: openArray[T]; elem: T): int {.noSideEffect.}

Přísné funkce

Od verze 1.4 je k dispozici přísnější definice „vedlejšího účinku“. Kromě stávajícího pravidla, že vedlejší efekt volá funkci s vedlejšími efekty, je vynuceno také následující pravidlo:

Jakákoli mutace objektu se počítá jako vedlejší účinek, pokud je k tomuto objektu dosažitelný pomocí parametru, který není deklarován jako varparametr.

Například:

{.experimental: "strictFuncs".}

type
  Node = ref object
    le, ri: Node
    data: string

func len(n: Node): int =
  # valid: len does not have side effects
  var it = n
  while it != nil:
    inc result
    it = it.ri

func mut(n: Node) =
  let m = n # is the statement that connected the mutation to the parameter
  m.data = "yeah" # the mutation is here
  # Error: 'mut' can have side effects
  # an object reachable from 'n' is potentially mutated

Objektově orientované programování (OOP)

Metaprogramování

Šablona

Toto je příklad metaprogramování v Nim pomocí jeho zařízení pro šablony.

template genType(name, fieldname: untyped, fieldtype: typedesc) =
  type
    name = object
      fieldname: fieldtype

genType(Test, foo, int)

var x = Test(foo: 4566)
echo(x.foo) # 4566

genTypeJe vyvolána při kompilaci-time a Testje vytvořen typ.

Obecný

Nim podporuje omezené i neomezené generické programování. V postupech, šablonách a makrech lze použít generika. Jsou definovány za jménem proc v hranatých závorkách, jak je vidět níže.

proc addThese[T](a, b: T): T =
  a + b

echo addThese(1, 2) # 3 (of int type)
echo addThese(uint8 1, uint8 2) # 3 (of uint8 type)

V roce addThese, Tje obecný typ, kompilátor přijmout žádnou hodnotu pro tuto funkci tak dlouho, dokud oba parametry a návratové hodnoty jsou stejného typu.

Lze dále objasnit, které typy bude procedura akceptovat, zadáním třídy typů.

proc addTheseNumbers[T: SomeNumber](a, b: T): T =
  a + b

addTheseNumberspak bude fungovat pouze pro typy obsažené v SomeNumbertypu součtu.

Makra

Makra mohou přepsat části kódu v době kompilace. Makra Nim jsou výkonná a mohou provádět mnoho operací se stromem abstraktní syntaxe.

Zde je jednoduchý příklad, který vytvoří makro nazvané dvakrát:

import macros

macro twice(arg: untyped): untyped =
  result = quote do:
    `arg`
    `arg`

twice echo "Hello world!"

twiceMakra v tomto příkladu má příkaz echo ve formě syntaktický strom jako vstup. V tomto příkladu jsme se rozhodli vrátit tento strom syntaxe bez jakýchkoli manipulací. Ale děláme to dvakrát, odtud název makra. Výsledkem je, že kód přepíše makro tak, aby v době kompilace vypadal jako následující kód:

echo "Hello world!"
echo "Hello world!"

Rozhraní cizích funkcí (FFI)

Nim's FFI se používá k volání funkcí napsaných v jiných programovacích jazycích, do kterých se může kompilovat. To znamená, že ve zdrojovém kódu Nim lze použít knihovny napsané v jazycích C, C ++, Objective-C a JavaScript. Je třeba si uvědomit, že knihovny JavaScript a C, C ++ nebo Objective-C nelze kombinovat ve stejném programu, protože nejsou tak kompatibilní s JavaScriptem, jako jsou navzájem. C ++ i Objective-C jsou založeny na C a jsou s ním kompatibilní, ale JavaScript je nekompatibilní, jako dynamický webový jazyk na straně klienta. </ref>

Následující program ukazuje snadnost, s jakou lze externí C kód použít přímo v Nim.

proc printf(formatstr: cstring) {.header: "<stdio.h>", varargs.}

printf("%s %d\n", "foo", 5)

V tomto kódu je printffunkce importována do Nim a poté použita.

Základní příklad použití 'console.log' přímo pro cíl kompilace JavaScriptu :

proc log(args: any) {.importjs: "console.log(@)", varargs.}
log(42, "z", true, 3.14)

Kód JavaScript vytvořený kompilátorem Nim lze spustit pomocí Node.js nebo webového prohlížeče.

Rovnoběžnost

Chcete -li aktivovat podporu vláken v Nim, program by měl být kompilován s --threads:onargumentem příkazového řádku. Každé vlákno má samostatnou hromadu odpadků a sdílení paměti je omezeno, což pomáhá s efektivitou a zastavuje konfliktní podmínky podle vláken.

import locks

var
  thr: array[0..4, Thread[tuple[a,b: int]]]
  L: Lock

proc threadFunc(interval: tuple[a,b: int]) {.thread.} =
  for i in interval.a..interval.b:
    acquire(L) # lock stdout
    echo i
    release(L)

initLock(L)

for i in 0..high(thr):
  createThread(thr[i], threadFunc, (i*10, i*10+5))
joinThreads(thr)

Nim má také channelsmodul, který zjednodušuje předávání dat mezi vlákny.

import os

type
  CalculationTask = object
    id*: int
    data*: int

  CalculationResult = object
    id*: int
    result*: int

var task_queue: Channel[CalculationTask]
var result_queue: Channel[CalculationResult]

proc workerFunc() {.thread.} =
  result_queue.open()

  while true:
    var task = task_queue.recv()
    result_queue.send(CalculationResult(id: task.id, result: task.data * 2))

var workerThread: Thread[void]
createThread(workerThread, workerFunc)

task_queue.open()
task_queue.send(CalculationTask(id: 1, data: 13))
task_queue.send(CalculationTask(id: 2, data: 37))

while true:
  echo "got result: ", repr(result_queue.recv())

Konkurence

Nim podporuje asynchronní IO prostřednictvím asyncdispatchmodulu, který přidává asynchronní/čekající syntaxi prostřednictvím makrosystému. Příklad asynchronního http serveru:

import asynchttpserver, asyncdispatch

var server = newAsyncHttpServer()
proc cb(req: Request) {.async.} =
  await req.respond(Http200, "Hello World")

waitFor server.serve(Port(8080), cb)

Společenství

Nim má aktivní komunitu na vlastním hostovaném oficiálním fóru, které si sám vytvořil. Dále projekt využívá úložiště Git, nástroj pro sledování chyb a wiki hostovanou na GitHubu , kde komunita komunikuje s jazykem.

Konvence

První konference Nim, NimConf, se konala 20. června 2020. Konala se digitálně kvůli COVID-19 a byla otevřena výzva k rozhovorům přispěvatelů ve formě videí na YouTube . Konference začala jazykovými přehledem vývojářů Nim Andrease Rumpfa a Dominika Pichety. Témata prezentace zahrnovala rozhovory o webových rámcích Nim, mobilním vývoji , zařízeních internetu věcí (IoT) a vývoji her , včetně povídání o psaní Nim pro Game Boy Advance . NimConf 2020 je k dispozici jako seznam skladeb na YouTube.

Kromě oficiálních konferencí byl Nim uveden na různých dalších sjezdech. Prezentace na téma Nim byla přednesena na O'Reilly Open Source Convention (OSCON) v roce 2015. Čtyři řečníci zastupovali Nim na European Meeting ( FOSDEM ) 2020 Free and Open source Software Developers 'European , včetně tvůrce jazyka Andrease Rumpfa.

Viz také

Reference

externí odkazy