Nim (programming language)

Nim

The Nim crown logo
Paradigms	Multi-paradigm: compiled, concurrent, Procedural, Imperative, Functional, Object-oriented
Designed by	Andreas Rumpf
First appeared	2008 (2008)
Preview release	0.20.0 / 6 June 2019 (2019-06-06)
Typing discipline	Static, strong, inferred, structural
Platform	IA-32, x86-64
OS	Cross-platform
License	MIT
Filename extensions	.nim
Website	nim-lang.org
Influenced by
Ada, Modula-3, Lisp, C++, Object Pascal, Python, Oberon

Search Nim (programming language) on Amazon.

Nim (formerly named Nimrod) is an imperative, general-purpose, multi-paradigm, statically typed, systems, compiled programming language designed and developed by Andreas Rumpf. It is designed to be "efficient, expressive, and elegant", supporting metaprogramming, functional, message passing, procedural, and object-oriented programming styles by providing several features such as compile time code generation, algebraic data types, a foreign function interface (FFI) with C and C++, and compiling to C, C++, Objective-C, and JavaScript.

Description

Nim is statically typed. It supports compile-time metaprogramming features such as syntactic macros and term rewriting macros. Term rewriting macros enable library implementations of common data structures such as bignums and matrices to be implemented efficiently, as if they were builtin language facilities. Iterators are supported and can be used as first class entities, as can functions, allowing for the use of functional programming methods. Object-oriented programming is supported by inheritance and multiple dispatch. Functions can be generic and can also be overloaded, and generics are further enhanced by the support for type classes. Operator overloading is also supported. Nim includes tunable automatic garbage collection based on deferred reference counting with cycle detection, which can be turned off altogether. In 2014, Andrew Binstock (editor-in-chief of Dr. Dobb's Journal) said:

"Nimrod [former name] ... presents a most original design that straddles Pascal and Python and compiles to C code or JavaScript."

Today, Nim compiles to C, C++, JavaScript, and Objective-C. The goal for Nim is to be as fast as C, as expressive as Python, and as extensive as Lisp.

History

Version	Release date
Old version, no longer supported: 0.10.2	2014-12-29
Old version, no longer supported: 0.11.2	2015-05-04
Old version, no longer supported: 0.12.0	2015-10-27
Old version, no longer supported: 0.13.0	2016-01-18
Old version, no longer supported: 0.14.2	2016-06-09
Old version, no longer supported: 0.15.2	2016-10-23
Old version, no longer supported: 0.16.0	2017-01-08
Old version, no longer supported: 0.17.2	2017-09-77
Old version, no longer supported: 0.18.0	2018-03-01
Old version, no longer supported: 0.19.6	2019-05-13
Current stable version: 0.20.0	2019-06-06
Legend: Old version Older version, still supported Latest version Latest preview version Future release
For each 0.x branch, only the latest point release is listed.

Nim's initial development was started in 2006 by Andreas Rumpf and the project was made public in 2008. The first version of the Nim compiler was written in Pascal using the Free Pascal compiler. In 2008, a version of the compiler written in Nim was released. The compiler is free and open-source software and is being developed by a community of volunteers working with Andreas Rumpf. The language was officially renamed from Nimrod to Nim with the release of version 0.10.2 in December 2014.

Language design

Syntax

The syntax of Nim highly resembles that of Python. Code blocks and nesting statements are identified through use of white-space according to the offside-rule, and many keywords are identical to their Python equivalents, which are mostly English keywords, where other programming languages use punctuation. Even though Nim supports indentation based syntax like Python, it introduced flexibility whereby one could break statement with a comma or binary operator to the next line. Nim also supports user-defined operators.

Nim is almost fully style-insensitive; two identifiers are considered equal if they only differ by capitalization and underscores as long as the first characters are identical.

Others

In details, it is influenced by:

• Modula-3: traced vs untraced pointers
• Object Pascal: type safe bit sets (set of char), case statement syntax, various type names and filenames in the standard library
• Ada: subrange types, distinct type, safe variants – case objects
• C++: operator overloading, generic programming
• Python: Off-side rule
• Lisp: Macro system, embrace the AST, homoiconicity
• Oberon: export marker
• C#: async – await, lambda macros
• Go: defer

Also, Nim supports a Uniform Function Call Syntax (UFCS) and identifier equality.

Compiler

The Nim compiler emits optimized C code and defers compiling to an external compiler to leverage their optimizing and portability abilities. Many compilers are supported including Clang and GNU Compiler Collection (GCC). The compiler can also emit C++, Objective-C, and JavaScript code to allow easy interfacing with application programming interfaces (APIs) written in those languages. This allows writing applications for iOS and Android.

The Nim compiler is self-hosting, meaning it is written in the Nim language.

Tools

Nimble

Nimble is the standard package manager used by Nim to package Nim modules, it was initially developed by Dominik Picheta who is also a core Nim developer. Newer releases of Nim come with Nimble included.

Nimble packages are defined by .nimble files, which contain information about the package version, author, license, description, dependencies and more. These files support a limited subset of the Nim syntax called NimScript, with the main limitation being the access to the FFI. These scripts allow changing of test procedure, or for custom tasks to be written.

The list of packages is stored in a JSON file which is freely accessible in the nim-lang/packages repository on GitHub. This JSON file provides Nimble with a mapping between the names of packages and their Git or Mercurial repository URLs.

Nimble Command-line tool

Because Nimble comes with the Nim compiler, it is possible to test the Nimble environment by running: nimble -v This command will reveal the version number, the compilation date and time and git hash of nimble. Nimble utilizes git, which must be available for Nimble to function well. The Nimble command-line is used as interface for installing, removing (uninstalling), and upgrading/patching module packages.

c2nim

c2nim is a transcompiler/transpiler that helps to generate new bindings by translating ANSI C code to Nim code. The output is human-readable Nim code that is meant to be tweaked by hand after the translation process.

Choosenim

Choosenim was developed by Dominik Picheta as tool that enables a developer to have multiple versions of Nim compile in his/her machine. Choosenim installs Nim from official downloads and sources, enabling easy switching between stable and development compilers.

Nimfix

Nimfix is a tool that helps to convert old-style Nimrod code to Nim code. Nimfix is currently beta-quality.

pas2nim

pas2nim is a tool to translate Object Pascal wrappers to Nim code. It was used to translate the original Pascal sources of the Nim compiler. Only what maps easily to Nim is supported. Free Pascal, Delphi-style classes, and some other features are unsupported. At this time, development and maintenance is mostly stalled.

py2nim

py2nim is a tool used for transpiling Python code into idiomatic Nim code. Development is active, with plans to extend the amount of Python code that can be fully translated into Nim.

Libraries

A Nim program can use any library which can be used in a C and C++ program. Language bindings exist for many libraries, including GTK+, SDL2, Cairo, OpenGL, WinAPI, zlib, libzip, OpenSSL and cURL. Nim works with PostgreSQL, MySQL and SQLite databases. Nim can interface with the Lua and Python interpreter.

Examples

The following code examples are valid as of Nim 0.19.0. and its subsequent releases. Because Nim has not had its 1.0 release, syntax and semantics may change in later versions.

Hello world

The "Hello, World!" program in Nim:

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

Another version of coding "Hello World" is...

stdout.write("Hello, world!")
## This is documentation single line comment

Reversing a string

A simple demonstration showing many of Nim's features.

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

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

One of the more exotic features is the implicit result variable: every procedure in Nim with a non-void return type has an implicit result variable that represents the value that will be returned. In the for loop we see an invocation of countdown which is an iterator. If an iterator is omitted, the compiler will attempt to use an items iterator, if one is defined for the type specified in the are run to be overridden oloop.

Stropping

Stropping is a method to mark explicitly a letter sequence for a special purpose. Stropping is not used in most modern languages. Instead, keywords are reserved words and cannot be used as identifiers for variables or functions. Stropping allows the same letter sequence to be used both as a keyword and as an identifier, and simplifies parsing. For example, allowing a variable named if without clashing with the keyword if. In Nim, this is achieved via backticks, allowing any reserved word to be used as an identifier.

var `type`: int

Programming Paradigms

Metaprogramming

Template

This is an example of metaprogramming in Nim using its template facilities.

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

The genType is invoked at compile-time and a Test type is created.

Foreign Function Interface (FFI)

Nim's FFI is used to call functions written in the other programming languages that it can compile to. This means that libraries written in C, C++, Objective-C and JavaScript can be used in Nim source code. One should be aware that both JavaScript and C, C++, or Objective-C libraries cannot be combined in the same program, as the are not as compatible with JavaScript as they are with each other. Both C++ and Objective-C are based on and compatible with C, but JavaScript is incompatible, as a dynamic, client-side web-based language.

The following program demonstrates the ease with which extant C code can be used directly in Nim.

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

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

In this code the printf function is imported into Nim and then used.

Community

The project has a bug tracker and wiki hosted by GitHub, and a forum. A presentation on Nim was given at O'Reilly Open Source Convention (OSCON) in 2015.

See also

Other articles of the topic Computer programming : Programmer, Software developer, Software release life cycle
Some use of "" in your query was not closed by a matching "".Some use of "" in your query was not closed by a matching "".

• Crystal (programming language)
• D (programming language)
• Go (programming language)
• Rust (programming language)
• UFCS, a feature supported by Nim

External links

• Nim on GitHub
• Information about Nim on Stack Overflow

This article "Nim (programming language)" is from Wikipedia. The list of its authors can be seen in its historical and/or the page Edithistory:Nim (programming language). Articles copied from Draft Namespace on Wikipedia could be seen on the Draft Namespace of Wikipedia and not main one.

This page exists already on Wikipedia.

📰 Article(s) of the same category(ies)

• Chainge
• Zippr
• CipherShed
• CoyIM
• ZenCash (cryptocurrency)
• HQ9+
• Dframe Framework

---