The Nim development team cooperates with OpenAI in order to fight climate change

Ass shit

Nim v2.0.0 RC2 is out

So is the situation with exceptions going to stay the same?

Why Svelte is far superior than React (Karax)

I would say the problem is really the unavailability of closure iterators. It's really just something that should not be the case, a language feature not implemented in a backend. The surprise is caused by a temporary lack of solutions to this problem, at which point it's good to be wary of such

Why Svelte is far superior than React (Karax)

I tried to do this a while ago but in a way that attempted to keep the old behavior under a `jsInner` calling convention and I couldn't get it to work, interested if anyone else can do it

Do you miss these compact syntaxes?

The early comments on that issue are referring to old edits Nested tuple unpacking is not easy because the current underlying implementation of tuple unpacking is extremely weird and hard to adapt basically any change to. Also any attempt at fixing it would probably become some generalization o

Do you miss these compact syntaxes?

Postfix if, unless keyword etc are all borrowed from Perl where code was supposed to look like English, like `say "this" if true` This doesn't really work otherwise imo and `if increment: count += 1` is one of the cleanest ways to write what it does in any language I've seen

Any way to implement `=` in the follow exampĺe?

> Can i raise an exception when create a variable with zero length e.g. > PasString[0] ? You can define it as `PasString*[n: static range[1..255]]` however unfortunately this does not create an error on `PasString[0]`. > Is there any way to change operator `<<` by `=` ? The actual operator `=`

Trying to understand: is it better if IndexDefect is CatchableError or not

Didn't say anything before in lieu of being unproductive but I never understood removing bare `except:` when it was an established feature for basically the entirety of the language's existence and it was also the most concise way of expressing the desired behavior; or why Defect was still an Ex

Get equivalent code with expanded templates/macros

`var a {.noinit.}: int` after turning into "typed" AST simplifies into `var a: int` where `a` is a symbol object with the `noinit` information embedded. However this is changed in the [development version](https://github.com/nim-lang/Nim/commit/de4b0346bdafab6c38b77d430d0e83f95da0582c) where th

Example of simple parser?

Well what I thought first was `if s[i] != '(': someError()` and the simplest way to error that came to mind was `assert false`

Example of simple parser?

This is the pattern I usually go for for dead simple parsers. Here is an example for an extremely limited version of S-expressions with only lists, integers and atoms: type SexpKind = enum List, Integer, Atom Sexp = object case kind: SexpKind of L

Fstring and Split to Variable Error

`let splitData = mydata.split("@", 2) let (newname, newsize) = (splitData[0], splitData[1]) ` Run

Template in template: should this work?

Well for one the signature of `bar` in your example is `(string, untyped)` and you are only giving the `untyped` parameter. But beyond that this really depends on the DSL at hand. For macros that take `untyped` parameters (seemingly like `buildHtml`) template evaluation will not necessarily be

Overflow Checks

> I am also reticent to use Natural types, since you can not convert back and > forth with integers and most functions are written for integers in libraries. Not true? let a: int = 1 let b: Natural = a let c: int = b echo (a, b, c) Run The problem might be

iterators composition

Came up with this on the forum a while ago:

import module just for comptime use

This is because of the bad API of the marshal module. The actual code in the marshal module only works on native backends, but there are hidden hooks for the VM in `$$` and `to`. If I had to guess, these hooks should be in a separate module and not conflated with the native `$$` and `to` in `mar

why use nim over c#?

No idea how learning C++ is "highly discouraged" lol Before addressing your concerns I would say comparing to C# and C++ the biggest problem Nim has is that it's a smaller language. There are less and less mature libraries and frameworks, you will get less support for your problems, etc etc. Th

Variable Declaration in Templates

It works if all the template parameters are not `untyped` and the template isn't generic. template declare_var(varName: untyped, var_type: untyped) = var varName {.inject.}: var_type proc gen[T]() = declare_var(a, int) a = a + 5 declare_var(c, T)

what's with deepCopy?

No, you have to redefine it in a way that recurses. proc deepCopy[T: ptr | ref](dst: var T, src: T) = deepCopy(dst[], src[]) proc deepCopy[T: Ordinal | string | cstring | proc | set](dst: var T, src: T) = dst = src proc deepCopy[I, T](dst: var array[I, T

大家好,有没有类似foldlIt的功能

You need to do this: import sequtils type TWPT* = object x*: int y*: int var pts = @[TWPT(x: 0, y: 0), TWPT(x: 1, y: 1)] echo foldl(pts, a + b.x, 0) Run

How to ref value types in tables?

Maybe a more user-friendly API for `withValue` could be `withValue(t: var Table[A, B], key: A, p: proc (item: var B)): bool` where `true` is returned if `key` exists and `p(t[key])` is called, otherwise `false` is returned. Then you can check for `if not resultOfWithValue` for behavior it doesn'

How to ref value types in tables?

There is [withValue](https://nim-lang.org/docs/tables.html#withValue.t%2CTable%5BA%2CB%5D%2CA%2Cuntyped%2Cuntyped%2Cuntyped) but it's a bit ugly

Problem with object constructor in macro

If `(foo: int)` is meant to be a function signature you can do `mymacro do (foo: int):` and not have to construct a parameter list yourself.

Unique ID's for types?

There is [signatureHash](https://nim-lang.org/docs/macros.html#signatureHash%2CNimNode) and [symBodyHash](https://nim-lang.org/docs/macros.html#symBodyHash%2CNimNode), though apparently these are not good enough for all cases and there was [a PR](https://github.com/nim-lang/Nim/pull/13305) to a

How to wrap a JavaScript function that takes variable arguments?

There is the [varargs pragma](https://nim-lang.org/docs/manual.html#foreign-function-interface-varargs-pragma) for C but I don't know if it works for JS

`--os:standalone` gives `Error: system module needs: getCurrentException`

Maybe also `--panics:on`?

Multilungual Nimdoc

I have no idea if this works, but as an idea maybe you could do: proc foo*() = when defined(englishDocs): ## English docs here when defined(chineseDocs): ## Chinese docs here Run then build docs with `nim doc -d:englishDocs foo.nim` for Engli

Illformed AST?

The error message you should have gotten is "expected colon-separated entry in table expression but got `"ceil"`" or something. It's so easy to improve these error messages, I don't know why it's such a rare area of contribution

Official Fediverse (e.g. Mastodon) account?

Sri Lankan law is right around the corner people! Seriously though this doesn't seem like a big deal, Nim twitter/social media seems like it would just be announcements or whatever and wouldn't be interactive, so you can easily automate this or make a custom client that sends to Twitter, Mastod

A seasoned programmer's take on Nim's docs

The doc generation actually supports [RST and markdown at the same time](http://nim-lang.github.io/Nim/markdown_rst.html).

Array concatenation

Oh, I didn't expect it to, I thought the error would only show up when trying to call it.

Array concatenation

The real reason is generics don't work like the code sample above for arrays, instead they have a range type, possibly an enum as the first type and this would have to be ignored in any implementation in favor of `0 ..< a.len + b.len`

Nim v2: what would you change?

If you just want object fields, you don't need extra indentation, you can use something like: template a: untyped = self.a Run And you can have a macro that generates these automatically on the same indentation level.

A seasoned programmer's take on Nim's docs

> I have the impression people here feel superior for using or creating Nim and > look at others as not worth having them in the boat. I think the main sentiment is that people see Nim as a fragile baby that either needs to be defended from any attackers or needs every possible weak point to be

Alternative to closure iterator that works in JS

Could use an iterator pattern, this is what languages without iterators do (but using objects instead of closure variables) import options type Database*[R] = object ## A bunch of arbitrary data rows: seq[R] View*[V] = object ## A v

A seasoned programmer's take on Nim's docs

I don't know how much documentation and library support it would ever take for Nim to be worth the hassle to some people. Not to be defeatist but outside factors are always going to be a huge contributor to how little languages are used despite how much people like them. That's why it's not goo

Nim book in Japanese

Languages like Japanese and Chinese are more different from English (the language most Nim resources are in) than other languages Nim users tend to speak, so they warrant their own resources more. Otherwise relative to population I don't think there's an exceptional amount of users from anywhere

What Nim version introduces "except CatchableError" ?

Something like 0.19.0. Note that this isn't a complete alternative to `except:` and something might be changed about this warning

A serious documentation for Nim

Anyone do anything challenge P.S. the manual is more of a specification than a learning resource. It's just more complete than existing learning resources

Did someone recreated Nim with Zig? \s

This doesn't look like either, for starters it's dynamic

Roadmap 2023

For the record about "working" callOperator all bugs related to callOperator were fixed recently

Parallel Fibonacci

Probably caused by `exceptions:goto`, this is the output of `fib` without arc on 1.6.10: N_LIB_PRIVATE N_NIMCALL(NI, fib)(NI n) { NI result; result = (NI)0; { if (!(n < ((NI) 2))) goto LA3_; result = n;

The meaning of `do`

There are 2 versions of `do`, one with nothing between do and : (`do:`), and one with routine-like features, such as `do (param) {.pragma.} -> returnType:`. The `do:` version is like `:` in that it represents a [statement list argument](https://nim-lang.github.io/Nim/manual.html#macros-postminus

try-catch misbehavior

> Does it mean - that we have to check range manually? Yes, in cases where it is reasonably possible that the index may be out of range. The difference with stuff like `KeyError` is that when we search a table for a key and don't find it, there's no fast "default" behavior to fall back on, so

Creating const in a macro fails in 1.9.1

I think the new behavior is correct here. `const ALL_METADATA = allInfo` evaluates before any changes to `allInfo`, so the value of ALL_METADATA is locked in. You can use something like template saveMetadata() = const ALL_METADATA {.inject.} = allInfo Run and c

Create a ref to a C allocated object to manage its memory

I expected there to be a library that does it but couldn't find one, though it should be easy to do, something like: type Array[T] = object len: int data: ptr UncheckedArray[T] proc `=destroy`[T](x: var Array[T]) = if not x.data.isNil: for i in 0 ..

Strange error: single character string constants

If you remove the `$` from `myChar: char = $mydata[myRow][myCol]` and convert the constants to chars as well, it should work. Thanks for giving information about this issue, the confusing error message should be fixed with

Strange error: single character string constants

Again, the error is likely happening in the context where you _use_ the constant `SOUTH`, Nim is just giving incorrect line information for the error. We could fix this issue but it would be nice to know the exact context

Strange error: single character string constants

Pretty sure what happened is constant folding folded the constant into a string where a char was expected, but the line information of the original constant was kept so the error showed at the constant definition. So I agree this is probably misleading error information, but this is speculation

Javascript backend and implicit cstring conversions

Even if it's not unsafe, it could affect performance to convert Nim strings to JS strings, and it's better if this is explicitly shown. In general to prevent too many cstring conversions, you can try to work directly on cstring. Sometimes you may need to `importjs` some JS string methods to mak

Question about the let statement

Mutability is allowed for `let` values if they are behind `ref`/`ptr`. In neo, Vector/Matrix are both `ref object`s, and their `[]=` does not require that they are `var Vector`/`var Matrix` (which they could, in which case this code would not compile).

Strange error: single character string constants

Is the error really in the code that you gave? What is line 25?

Nim version 2.0 RC1

I'm guessing this post only has the breaking changes from the changelog because it's a release candidate. But then idk why object field default values is there because it shouldn't break any existing code.

Nim version 2.0 RC1

Changelog entries are usually added by people who make the changes and sometimes these people don't know much English. It's fine to rewrite these entries. I have no idea what the contentLength part is trying to say. >From my understanding the nimPreviewDotLikeOps feature is being given up on >f

How to move variable to other thread

These were tested on 1.6.0, unsure if the same will work on later versions. The global context makes it so the destruction of `myStr` is delayed until program exit and `var theStr = ..` makes a copy instead. Wrapping it in a proc gives the result you expect. import locks type

Windows Defender detected Trojan.AndroidOS/Multiverze in Nim-1.6.10_64.zip

Again, the gist of it is, people have used Nim to make malware, so some antiviruses automatically detect Nim programs (including Nim itself) and flag them as malware. We should really have a blog post about this

Looking for resources about more complex generics, comptime type construction, etc.

The reason `array[X.N, int]` doesn't work is because of the quirkiness of the array type, `array[0 .. X.N-1, int]` works.

Splat operator implementation with macros

That is fixed in devel

Splat operator implementation with macros

Term rewriting macros work on checked AST IIRC

Transpile Nim to Dart/Flutter?

https://github.com/HaxeFoundation/haxe/issues/7576

JS compiler produces a large file (with -d:release) ?

Yeah I don't see how strutils could be better than strformat here, from what I know strformat handles the interpolation at compile time while strutils would have to handle it at runtime.

JS compiler produces a large file (with -d:release) ?

This has been talked about to death so it would be better if you gave concrete code Yes there are runtime checks because JS barely has them (as with C), JS hides errors behind `undefined` and `NaN` and Nim checks for overflows and Nim has types like

Nim Static linking OpenSSL issue with fork()

Is there is a difference when using Nim 1.6.8 vs 1.6.10?

BigNum and BigInt timings on the Pollard Rho algorithm

Also (more popular) and

Nimble is unable to download and install

I would guess maybe antivirus blocking internet access?

Advent of Nim 2022

Wasn't backported because it's a breaking change IIRC but it theoretically could be

Best practices for initializing objects?

To prevent `T()` initialization you could have a private field and annotate it with `{.requiresInit.}` or `{.requiredInit.}`, I forgot the name.

How should system library support be structured?

What is the include file support? Does it parse `# included in abc.nim` or something?

noob: getch giving AssertionDefect etc

readConsoleInput is wrapped from Windows: > If the function succeeds, the return value is nonzero. > If the function > fails, the return value is zero. To get extended error information, call > GetLastError. So there was an e

A new way for Nim to shine ? Faster than NodeJS interpreted Nim, taking advantage of declared types

I'll corroborate that Nim compiles to JS unreasonably fast compared to native. I've even used the JS backend for easy debugging. Unfortunately it's not super fun for scripting as a substantial portion of Node.js libraries would have to be wrapped to deal with files etc and even then you might n

Nim HashSets operators

I tried it myself and there is another problem here. The `intersection` proc (which `*` is sugar for) is generic and dynamically tries to use the symbol `items`, which isn't imported here so can't get resolved. I would guess this is specific to the implicit `items` iterator, and I vaguely rememb

Nim HashSets operators

Well `echo (b * c)` gets transformed to `echo $(b * c)` so you would have to import `$` as well, but it says `items` here, making me guess this picks a `$` implementation from `system` instead that uses `items`. What is the file/line information before `Error: type mismatch`?

Get time at compile-time

`CompileDate` is also directly above it

Why is Rust faster than Nim in this CSV parsing example?

What was the Nim version? I'm guessing it's devel since otherwise mine would be fairly slower. Also this is something people tend to miss but clang instead of gcc might be faster. It's the same compiler architecture as Rust which is faster without memfiles.

Why is Rust faster than Nim in this CSV parsing example?

The use of view types is tied to the implementation of `split` and `parseInt` which is why no one has shown it. You have to rewrite them with changed type signatures (which `parseutils.parseInt` already has on devel, so we just make a shim for it): import std/parseutils {.

Forum subscription feature

Not that I follow this stuff but the person who I think is responsible for hosting the forum seems to be a little distant from Nim due to some personal differences. I don't blame them for this but it might be a problem to have less maintainers.

Why is Rust faster than Nim in this CSV parsing example?

To simplify the answers, the biggest differences are: 1. `splitLines` returns full `string`s, which are copied substrings from the original string vs. something like `lent string` or `openarray[char]` which would be equivalent to what Rust does 2. `sequtils` procs like `mapIt` do not produce

Upcoming standard library changes

The intention was to keep the modules in the standard library for a while with a warning saying "this module is deprecated, use the nimble package instead", but they were removed due to what I think might have been a technical reason. The system module splits are really hard to warn about with N

Upcoming standard library changes

Moved out packages (all seem to be on nimble): * * * *

Upcoming standard library changes

Before starting: I am not part of the Nim team, I'm just following along and want people to have minimal issues the same way I would want for myself. See the original discussion for a more reliable source of information. In light of the new Nim version that has been in development for more than

Do you have to use 'ref' for the field types within ref objects?

I'm guessing "Nim automatically chooses to pass by ref or by copy" doesn't mean "Nim automatically changes between value/reference type semantics".

Plans for improving tagged enum (ADT) syntax?

My view is that in general people shouldn't use "raw" object variants in important code. They should either stick to some guidelines for using them (this is not a rare thing in code) or wrap around those guidelines with macros. As an example of a guideline: each branch must have a single field,

Plans for improving tagged enum (ADT) syntax?

Before someone gives the stock answer of "you can just use macros": I agree that this stuff should be easier to write. And there is no popular or standard macro library that lets you do this, despite not being very hard to implement. However the existing way of doing it in the language should re

Choosing Nim out of a crowded market for systems programming languages

This seems way too opinionated to post on the Nim website IMO

Type macro returning a transformed type def + other definitions

The only limitation of StmtListType I've noticed is that converters defined in it do not get called. Ideally in the future we have some kind of lazy symbol loading/cyclic dependency mechanism so type sections can be broken up into linear statements, and this kind of hackiness is not needed. In

Nim 1.6.10 released

No repors of issues on the forum in 24 hours is a good sign

Nim Table, type iterators and lent type

The segfault was unrelated to `iterable[T]` (as much as people rag on this feature), it was due to the hackiness of defining closure iterators inside the `for` statement iterator call. This works: template `!`[T](it: iterable[T]): untyped = (iterator(): T = for i in it

Nim Table, type iterators and lent type

There is kind of a way to compose iterators. template `!`[T](it: iterable[T]): untyped = (iterator(): T = for i in it: yield i) iterator double(it: iterator(): int): int = for i in it(): yield 2 * i for i in double(!double(!(1..3))):

Small Nim js fib benchmark

Actually I think the closest comparison is with languages like Haxe or Scala or Kotlin that are high level and support multiple backends including both native and JS. Someone [made a benchmark of these languages](https://imsky.co/notes/compiling-11-languages-to-javascript/) but annoyingly it do

How to inject member identifiers in generics

With a simple macro you can work with the string "value1" and convert it to an identifier node to be used in `offsetOf`. type TestObj = object text: string value1: int value2: int type TestGeneric[T; MEMBER: static string] = object

Procedure to remove modules from stdlib?

See for some discussion about this Nothing is standard so far. There is even a "parsesql" nimble package that is a diverged fork of the stdlib parsesql module, without the original commit history. And the stdlib parsesql isn't planned for removal or

wrapping c++ function - cannot instantiate 'T2'

Might be related to

can Parsing Expression Grammar mechanisms replace the absence of reader macros in Nim??

I haven't heard of string macros in Julia so I looked it up and based on [this](https://stackoverflow.com/questions/26600143/why-do-string-macros-in-julia-use) Nim does have something similar with [generalized raw string literals](https://nim-lang.org/docs/manual.html#lexical-analysis-generalize

nim name origin?

> Different dialects would emerge due to its macro system. It's inevitable that people will use different sugar/macro libraries that do the same thing. Currently to me it looks like people are just not using sugar libraries. I'm not sure if this is because people aren't used to macros or becaus

kotlin style scope macros?

There is no "class scope" in Nim like in Java and Kotlin, but you can mimic it by declaring equivalent routines inside a new scope: type Foo = object x: int proc incr(foo: var Foo) = inc foo.x template withFoo(body) = block: # new scope var foo =

Looping Assertions

Not true, they are only turned off in danger mode. Maybe you can define your own iterator that does `push checks: off` for the element access.

How to import a C array of unknown size?

See also [codegenDecl](https://nim-lang.org/docs/manual.html#implementation-specific-pragmas-codegendecl-pragma).

Question about patterns

`(~x){y}` seems to mean "capture `y` as long as it is not `x`". So template foo{x = (~x){y}}(x, y: untyped) = echo "got ", astToStr(x), " and ", astToStr(y) var a = 1 var b = 2 a = b a = a b = a b = b Run outputs got a an

Tips on how to avoid Nim pointer instability bugs?

This gives an assertion error on , unless you are using the development version. If you change `Foo` to `object` instead of `ref object` then assertion passes as expected. If it persists, I'm guessing it might be a C compiler issue. But I'm not sure.

Has 'IsNullOrEmpty' been deprecated?

It's `isNilOrEmpty`. It was deprecated and later on removed. It's in the [1.0.6 docs](https://nim-lang.org/1.0.6/strutils.html#isNilOrEmpty%2Cstring) as a deprecated proc but not in the 1.2.0 docs. Also `isNilOrWhitespace` was deprecated in the [1.2 docs](https://nim-lang.org/1.2.0/strutils.htm

  1   2   3   4   >