I'm someone new to nim and I've never read anything about the metaprogramming 
side of Nim. I dunno if you want feed from a beginner, and I dunno if I'm too 
late, but here it is just in case...

This video was really good and interesting. I loved how I could copy & paste 
from your code file you linked to, to try things out myself (maybe it's a good 
idea to mention that file at the beginning). I'm glad I watched the video - 
thank you! I liked how you said at the end that simpler is better, and that the 
complex stuff shouldn't be used (just because it can) when a simpler way can be 
used, and so it should be approached in this order: normal procs generic procs 
templates macros (again maybe this should have been mentioned at the start)

For Generics, I'm left a bit confused as why this the more complicated form is 
used: proc sumGenericConstrained[T: int | float](https://forum.nim-lang.org/a, 
b: T): T = ... instead of the simpler way I saw somewhere: proc 
sumGenericConstrained(a, b: int | float) =

For Templates, you said they're good for making it easie then you show that a 
bunch of if-statements can be broken down into four template calls, but I'm 
left wondering why four proc calls can't be called instead. You mentioned 
something about templates not having a local scope in the same way procs do, 
and that templates inject code (so I'm wondering if the compiler puts the code 
inline instead of leaving it in the template, and maybe it doesn't do that for 
procs?). It wasn't clear to me why this is a good thing ... does it speed 
things up vs using procs? I'm left wondering if it's contradicting your 
simplicity rules.

Keep up the great work!

Reply via email to