Nim (langage de programmation) - Nim (programming language)
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 |
Version stable | |
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 |
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 |
---|---|
0.10.2 | 2014-12-29 |
0.11.2 | 2015-05-04 |
0,12,0 | 2015-10-27 |
0.13.0 | 2016-01-18 |
0,14.2 | 2016-06-09 |
0,15.2 | 2016-10-23 |
0,16.0 | 2017-01-08 |
0,17.2 | 2017-09-07 |
0,18.0 | 2018-03-01 |
0,19.6 | 2019-05-13 |
0.20.2 | 2019-06-17 |
1.0.0 | 2019-09-23 |
1.0.10 | 2020-10-27 |
1.2.0 | 2020-04-03 |
1.2.12 | 2021-04-21 |
1.4.0 | 2020-10-16 |
1.4.8 | 2021-05-25 |
1.6.0 | 2021-10-19 |
Légende:
Ancienne version
Ancienne version, toujours maintenue
Dernière version
|
|
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 :
- Modula-3 : pointeurs tracés vs non tracés
- Pascal Objet : ensembles de bits de sécurité de type ( set of char ), syntaxe de l'instruction case, divers noms de types et noms de fichiers dans la bibliothèque standard
- Ada : types de sous-gamme, type distinct, variantes sûres – objets de cas
- C++ : surcharge d'opérateurs , programmation générique
- Python : Règle de hors-jeu
- Lisp : Macro système, embrasser l' AST , homoiconicité
- Oberon : marqueur d'exportation
- C# : async – wait , macros lambda
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:release
une 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:danger
tous 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:arc
mais 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 .nimble
fichiers, 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 .nim
fichier 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 result
variable 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 countdown
dont est un itérateur. Si un itérateur est omis, le compilateur tentera d'utiliser un items
ité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 func
mot-clé introduit un raccourci pour un noSideEffect
pragma.
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 var
paramè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 genType
est invoqué au moment de la compilation et un Test
type 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
, T
est 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
addTheseNumbers
ne fonctionnera alors que pour les types contenus dans le SomeNumber
type 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 twice
macro 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 printf
fonction 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:on
argument 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 channels
module 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 asyncdispatch
module, 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
- C++
- Crystal (langage de programmation)
- D (langage de programmation)
- Go (langage de programmation)
- Rust (langage de programmation)
Les références
Liens externes
- Site officiel
- Nim sur GitHub
- Informations sur Nim sur Stack Overflow
- Programmation informatique avec le langage de programmation Nim Une introduction en douceur par le Dr Stefan Salewski