Re: [C backend] On const qualifier again

[foldl]

I won't write `const` everywhere. If I see a parameter `a_type_t *p` in a 
function is decorated with `const`, I am happy because its side effects seem to 
be _under control_.

> We can simply make all parameters `const` since that's Nim semantics anyway.

I can't understand this. The first parameter of `nimCopyMem` can't be `const` 
obviously.

Re: [C backend] On const qualifier again

[Araq]

We can simply make all parameters `const` since that's Nim semantics anyway. 
But I doubt it will work better.

> Oh, by the way, in C, I like to use const whenever possible.

Good for you, but there is no evidence whatsoever that the cost of writing 
`const` everywhere (and the cognitive load that it implies!) prevents enough 
bugs to be a worth-while trade-off. 

How to run nim code in Atom editor

[kcvinu]

Hi all, I am struggling to find a way to run my nim code in Atom editor. I've 
installed the nim extension, so i can see colors in my code, the linter is also 
working perfectly. But i find its quite hard for me to run my code. In VS code, 
it was very easy. For nim files, we can add our cmd arguments and use the 
$FileName or $FullFileName variables. But there is no such variables in Atom.

[C backend] On const qualifier again

[foldl]

Hi all,

There are already lots of discussions on this. I find that we need to discuss 
it further in a generalized manner: interfacing with C without a `const` 
equivalent qualifier.

  * **Case 1: Global constant values**




const int value[] = {1,2,3};


Run

This has been addressed in RFC 
[#12216](https://github.com/nim-lang/Nim/issues/12216). With PR 
[#12799](https://github.com/nim-lang/Nim/pull/12799) & 
[12824](https://github.com/nim-lang/Nim/pull/12824), below code results in the 
same C code:


let value = [1,2,3]


Run

  * **Case 2: Generate a C function with ``const`` params**



This is impossible now. For example, if we use Nim to create a callback 
function for an API in C, C compiler will complain on this.

  * **Case 3: Inconsistence within the generated C code**



For example, `source` of `nimCopyMem` is not marked as `const`, but when 
calling it, this parameter is casted to `NIM_CONST void *`.


static N_INLINE(void, nimCopyMem)(void* dest, void* source, NI size)


Run

Since we don't have something equivalent to `const` which indicates the 
parameter is not modified in the function, I think it is **_hard_** to decided 
when to attach `const` to a parameter when generating C code.

Also seen in [12824](https://github.com/nim-lang/Nim/pull/12824), parameter of 
the generated `$$` function do not have a `const` qualifier, if we pass in an 
value that has the `const` qualifier, some compiler may just warn on this, 
while others treat it as an error for some types.

* * *

How to deal with above cases?

Oh, by the way, In C I like to use `const` whenever possible.

Re: Recommended GUI library?

[dawkot]

Is there a good reason people often don't even mention QML in these threads?

Re: Recommended GUI library?

[Stefan_Salewski]

> Same pattern goes for gtk3. The only upto date gtk binding lacks any form of 
> API reference, and it's been a couple years.

We had the discussion (again) some days ago at GTK forum:

[https://discourse.gnome.org/t/better-documentation-for-gtk-request/2215/15](https://discourse.gnome.org/t/better-documentation-for-gtk-request/2215/15)

I have never recommended GTK for people not already familiar with GTK, as I 
know that learning GTK is some work -- more work than learning Nim for example. 
That is true for all language bindings -- for Python and D lang there is some 
documentation, for many language bindings there is nearly nothing. That is sad 
indeed. We would need a 600 pages book like the old GTK2 one of A. Krause for 
GTK3 and 4, and that for a dozen of languages bindings. The gintro page has 
already a large collection of examples -- together with other C examples or 
tutorials that offers a starting point. Of course a free book would be fine -- 
for GTK experts like Mr Bassi that may be only 1k hours of work, but for people 
like me with only basic GTK skills that would be more of course. For maybe a 
dozen Nim readers finally.

For your API reference, it is the C API and grep xxx 
~/.nimble/pkgs/gintro-0.6.1/gintro/* gtk.nim alone has 3k procs, all the gintro 
modules have about 10k procs and thousand of data types. Of course I can list 
all of them on a html page, will do it maybe over christmas. May look 
impressiv, but I am sure it is not helpful. Users with some GTK knowledge do 
not need it, and people without a clue of GTK will not benefit, they will need 
a book or at least very extended tutorials.

And finally, may I ask how many books you have written already, or how many 
great tools or libraries you have created, without being paid for it?

Re: Recommended GUI library?

[Araq]

> None of them has any API documentation, let alone any websites. It's 
> frustrating not to see any form of documentation other than "looking at 
> existing the project that uses both".

Both have documentation at the github entry page but it's a very good point 
regardless. I'll see if I'll mange to do something about that.

Re: Nim compiling using MS VS2015 (windows)

[Lecale]

I don't think mingw32 is perfect , at least, I blame it for getting stuck with 
this issue 
[https://gitlab.com/define-private-public/stb_image-Nim/issues/8](https://gitlab.com/define-private-public/stb_image-Nim/issues/8)

Re: Recommended GUI library?

[adnan]

What's Nim's killer app/library? Jester and Karax? None of them has any API 
documentation, let alone any websites. It's frustrating not to see any form of 
documentation other than "looking at existing the project that uses both".

Same pattern goes for gtk3. The only upto date gtk binding lacks any form of 
API reference, and it's been a couple years.

You are right, everyone is interested in web programming (and mobile, to add). 
But I don't see Nim provide a friendly choice for any of them.

I don't think anyone is interested in a library that has no documentation 
whatsoever. Nobody will pick it up. Nim is a fun language to write in. But the 
state of the ecosystem leaves me very frustrated.

Re: Recommended GUI library?

[marks]

I'm starting to experiment with NiGui. I'm trying to create "widgets" that 
maintain some state and that can communicate events between the child widgets 
they contain. I also want to modularise the code into separate functions and 
objects. Here's my first hack on your example 10 (see also a question in the 
code & notes after the code): 


{.experimental: "codeReordering".}

import nigui

type
MainWindow = object
window: Window
statusLabel: Label
CustomControl = object
control: Control

proc main(): void =
app.init()
var mainWindow = newMainWindow("Test #2")
mainWindow.statusLabel.text = "Click..."
mainWindow.window.show()
app.run()

proc newMainWindow(title: string): MainWindow =
result.window = newWindow(title)
result.window.width = 500
result.window.height = 500
var vbox = newLayoutContainer(LayoutVertical)
result.window.add(vbox)
result.statusLabel = newLabel()
vbox.add(result.statusLabel)

# pass in the label so that the new control can "talk: to it: is there 
a better way?
var control = newCustomControl(result.statusLabel)
control.control.width = 400
control.control.height = 400
vbox.add(control.control)
control.control.widthMode = WidthMode_Fill
control.control.heightMode = HeightMode_Fill

proc newCustomControl(label: Label): CustomControl =
result.control = newControl()

result.control.onDraw = proc (event: DrawEvent) =
let canvas = event.control.canvas
canvas.areaColor = rgb(30, 30, 30) # dark grey
canvas.fill()
canvas.setPixel(0, 0, rgb(255, 0, 0))
canvas.areaColor = rgb(255, 0, 0) # red
canvas.drawRectArea(10, 10, 30, 30)
canvas.lineColor = rgb(255, 0, 0) # red
canvas.drawLine(60, 10, 110, 40)
let text = "Hello World!"
canvas.textColor = rgb(0, 255, 0) # lime
canvas.fontSize = 20
canvas.fontFamily = "Arial"
canvas.drawText(text, 10, 70)
canvas.drawRectOutline(10, 70, canvas.getTextWidth(text),
   canvas.getTextLineHeight())

result.control.onMouseButtonDown = proc (event: MouseEvent) =
label.text = $event.button & " (" & $event.x & ", " & $event.y & ")"
# Shows where the mouse is clicked in control-relative coordinates

main()


Run

You'll notice that I had to drop the images since I couldn't get them to work 
(even though they work fine in your original example). Oh, and this runs fine 
on Windows & Linux:-)

PS I use 4 spaces for indents because I read years ago in _Code Complete_ that 
comparative studies had shown that a minimum of 3 is needed for clarity, and 
I'm used to 4 from Python;-}

Re: Godot and Blender

[rayman22201]

This is a huge pet peeve of mine. Nim and Python are very different languages! 
There is some similarity in the syntax, but that is where it ends. Nim is much 
closer to Ada or Pascal :-P

I looked into adding Nim support to Blender a long time ago. Here is what I 
found:

TLDR; It would be **extremely difficult**

It is a lot of work, and requires extensive knowledge of Nim, C++, and Blender, 
and you won't get a lot of help. It's definitely not a good beginner project.

1\. Blender embeds a full Python fork inside itself. They don't just use your 
system python. They have a custom python that has hooks all over the internal 
C++ code. (It was a big deal for them to migrate from Python 2 to Python3 for 
this reason)

2\. They don't have a published C++ api, and have **explicitly said** that they 
do not plan on publishing any documentation for their C++ api because it 
changes often and they like it that way. (They don't want to support backwards 
compatibility in their external C++ api)

3\. Related to point 2, the Blender programmer community is against adding 
other languages. Go look in their forums. Several people have asked for various 
languages (Lua for example). The answer is always, "it's open source, do what 
you want, but we will not support it in any way or accept any PR's for this"

I want to point out: I don't disagree with the Blender people. Blender is a 
very complicated piece of software, and they only have so much developer 
resources. They don't want to worry about having to maintain several language 
bindings. It's hard enough to maintain "Professional quality CG software".

The other side of the coin, it is technically possible. (Here be dragons.) 
There is a C++ api for Blender. People make C++ addons for Blender all the time.

You could make Nim bindings for the Blender C++ api. Nim is really good at 
binding to C code, but:

  * the api doesn't have good documentation
  * is not officially supported
  * may change with no notice



You will spend a lot of time figuring out how the Blender C++ api works, then 
getting Nim to talk to it, and then making sure it is kept up to date, and you 
probably won't get much help from the Blender people.

Re: Recommended GUI library?

[rayman22201]

nimx: [https://github.com/yglukhov/nimx](https://github.com/yglukhov/nimx)

The documentation is lacking, but it's maintained, performant, and cross 
platform

Re: How to get rid of [ProveInit] warning?

[rayman22201]

I understand what you are saying now.

Based on your last reply, I modified the macro to take a "default 
initialization expression" parameter: 
[https://play.nim-lang.org/#ix=23Zl](https://play.nim-lang.org/#ix=23Zl)

The syntax could be made "more beautiful" but I think it closely approximates 
the feature you are looking for.

The other relevant documentation is here: 
[https://nim-lang.org/docs/manual.html#statements-and-expressions-return-statement](https://nim-lang.org/docs/manual.html#statements-and-expressions-return-statement)

Specifically:

> The result variable is always the return value of the procedure. It is 
> automatically declared by the compiler. As all variables, result is 
> initialized to (binary) zero

Nim memsets the memory to binary 0 by default when a variable is initialized 
(It does not take into account the type at that stage) This is an important 
thing for memory security etc..., But, as you observe, does not necessarily 
result in a semantically correct default value for a type. (This is called out 
in the manual. It's known behavior.)

I agree with you that being able to set a semantically correct default value 
for a type is a useful feature, but consider that it is not fundamental.

A related issue has been discussed previously here: 
[https://github.com/nim-lang/RFCs/issues/126](https://github.com/nim-lang/RFCs/issues/126)

and here: 
[https://github.com/nim-lang/RFCs/issues/48](https://github.com/nim-lang/RFCs/issues/48)

Notably, other popular languages such as Go work the exact same way. There is 
precedent for the current behavior and there are real costs associated with 
adding this behavior to the language.

The thing that I am unsure about is how the current behavior should interact 
with the "Proveinit" algorithm. Proveinit is counter intuitive but technically 
correct in this case. It is reminding you that Nim has not set a semantically 
valid default value and you must do so yourself.

> Thanks. It's more a workaround than a satisfaying solution but I'll see if I 
> can use it in my code. Using the no warning pragma is shorter though ;-)

It is a work around, but IMO, it is more correct that setting the "no warning" 
pragma. That silences the warning, which you explicitly stated that you did not 
want:

> My goal is not to disable that compiler warning with compiler flags or 
> pragma, but to write the correct code for the nim compiler.

Unlike disabling or ignoring the warning, my macro solution produces "correct" 
code :-P.

IMHO, the beauty of Nim is that macros allow you to "fix" small holes in the 
spec like this in an elegant way. Believe or not, it is actually idiomatic Nim 
to do something like this. Pick your poison :-P 

Re: Recommended GUI library?

[phillvancejr]

Hey @marks, you're right it should be added there. It is an old package and is 
just in maintenance mode so it definitely needs some updating. I'm not the 
original creator of the bindings but I plan on making a pull sometime in the 
near future to update it with my changes and instructions for MacOS 
installation. I will also include the dylibs for MacOS as you suggested.

on MacOS we can use a terminal command called otool to list dependencies, I 
think on Linux you can use ldd or objdump and windows has dumpbin. Based on the 
quick google searching I did, I think you can use these to verify what dynamic 
libs the executable is calling out to. So on Mac I compile my executable and 
then run the tool to list all the dependencies and then I include the 
dependencies that are not System libraries guaranteed to be installed.

on MacOS the dependencies are libpng16.16.dylib, libjpeg.9.dylib and 
libtiff.6.dylib. I'm guessing these come from wxWidgets because I didn't have 
them on a test machine without wxWidgets installed, so I think these might also 
be the same ones needed on Windows and Linux with the appropriate extensions of 
course

The static variants are also included so it should be possible to statically 
link with them, though I have not tried that yet 

Re: Nim compiling using MS VS2015 (windows)

[demotomohiro]

If you want Nim to C/C++ compiler in MS visualstudio, just call nim with 
\--cc:vcc option. If you want to see how Nim call cl.exe, add \--listcmd option.

For example: 


nim c --cc:vcc --listcmd test.nim


Run

If you want Nim always use cl.exe, add cc = vcc in nim.cfg. And put the cfg 
file in %APPDATA%/nim/nim.cfg. If you want to use cl.exe in specific nim file, 
put the nim.cfg in the same directory. (Detail of how Nim process configuration 
files: 
[https://nim-lang.org/docs/nimc.html#compiler-usage-configuration-files](https://nim-lang.org/docs/nimc.html#compiler-usage-configuration-files))

I don't think it is a good idea to edit C:nimconfignim.cfg or nim.cfg in Nim 
install directory. When you update your Nim, that file is also replaced by new 
one.

@AmbrusFernas I don't understand what you are trying, but if you just want to 
use Nim on windows, you can install Nim using choosenim. 
[https://github.com/dom96/choosenim](https://github.com/dom96/choosenim) It 
also install mingw32 as backend C compiler. 

Re: Recommended GUI library?

[Trustable]

I'm the author of NiGui.

@rockcavera Please create an GitHub issue for the refresh issue you described. 
Maybe it's easy to fix.

@marks You're right, the documentation is still a missing part.

Re: Fastest way to check for int32 overflows

[e]

I keep this CMU SEI bookmark 
_
 as a reference for whenever I need to deal with overflow in C... it's probably 
useful for safe cross platform Nim coding, too.

Re: Recommended GUI library?

[marks]

I didn't even know there was a wxWidgets port. When I searched the nimble 
package site for "gui" it didn't find it (maybe it isn't there) and nor is it 
mentioned in the Curated Packages. Probably good if you put it in one or both 
those places so people could find it:-)

Also might help if you list the .so's, .dylib's and .DLLs that need to be 
distributed with an nim executable.

Anyway, I'll give it a try!

Re: Docker image for cross compiling

[jinnguyen019]

please provide some guide for cross arm building

Re: Nim forum confirmation email has no date

[anthonix]

Yeah but I don't have a github account, so I am reporting here. If possible can 
someone here report it?

Re: Fastest way to check for int32 overflows

[Stefan_Salewski]

> Anyway, why are i32 integers the fastest when performing calculations?

Some CPU may have no 64 bit data type at all, like some ARM and embedded chips. 
So for int64 addition we would get two operations at least, one plain addition 
and one add with carry. Even for a CPU with 64 bit support a multiplication 
will result in a 128 bit result which may be not a native type.

And finally, even when the 64 bit type is fully supported, you have to regard 
memory bandwidth and cache size. There can be twice as much int32 in cache as 
int64.

For smaller types than native word size, like int16 or int8 there may exists 
CPUs which first have to extent the size to native word size like 32 or 64 bit, 
and then do the math. I think for x86 CPU that is not true.

For float types -- well when there is a FPU add and mul can be fast too, 
division is generally not that fast and has latency.

Re: How to debug a segmentation fault?

[AmbrusFernas]

I'm working on a Reverse Polish Notation calculator for my Data Structures 
class and I get a segfault when I pass arguments to the program at runtime. How 
do you guys troubleshoot errors without line numbers?

Re: Fastest way to check for int32 overflows

[AmbrusFernas]

I tried searching it but I couldn’t find anything, could have been me not using 
the right words though 

Anyway, why are i32 integers the fastest when performing calculations? I think 
this is the case for C/C++ too so I’m assuming it’s an architectural thing.

Re: Nim compiling using MS VS2015 (windows)

[AmbrusFernas]

iv made some progress. so uh... 
[https://gyazo.com/47eb4eac97fa584b10f26e9a6b8b765e](https://gyazo.com/47eb4eac97fa584b10f26e9a6b8b765e)
 i was following the guide and this step doesnt seem doable (bin/nim c koch) 
the bin is empty. also tried using the aphoria ide but there isnt and exe to 
run it. i appologize if im coming off like an idiot. im eager to learn and 
figure this out so i figured ill look like an idiot now and laugh about it 
later.

Re: generic typevariable binding

[e]

Thanks, I created 
[https://github.com/nim-lang/Nim/issues/12863](https://forum.nim-lang.org/postActivity.xml#https-github-com-nim-lang-nim-issues-12863)

Re: Nim forum confirmation email has no date

[juancarlospaco]

Report the Bug, its Open Source. :) 

Re: How to export custom exception types?

[mp035]

Duh (feeling silly). Thank you.

Re: How to export custom exception types?

[SolitudeSF]

you didnt export extraData field.

Nim forum confirmation email has no date

[anthonix]

The email that is sent after registering at forum.nim-lang.org contains no date 
header.

Re: How to export custom exception types?

[lscrd]

Exporting the type is not enough. You need to mark the fields you want to 
export with an * too. So, here, put an * after "extraData":


type myModuleException* = ref object of Exception
  extraData* : uint32


Run

How to export custom exception types?

[mp035]

Hi, I'm having trouble using custom exceptions; any clue what I'm doing wrong 
here:

mymodule.nim: 


type myModuleException* = ref object of Exception
  extraData : uint32

proc myModuleFunc*() =
  var ex : myModuleException
  new(ex)
  ex.extraData = 12
  raise ex


Run

main.nim: 


import mymodule

try:
  mymoduleFunc()
except myModuleException as ex:
  echo ex.extraData


Run

When compiling (with nim 1.0.4) I get: 


user@host:~/temp/nimExceptions$ nim c -r main.nim
Hint: used config file 
'/home/user/.choosenim/toolchains/nim-1.0.4/config/nim.cfg' [Conf]
Hint: system [Processing]
Hint: widestrs [Processing]
Hint: io [Processing]
Hint: main [Processing]
Hint: mymodule [Processing]
/home/user/temp/nimExceptions/main.nim(7, 10) Error: undeclared field: 
'extraData'


Run

Nim version: 


user@host:~/temp/nimExceptions$ nim -v
Nim Compiler Version 1.0.4 [Linux: amd64]
Compiled at 2019-11-27
Copyright (c) 2006-2019 by Andreas Rumpf

git hash: c8998c498f5e2a0874846eb31309e1d1630faca6
active boot switches: -d:release


Run

Re: Recommended GUI library?

[JPLRouge]

I tested back and forth and it works. I even got into the code and it works. 
moreover you can use a designer or do everything by hand ...

Re: Recommended GUI library?

[phillvancejr]

Hello, I personally use the wxWidgets bindings. There isn't a ton of 
documentation on the Nim bindings specifically, but between the examples and 
wxWidgets c++ documentation, it is easy enough to navigate. Check out he 
wxWidgets window creation example I just uploaded to Rosetta Code, 
[https://rosettacode.org/wiki/Window_creation#wxWidgets](https://rosettacode.org/wiki/Window_creation#wxWidgets)

I'm on MacOS, but wxWidgets is cross platform, and the github page has 
installation instructions for Windows and Linux. I am using the pmunch branch:

[https://github.com/pmunch/wxnim](https://github.com/pmunch/wxnim)

It does have some dependencies. First of all you need to install wxWidgets 
separately then the bindings. On MacOS it calls out to some dlls that I end up 
including with the executable. There is probably a way to statically link to 
them but I haven't taken the time to try that yet. on MacOS I only need to ship 
2 dlls with my executable and they are small 

Re: TXT DNS lookup

[enthus1ast]

There is also cheatfate's asyncdns in asynctools repo. But have not tried it 
lately.

Re: Recommended GUI library?

[enthus1ast]

The best/most advanced gui library for nim is afaik gintro (gtk).

I can also recommend web view for smaller things.

Re: How to peek and/or advance an iterator inside a for loop

[mratsim]

Write you own iterator

(pseudo code, not checked even for indentations)


import parseUtils # for parseint suitable to advance cursors

iterator customSplit(splitToken: char, tokenStream: string): int =
  var cursor = 0
  var code = low(int) # just a default value to detect bugs
  
  while cursor < tokenStream.len:
cursor += parseInt(tokenStream, code, cursor)
case code
of 1:
  yield(123)
  yield(456)
  yield(789)
  # This will yield 123, 456, 789 for the next 3 iterations
 of 2:
   yield(123456)
   # This will yield 123456
 of 99:
   discard
 else:
   quit "Cannot parse instructions"


Run

Re: generic typevariable binding

[mratsim]

Yes please create an issue, thanks for the example. Seems like an instance of 
too strong type bindings for int.

This RFC covers what Nim type bindings rules are in-depth 
[https://github.com/nim-lang/RFCs/issues/153](https://github.com/nim-lang/RFCs/issues/153)
 but I unlike the examples given there your example is expected to work with 
the current Nim code.

How to peek and/or advance an iterator inside a for loop

[adnan]

Something similar to 
[https://doc.rust-lang.org/std/iter/trait.Iterator.html#tymethod.next](https://doc.rust-lang.org/std/iter/trait.Iterator.html#tymethod.next)
 and 
[https://doc.rust-lang.org/std/iter/struct.Peekable.html#method.peek](https://doc.rust-lang.org/std/iter/struct.Peekable.html#method.peek)


import utils, strutils

for line in lines open getData "day2":
for codeStr in split ",":
let code = parseInt codeStr
case code:
of 1:
#[
let next1 = next()
let next2 = next()
let next3 = next()
# iterator has advanced by 3 now
]#
of 2:
#[
let next = peek()
# iterator has not advanced forward
]#
of 99:
# ...
else:
quit "Cannot parse instructions"


Run

Re: Using setLen after newSeqOfCap is not safe?

[mratsim]

`setLen` only changes the length, it does not initialize with zero except in 
one case, when Nim needs to reallocate the seq because the reserved buffer was 
too small but AFAIK that's the OS that gives zero-ed out memory pages by 
default.

That can be seen with


s = newSeqOfCap[int](max_seq_size)
s.setLen(max_seq_size + 10)
echo s[max_seq_size - 1]


Run

Re: Recommended GUI library?

[marks]

I've now tried the "hello world" program for all those that claim to be 
cross-platform (at least Linux & Windows). Most don't actually work on Windows, 
and all but one requires at least one `.so` or `.dll`.

The one exception is [NiGui](https://github.com/trustable-code/NiGui). This is 
pure Nim so doesn't need any extra shared libraries. Also, I found it worked 
fine on both Linux and Windows. I haven't tested it for performance or for 
comprehensiveness, and the documentation is rather sparse. However, it comes 
with a whole bunch of examples which are small enough to study and learn from.

I really hope that _NiGUI_ gets the support it needs. For example, after 
decades, Python still has no native GUI library (although there have been many 
attempts, e.g., _PyGUI_ ). This makes it much harder to deploy Python GUI apps. 
Yet with _NiGUI_ deployment is easy since it is built right into the executable 
with no separate libraries.