D vs nim

PR’s welcome! Goal: up to date and objective comparison of features between D and nim, and 1:1 map of features to help D users learn nim and vice versa.

NOTE: tables render better (ie full width) with a chrome extension, see https://stackoverflow.com/a/49566642/1426932

NOTE: occasionally, nim code below will use the braces syntax skin to fit in 1 line

Help welcome, eg by filling in the entries with ? TODO and CHECKME, correcting wrong entries, or adding more (see also other files eg libraries.md).

See also libraries.md

features requested in latest D survey (https://rawgit.com/wilzbach/state-of-d/master/report.html) that are already supported in Nim

• From the D survey question “What language features do you miss?”, these features are supported in Nim: tuples, named arguments, string interpolation, in-place struct initialization, UFCS for local symbols, writing files at compile-time
• these are doable in library code: assert diagnostics, static break
• these are sort of available: Static inheritance

compilation time

• https://forum.nim-lang.org/t/1372
• tcc instead of clang (but not on OSX, see https://github.com/wheineman/nrpl/issues/16)

runtime performance

See also https://github.com/timotheecour/D_vs_nim/issues/11

similar code comparison

differences (not clear if pro or con)

• nim has head immutability unlike D: http://nim-by-example.github.io/types/objects/
• Indentation based syntax, but supports syntax skins

map of corresponding features

| category | D | nim | | — | — | — | | syntax:lexical | | nesting block comments | /+ +/ | #[ ]# | | documentation comments | /** */ or /++ +/ or /// | ## or ##[ ... ]## | | WYSIWYG string | `foo\nbar`, r"foo\nbar", etc. | """foo\nbar""", r"foo\nbar", etc.(?) | | end of file (useful when debugging) | __EOF__ | ? | | increment | i++ | i+=1 or inc(i) | | concatenation | ~ | & | | empty statement | {} | discard | | null pointer | null | nil | | checking for null | if (myObj is null) | if myObj == nil or if myObj.isNil | | syntax:parsing | | alias | alias T2=T; | ?; template, see https://github.com/nim-lang/Nim/issues/7090 | | type alias | alias T2=T; | type T2=T | | string mixin | mixin("1+1") | stringMixinLikeInD("1+1") with: macro stringMixinLikeInD(s: static[string]): untyped = parseStmt(s) source: https://forum.nim-lang.org/t/1779/2#19060 | | UFCS | foo(a, b), a.foo(b) | foo(a, b), a.foo(b), a.foo b, foo a, b | | expr without parenthesis | auto a=fun; calls fun | var a=fun returns fun | | UFCS expr without parenthesis | auto a=b.fun; calls fun | var a=b.fun calls fun (when b is arg, not module) | | static if .. else if .. else| static if(foo1) bar1 else if(foo2) bar2 else bar3 | when foo1: bar1 elif foo2:bar2 else:bar3 | | conditional compilation | version(OSX) | when defined(macosx) | | compile time if | static if | when | | string import | import("foo"); requires -J for security | staticRead("foo") | | public import | public import foo; | import foo; export foo; | | static import | static import foo; | from foo import nil | | package fully qualified access | pkg.mod.symbol(); | symbol() (pkg.mod.symbol illegal) | | syntax:exceptions | | scope guards | scope(exit) foo, scope(success) foo, scope(failure) foo, | defer: foo, ? , ? ; see also https://forum.nim-lang.org/t/141/1#23104 | | try throw catch finally | try{throw new Exception("bar");}
catch(Exception e) {writeln(e);}
finally {} | try: raise newException(IOError, "test exception")
except IOError: (let e = (ref IOError)(getCurrentException()); echo e[])
finally: discard | | **syntax:array** | | static array literal | `int[2] a = [1,2];` | `var a = [1,2]` | | dynamic array literal | `auto a = [1,2];` | `var a = @[1,2]` | | dynamic array create | `auto a = new int[2];` | `var a = newSeq[int](2)` | | empty dynamic array | `auto a = [];` | `var a:seq[int] = @[]` | | indexing slice of a | `a[1..$], a[1..$-1], a[1..3]` | `a[1..^1], a[1..^2], a[1..<3]` | | length | `a.length;` | `a.len` | | **types** | | initial value of type | `T.init` (known at CT) | ? | | type of | `typeof(expr)` | `expr.type` | | type name | `T.stringof` (builtin) | `T.name` (import typetraits) | | class | `class A : B` | `type A = ref object of B` | | struct | `struct A` | `type A = object` | | float: 32, 64 bit | float, double | float32, float(float64) | | pointer sized int, uint | ptrdiff_t, size_t | int, uint | | sized ints | byte, short, int, long | int8, int16, int32, int64 | | char types | char, wchar, dchar | ?,?,? | | **functions** | | delegates | `int delegate(int, int)` | `proc (a, b: int): int {.closure.}` | | **decl** | | variable decl | `auto a=foo;` | `var a=foo` | | immutable decl | `immutable foo=bar;` | `let foo=bar` | | compile time decl | `enum foo=bar;` | `const foo=bar` | | shared static | `__gshared a = 0;` | `var a {.global.} = 0` ? | | static TLS | `static a = 0;` | `var a {.threadvar.} : int` | | ref return | `auto ref fun(ref A a){ return a.x;}` | `proc fun(a:var A):var a.x.type = return a.x` | | skip initialization | `T a = void;` | `var a {.noInit.}: T` | | **attributes** | | purity | `pure` | `{.noSideEffect.}` | | nothrow | `nothrow` | `{.raises: [].}` | | safe | `@safe` | ? | | GC free | `@nogc` | ? | | lockfree | ? | `{.locks:0.}` | | **language** | | unit tests | `unittest{stmt}` | https://nim-lang.org/docs/unittest.html | | constructor | `T(args)` | ad-hoc: `newT(args)`, but see https://github.com/nim-lang/Nim/issues/7474 | | **semantics** | | float.init | NaN | 0 | | file | `__FILE__` | instantiationInfo; limitation: doesn't work for function caller, cf https://github.com/nim-lang/Nim/issues/7406 | | **traits** | | does expr compile | `__traits(compiles, expr)` | `compiles(expr)` | | get fields | `T.tupleof` | `x.fields` | | **metaprogramming** | | static assert | `static assert(foo);` | `static: assert foo` | | **library** | | universal type conversion | a.to!T | no: https://github.com/nim-lang/Nim/issues/7430 | | option/maybe type | [`Nullable`](https://dlang.org/phobos/std_typecons.html#.Nullable) in `std.typecons` | [`Option`](https://nim-lang.org/docs/options.html) in the `options` module | | path append | a.buildPath(b) | a / b ; does right thing on windows; NOTE: if b is absolute, buildPath returns b unlike nim | | **cmd line** | | custom define | -version=foo | --define:foo or --define:foo=bar | | **resources** | | tutorials | https://tour.dlang.org/ | https://nim-lang.org/docs/tut1.html | | **tools** | | caching compiler | rdmd | nim (compiles dependencies; only compiles changed file by default); https://github.com/Jeff-Ciesielski/nimr (subset of functionality) | | find declaration | dscanner --declaration | nimgrep (but no declaration search, cf https://github.com/nim-lang/Nim/issues/7419) | | fix code | dfix | nimfix | | package manager | dub | nimble | | install specific compiler versions | digger | choosenim |

See also libraries.md

links

• https://www.slant.co/versus/118/395/~d_vs_nim
• https://forum.nim-lang.org/t/1779 Nim vs D
• https://forum.dlang.org/post/mailman.1536.1428946094.3111.digitalmars-d@puremagic.com D vs nim
• http://gradha.github.io/articles/2015/02/goodbye-nim-and-good-luck.html
• https://www.quora.com/Of-the-emerging-systems-languages-Rust-D-Go-and-Nim-which-is-the-strongest-language-and-why
• https://github.com/kostya/benchmarks
• https://digitalmars.com/d/archives/digitalmars/D/D_and_Nim_251571.html
• https://forum.nim-lang.org/t/1983#12391 A few questions about Nim

nim questions (besides entries marked above with ?)

• does it have dfmt equivalent?

• instead of newSeq could we write new!Seq or new[Seq] or anything else that’s generic and doesn’t pollute namespace?

• how to use dirty templates/macros that require an import? eg:

  template foo*() {.dirty.} { #[want: import os ]# let programName = getAppFilename() }
  

• how to compose arbitrary ranges/iterators in Nim?

• how to define a slice of type T from ptr + length? cf https://github.com/nim-lang/Nim/issues/5437 feature-request pointer size pair, (openArray as value) #5437

nim questions (answered)

• are there real immutable variables in nim ? A: https://www.reddit.com/r/nim/comments/2w32oi/immutability_in_nim/
• how to specify immutable inside for(foo in bar) ? A: immutability depends on iterator and by default iterators return immutable values.

  var a = @[1, 2, 3, 4]
  for item in a: item += 5  # compile-time error
  for item in mitems(a):  item += 5  # ok
  

• how to search for symbols fooBar given that nim allows foobar fooBar foo_bar etc? A: nimgrep; also: Nim provides “nimsuggest” that can be used for vim, emacs, vscode, atom that autocompletes

• how to use global variables? (cf http://gradha.github.io/articles/2015/02/goodbye-nim-and-good-luck.html) A: Non-const global vars are not allowed in proc tagged noSideEffects and care must be used if accessed from multiple threads but there is nothing special about them otherwise.

• can we modify a slice of an immutable array declared by ‘let’? A: Slicing doesn’t return a var T for let arrays so you can’t. Note that immutability for stack objects/array/types is deep but for ref/ptr types it is shallow, it means that the memory address pointed to cannot be modified but the content can.

• is there a robust way to write complex nim functions as a one liner (eg, for use in 1 line docs, in REPL etc); ideally by replacing indentation with braces A: (st1; st2; st3), or undocumented braces syntax skin: ```nim #? braces

proc main() { echo “Hello” }

when (isMainModule) { main() } ```

no longer valid points

https://forum.nim-lang.org/t/1779/1#11314 => dmd backend license was changed recently