Nim (langage de programmation) - Nim (programming language)

Nim
Nim-logo.png
Le logo de la couronne Nim
Paradigmes Multi-paradigme : compilé , concurrent , procédural , impératif , fonctionnel , orienté objet
Conçu par Andreas Rumpf
Développeur Équipe Nim Lang [1]
Première apparition 2008 ; Il y a 13 ans ( 2008 )
Version stable
1.6.0  Modifiez ceci sur Wikidata / 19 octobre 2021 ; il y a 0 jours ( 19 octobre 2021 )
Discipline de frappe Statique , fort , inféré , structurel
Portée Lexical
Plate-forme IA-32 , x86-64 , ARM , Aarch64 , RISC-V , PowerPC ... [2]
Système d'exploitation Multiplateforme
Licence MIT
Extensions de nom de fichier .nim, .nims, .nimble
Site Internet nim-lang .org
Influencé par
Ada , Modula-3 , Lisp , C++ , Pascal Objet , Python , Oberon , Rust [3]

Nim est un impératif , à usage général , multi-paradigme , statiquement typé et expressif , systèmes compilé langage de programmation , conçu et développé par Andreas Rumpf. Il est conçu pour être "efficace, expressif et élégant", prenant en charge les styles de métaprogrammation , fonctionnel , de passage de messages , procédural et orienté objet en fournissant plusieurs fonctionnalités telles que la génération de code temporel de compilation , les types de données algébriques , une interface de fonction étrangère ( FFI) avec C , C++ , Objective-C et JavaScript , et prenant en charge la compilation dans ces mêmes langages.

La description

Nim a été créé pour être un langage aussi rapide que C, aussi expressif que Python et aussi extensible que Lisp .

Nim est typé statiquement. Il prend en charge les fonctionnalités de métaprogrammation à la compilation telles que les macros syntaxiques et les macros de réécriture de termes . Les macros de réécriture de termes permettent d' implémenter efficacement des implémentations de bibliothèques de structures de données communes, telles que des bignums et des matrices, comme s'il s'agissait de fonctionnalités de langage intégrées. Les itérateurs sont pris en charge et peuvent être utilisés comme entités de première classe, tout comme les fonctions, permettant l'utilisation de méthodes de programmation fonctionnelles . La programmation orientée objet est prise en charge par l' héritage et la répartition multiple . Les fonctions peuvent être génériques, elles peuvent être surchargées et les génériques sont encore améliorés par la prise en charge par Nim des classes de types. La surcharge des opérateurs est également prise en charge. Nim inclut un garbage collection automatique réglable basé sur un comptage de références différé avec détection de cycle , qui peut également être complètement désactivé.

[Nim] ... présente une conception des plus originales qui chevauche Pascal et Python et se compile en code C ou JavaScript.

—  Andrew Binstock, rédacteur en chef du Dr. Dobb's Journal , 2014

Depuis octobre 2021, Nim compile en C, C++, JavaScript et Objective-C.

Histoire

Version Date de sortie
Ancienne version, plus maintenue : 0.10.2 2014-12-29
Ancienne version, plus maintenue : 0.11.2 2015-05-04
Ancienne version, plus maintenue : 0,12,0 2015-10-27
Ancienne version, plus maintenue : 0.13.0 2016-01-18
Ancienne version, plus maintenue : 0,14.2 2016-06-09
Ancienne version, plus maintenue : 0,15.2 2016-10-23
Ancienne version, plus maintenue : 0,16.0 2017-01-08
Ancienne version, plus maintenue : 0,17.2 2017-09-07
Ancienne version, plus maintenue : 0,18.0 2018-03-01
Ancienne version, plus maintenue : 0,19.6 2019-05-13
Ancienne version, plus maintenue : 0.20.2 2019-06-17
Ancienne version, plus maintenue : 1.0.0 2019-09-23
Ancienne version, mais toujours maintenue : 1.0.10 2020-10-27
Ancienne version, plus maintenue : 1.2.0 2020-04-03
Ancienne version, mais toujours maintenue : 1.2.12 2021-04-21
Ancienne version, plus maintenue : 1.4.0 2020-10-16
Ancienne version, mais toujours maintenue : 1.4.8 2021-05-25
Version stable actuelle : 1.6.0 2021-10-19
Légende:
Ancienne version
Ancienne version, toujours maintenue
Dernière version
Dernière version d'aperçu
Version future
Pour chaque branche 0.x, seule la dernière version intermédiaire est répertoriée.
Pour les branches ultérieures, la première et la dernière version intermédiaire sont répertoriées.

Le développement initial de Nim a été lancé en 2005 par Andreas Rumpf. Il s'appelait à l'origine Nimrod lorsque le projet a été rendu public en 2008. La première version du compilateur Nim a été écrite en Pascal à l'aide du compilateur Free Pascal . En 2008, une version du compilateur écrit en Nim est sortie. Le compilateur est un logiciel libre et open source , et est développé par une communauté de bénévoles travaillant avec Andreas Rumpf. Le langage a été officiellement renommé de Nimrod à Nim avec la sortie de la version 0.10.2 en décembre 2014. Le 23 septembre 2019, la version 1.0.0 de Nim a été publiée, signifiant la maturation du langage et de sa chaîne d'outils.

Conception du langage

Syntaxe

La syntaxe de Nim ressemble à celle de Python . Les blocs de code et les instructions d'imbrication sont identifiés par l'utilisation d'espaces blancs, conformément à la règle de hors-jeu . De nombreux mots - clés sont identiques à leurs équivalents Python, qui sont pour la plupart des mots-clés en anglais, alors que d'autres langages de programmation utilisent généralement la ponctuation. Dans le but d'améliorer ses langages d'influence, même si Nim prend en charge la syntaxe basée sur l'indentation comme Python, il a introduit une flexibilité supplémentaire ; on peut casser des déclarations avec une virgule ou un opérateur binaire à la ligne suivante. De plus, Nim prend en charge les opérateurs définis par l'utilisateur.

Nim est presque totalement insensible au style ; deux identifiants sont considérés égaux s'ils ne diffèrent que par les majuscules et les traits de soulignement, tant que les premiers caractères sont identiques. Historiquement, Nim était totalement insensible à la casse (ce qui signifie que les majuscules et les traits de soulignement des identifiants étaient totalement ignorés).

Influence

Nim a été influencé par des caractéristiques spécifiques des langues existantes, notamment les suivantes :

Syntaxe d'appel de fonction uniforme

Nim prend en charge la syntaxe d'appel de fonction uniforme (UFCS) et l'égalité des identifiants, ce qui offre une grande flexibilité d'utilisation.

Par exemple, chacune de ces lignes fait le même appel, mais avec une syntaxe différente :

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

Égalité des identifiants

À l'exception de la première lettre, les identifiants dans Nim sont comparés sans tenir compte de la casse et les traits de soulignement sont ignorés.

Exemple:

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

Stropping

La fonction stropping permet l'utilisation de n'importe quel nom pour les variables ou les fonctions, même lorsque les noms sont des mots réservés pour les mots-clés. Un exemple de stropping est la possibilité de définir une variable nommée if, sans entrer en conflit avec le mot-clé if. L'implémentation par Nim de ceci est réalisée via des backticks, permettant à n'importe quel mot réservé d'être utilisé comme identifiant.

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`

Compilateur

Le compilateur Nim émet du code C rapide et optimisé par défaut. Il reporte la compilation du code objet à un compilateur C externe pour tirer parti de l'optimisation et de la portabilité du compilateur existant. De nombreux compilateurs C sont pris en charge, notamment Clang , Microsoft Visual C++ (MSVC), MinGW et GNU Compiler Collection (GCC). Le compilateur Nim peut également émettre du code C++ , Objective-C et JavaScript pour permettre une interface facile avec les interfaces de programmation d'applications ( API ) écrites dans ces langages ; les développeurs peuvent simplement écrire dans Nim, puis compiler dans n'importe quel langage pris en charge. Cela permet également d'écrire des applications pour iOS et Android . Il existe également un backend LLVM non officiel , permettant l'utilisation du compilateur Nim de manière autonome.

Le compilateur Nim est auto-hébergé , ce qui signifie qu'il est écrit dans le langage Nim. Le compilateur prend en charge la compilation croisée, il est donc capable de compiler des logiciels pour tous les systèmes d'exploitation pris en charge, quelle que soit la machine de développement. Ceci est utile pour compiler des applications pour des systèmes embarqués et pour des architectures informatiques peu courantes et obscures.

Options du compilateur

Par défaut, le compilateur Nim crée une version de débogage . Avec l'option, -d:releaseune version de version peut être créée, qui est optimisée pour la vitesse et contient moins de contrôles d'exécution. Avec l'option, -d:dangertous les contrôles d'exécution peuvent être désactivés, si la vitesse maximale est souhaitée.

Gestion de la mémoire

Nim prend en charge plusieurs stratégies de gestion de la mémoire, notamment les suivantes :

  • --gc:refc– Il s'agit du GC par défaut. Il s'agit d'un ramasse-miettes basé sur le comptage de références différées avec un simple GC de sauvegarde Mark&Sweep afin de collecter les cycles. Les tas sont thread-local.
  • --gc:markAndSweep– Un simple ramasse-miettes basé sur Mark-And-Sweep . Les tas sont thread-local.
  • --gc:boehm– Le ramasse-miettes basé sur Boehm , il offre un tas partagé.
  • --gc:go– Le ramasse-miettes de Go , utile pour l'interopérabilité avec Go . Offre un tas partagé.
  • --gc:arc– Comptage de références simples avec optimisations sémantiques de déplacement, offre un tas partagé. Il offre des performances déterministes pour les systèmes temps réel durs. Les cycles de référence provoquent des fuites de mémoire, attention.
  • --gc:orc– Identique à --gc:arcmais ajoute un collecteur de cycles basé sur la « suppression d'essai ». Malheureusement, cela rend son profil de performances difficile à raisonner, il est donc moins utile pour les systèmes temps réel difficiles.
  • --gc:none– Pas de stratégie de gestion de la mémoire ni de ramasse-miettes . La mémoire allouée n'est tout simplement jamais libérée, à moins qu'elle ne soit libérée manuellement par le code du développeur.

Outils de développement

Regroupé

De nombreux outils sont fournis avec le package d'installation de Nim, notamment :

Agile

Nimble est le gestionnaire de packages standard utilisé par Nim pour packager les modules Nim. Il a été initialement développé par Dominik Picheta, qui est également un développeur principal de Nim. Nimble est inclus en tant que gestionnaire de packages officiel de Nim depuis le 27 octobre 2015, la version v0.12.0.

Les packages Nimble sont définis par des .nimblefichiers, qui contiennent des informations sur la version du package, l'auteur, la licence, la description, les dépendances, etc. Ces fichiers prennent en charge un sous-ensemble limité de la syntaxe Nim appelé NimScript, la principale limitation étant l'accès au FFI. Ces scripts permettent de modifier la procédure de test ou d'écrire des tâches personnalisées.

La liste des packages est stockée dans un fichier JavaScript Object Notation ( JSON ) qui est librement accessible dans le référentiel nim-lang/packages sur GitHub. Ce fichier JSON fournit à Nimble un mappage entre les noms des packages et leurs URL de référentiel Git ou Mercurial.

Nimble est fourni avec le compilateur Nim. Ainsi, il est possible de tester l'environnement Nimble en exécutant : nimble -v. Cette commande révélera le numéro de version, la date et l'heure de compilation et le hachage Git de nimble. Nimble utilise le package Git, qui doit être disponible pour que Nimble fonctionne correctement. La ligne de commande Nimble est utilisée comme interface pour l'installation, la suppression (la désinstallation) et la mise à niveau des packages de modules.

c2nim

c2nim est un compilateur source à source (transcompilateur ou transpileur) qui permet de générer de nouvelles liaisons en traduisant le code C ANSI en code Nim. La sortie est un code Nim lisible par l'homme qui est destiné à être optimisé à la main après le processus de traduction.

DrNim

DrNim est un outil qui combine le compilateur Nim Frontend avec le moteur de preuve Z3 afin de permettre la vérification et la validation de logiciels écrits en Nim. Nim est livré avec le code source DrNim inclus, mais nécessite une compilation à l'aide de Koch, également fourni avec Nim.

Koch

Un script de maintenance utilisé pour construire Nim et fournir une documentation HTML.

Nimgrep

Nimgrep est un outil générique pour manipuler du texte. Il est utilisé pour rechercher des expressions régulières, des modèles de cheville et le contenu des répertoires, et il peut être utilisé pour remplacer des tâches.

Nimsuggest

Nimsuggest est un outil qui aide tout éditeur de code source à interroger un .nimfichier source pour obtenir des informations utiles telles que la définition de symboles ou des suggestions de complétions.

Niminst

Niminst est un outil pour générer un installateur pour un programme Nim. Il crée des programmes d'installation .msi pour Windows via Inno Setup et installe et désinstalle des scripts pour Linux , macOS et Berkeley Software Distribution (BSD).

Insignifiant

Nimpretty est un embellisseur de code source, utilisé pour formater le code selon le guide de style officiel de Nim.

Testament

Testament est un lanceur automatique avancé de tests unitaires pour les tests Nim. Utilisé dans le développement de Nim, il propose des tests d'isolation de processus, génère des statistiques sur les cas de test, prend en charge plusieurs cibles et des essais à sec simulés, dispose d'une journalisation, peut générer des rapports HTML, peut ignorer les tests d'un fichier, etc.

Autres outils notables

Certains outils notables non inclus dans le package Nim incluent :

Choisinim

Choosenim a été développé par Dominik Picheta, créateur du gestionnaire de packages Nimble, en tant qu'outil permettant d'installer et d'utiliser plusieurs versions du compilateur Nim. Il télécharge n'importe quelle version stable ou de développement du compilateur Nim à partir de la ligne de commande, ce qui permet de basculer facilement entre elles.

Nimfix

Nimfix est un outil pour convertir des parties de code Nimrod à l'ancienne en code Nim. Depuis 2019, il est en version bêta .

pas2nim

pas2nim est un outil pour traduire les wrappers Object Pascal en code Nim. pas2nim a joué un rôle important dans la chronologie de Nim, car il a été utilisé pour traduire les sources Pascal originales du compilateur Nim. Seul ce qui correspond facilement à Nim est pris en charge ; Free Pascal, les classes de style Delphi ne sont pas prises en charge, tout comme certaines autres fonctionnalités difficiles à traduire. Depuis octobre 2020, le développement et la maintenance sur pas2nim sont pour la plupart au point mort.

py2nim

py2nim est un outil utilisé pour traduire le code Python en code Nim idiomatique. A partir de 2020, son développement est au point mort.

Bibliothèques

Bibliothèques pures/impures

Les bibliothèques pures sont des modules écrits en Nim uniquement. Ils n'incluent aucun wrapper pour accéder aux bibliothèques écrites dans d'autres langages de programmation.

Les bibliothèques impures sont des modules de code Nim qui dépendent de bibliothèques externes écrites dans d'autres langages de programmation tels que C.

Bibliothèque standard

La bibliothèque standard Nim comprend des modules pour toutes les tâches de base, notamment :

  • Systèmes et modules de base
  • Collections et algorithmes
  • Manipulation des chaînes
  • Gestion du temps
  • Services génériques du système d'exploitation
  • Bibliothèques mathématiques
  • Protocoles Internet et assistance
  • Enfilage
  • Analyseurs
  • Documents
  • Traitement XML
  • Générateur de code XML et HTML
  • Hachage
  • Prise en charge des bases de données (PostgreSQL, MySQL et SQLite)
  • Wrappers (API Win32, POSIX)

Utilisation d'autres bibliothèques

Un programme Nim peut utiliser n'importe quelle bibliothèque pouvant être utilisée dans un programme C, C++ ou JavaScript. Des liaisons de langage existent pour de nombreuses bibliothèques, notamment GTK+ , Qt QML, wxWidgets , Simple DirectMedia Layer (SDL) 2, Cairo , OpenGL , Windows API (WinAPI), zlib , libzip , OpenSSL , Vulkan et cURL . Nim fonctionne avec les bases de données PostgreSQL , MySQL et SQLite . Nim peut s'interfacer avec les langages de programmation Lua , Julia , Rust , C Sharp , TypeScript et Python .

Exemples

Bonjour le monde

Le "Bonjour, Monde!" programme en Nim :

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

Une autre version de la création d'un "Hello World" est...

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

Factorielle

Programme pour calculer la factorielle d'un entier positif en utilisant l'approche itérative :

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

Utilisation du module math de la bibliothèque standard de Nim :

import math
echo fac(x)

Inverser une chaîne

Une démonstration simple montrant de nombreuses fonctionnalités de Nim.

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

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

L'une des caractéristiques les plus exotiques est la resultvariable implicite . Chaque procédure dans Nim avec un type de retour non void a une variable de résultat implicite qui représente la valeur à retourner. Dans la boucle for, nous voyons une invocation countdowndont est un itérateur. Si un itérateur est omis, le compilateur tentera d'utiliser un itemsitérateur, s'il est défini pour le type spécifié.

Interface utilisateur graphique

Utilisation de GTK 3 avec l'introspection gobject via le module 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()

Ce code nécessite le module gintro pour fonctionner, qui ne fait pas partie de la bibliothèque standard. Pour installer le module gintro et bien d'autres, vous pouvez utiliser l'outil nimble, qui fait partie de nim. Pour installer le module gintro avec nimble, procédez comme suit :

nimble install gintro

Paradigmes de programmation

Programmation fonctionnelle

La programmation fonctionnelle est prise en charge dans Nim via des fonctions et un code de première classe sans effets secondaires via le pragma `noSideEffect`, le mot-clé `func` et la fonctionnalité expérimentale `strictFuncs`.

Avec la fonctionnalité "strictFuncs" activée, Nim effectuera une analyse des effets secondaires et générera des erreurs de compilation pour le code qui n'obéit pas au contrat de ne pas produire d' effets secondaires .

Contrairement aux langages de programmation purement fonctionnels , Nim est un langage de programmation multi-paradigmes , de sorte que les restrictions de programmation fonctionnelles sont acceptées fonction par fonction.

Fonctions de première classe

Nim prend en charge les fonctions de première classe en permettant aux fonctions d'être stockées dans des variables ou transmises en tant que paramètres à appeler par d'autres fonctions.

Par exemple:

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)

Produit la sortie :

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

Fonctions

Le funcmot-clé introduit un raccourci pour un noSideEffectpragma.

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

Est l'abréviation de :

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

Fonctions strictes

Depuis la version 1.4, une définition plus stricte d'un "effet secondaire" est disponible. En plus de la règle existante selon laquelle un effet secondaire appelle une fonction avec des effets secondaires, la règle suivante est également appliquée :

Toute mutation d'un objet compte comme un effet secondaire si cet objet est accessible via un paramètre qui n'est pas déclaré comme varparamètre.

Par exemple:

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

Programmation orientée objet (POO)

Métaprogrammation

Modèle

Ceci est un exemple de métaprogrammation dans Nim utilisant ses fonctionnalités de modèle.

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

Le genTypeest invoqué au moment de la compilation et un Testtype est créé.

Générique

Nim prend en charge la programmation générique avec et sans contrainte. Les génériques peuvent être utilisés dans les procédures, les modèles et les macros. Ils sont définis après le nom du proc entre crochets, comme on le voit ci-dessous.

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)

Dans addThese, Test le type générique, le compilateur acceptera toutes les valeurs pour cette fonction tant que les deux paramètres et la valeur de retour sont du même type.

On peut en outre clarifier quels types la procédure acceptera en spécifiant une classe de types.

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

addTheseNumbersne fonctionnera alors que pour les types contenus dans le SomeNumbertype sum.

Macro

Les macros peuvent réécrire des parties du code au moment de la compilation. Les macros Nim sont puissantes et peuvent effectuer de nombreuses opérations sur l'arbre de syntaxe abstraite.

Voici un exemple simple, qui crée une macro appelée deux fois :

import macros

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

twice echo "Hello world!"

La twicemacro de cet exemple prend en entrée l'instruction echo sous la forme d'un arbre de syntaxe abstrait. Dans cet exemple, nous avons décidé de retourner cet arbre syntaxique sans aucune manipulation. Mais on le fait deux fois, d'où le nom de la macro. Le résultat est que le code est réécrit par la macro pour ressembler au code suivant au moment de la compilation :

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

Interface de fonction étrangère (FFI)

Le FFI de Nim est utilisé pour appeler des fonctions écrites dans les autres langages de programmation avec lesquels il peut compiler. Cela signifie que les bibliothèques écrites en C, C++, Objective-C et JavaScript peuvent être utilisées dans le code source de Nim. Il faut savoir que les bibliothèques JavaScript et C, C++ ou Objective-C ne peuvent pas être combinées dans le même programme, car elles ne sont pas aussi compatibles avec JavaScript qu'elles le sont entre elles. C++ et Objective-C sont tous deux basés sur et compatibles avec C, mais JavaScript est incompatible, en tant que langage Web dynamique côté client.</ref>

Le programme suivant montre la facilité avec laquelle le code C externe peut être utilisé directement dans Nim.

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

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

Dans ce code, la printffonction est importée dans Nim puis utilisée.

Exemple de base utilisant 'console.log' directement pour la cible de compilation JavaScript :

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

Le code JavaScript produit par le compilateur Nim peut être exécuté avec Node.js ou un navigateur Web.

Parallélisme

Pour activer la prise en charge des threads dans Nim, un programme doit être compilé avec un --threads:onargument de ligne de commande. Chaque thread a un tas de récupération de mémoire séparé et le partage de la mémoire est restreint, ce qui contribue à l'efficacité et arrête les conditions de concurrence par les threads.

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 dispose également d'un channelsmodule qui simplifie la transmission de données entre les threads.

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())

Concurrence

Nim prend en charge les E/S asynchrones via le asyncdispatchmodule, qui ajoute une syntaxe async/wait via le système de macros. Un exemple de serveur http asynchrone :

import asynchttpserver, asyncdispatch

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

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

Communauté

Nim a une communauté active sur le forum officiel auto-hébergé et auto-développé. De plus, le projet utilise un référentiel Git, un outil de suivi des bogues et un wiki hébergé par GitHub , où la communauté s'engage avec le langage.

Conventions

La première conférence Nim, NimConf, a eu lieu le 20 juin 2020. Elle s'est tenue numériquement en raison de COVID-19 , avec un appel ouvert à des discussions de contributeurs sous forme de vidéos YouTube . La conférence a commencé par des présentations linguistiques des développeurs Nim Andreas Rumpf et Dominik Picheta. Les sujets de présentation inclus parle de cadres web Nim, développement mobile , Internet des objets périphériques (IOT), et le développement de jeux , y compris un discours sur l' écriture de Nim pour Game Boy Advance . NimConf 2020 est disponible sous forme de liste de lecture YouTube.

En plus des conférences officielles, Nim a été présenté à diverses autres conventions. Une présentation sur Nim a été donnée à la O'Reilly Open Source Convention (OSCON) en 2015. Quatre conférenciers ont représenté Nim au Free and Open source Software Developers' European Meeting ( FOSDEM ) 2020, dont le créateur du langage, Andreas Rumpf.

Voir également

Les références

Liens externes