A cursory look at meta-programming in Nim

A cursory look at meta-programming in Nim(blog.ldlework.com)

97 points by ldlework 11 years ago | 29 comments

hzhou321 11 years ago |

Or, with a text based meta-layer (MyDef):

    import macros

    $(for:A in A,B,C)
        proc $(A)() = echo "$(A)"

    proc execute(order: seq[int], callbacks: seq[proc]) =  
      for i in items(order):                              
        callbacks[i]()

    execute(@[0,0,1,2,1,2], @[A, B, C])

kazinator 11 years ago | |

You might as well use the POSIX shell to write your code:

   cat <<END
   $(for x in A B C; do
       echo "proc $x() = echo \"$x\"";
     done)
   
   proc execute(order: seq[int], callbacks: seq[proc]) =  
     for i in items(order):                              
       callbacks[i]()

   execute(@[0,0,1,2,1,2], @[A, B, C])
   END

rockboe 11 years ago | | |

It's great that both Nim and Bash are so easy to read and write. The beauty of Nim is it makes writing performant C code as easy as writing Python.

hzhou321 11 years ago | | |

It worked!

Now how do I incorporate this into my tool chain (Makefile)?

HOLYCOWBATMAN 11 years ago | |

Hey i can do that in $php too!

    function execute($order, $callbacks){
        foreach($order as $i){
            $callbacks[$i]();
        }
    }

    function abcProcs(){
        foreach(func_get_args() as $f){
            eval("function $f() { echo '$f'; };");
        }
    }

    abcProcs("A","B","C");
    execute([0,0,1,2,1,2], ['A','B','C']);

edit:

you don't have to quote the function names (just to show they are really functions and not closures):

    execute([0,0,1,2,1,2], [A,B,C]);

rockboe 11 years ago | | |

Most scripting languages have miserable performance characteristics and lack native types. The beauty of Nim is it isn't a scripting language, it just looks like it is.

Nim isn't C/C++, but it performs like it is C/C++. Nim isn't Golang, either, but it compiles programs like Go does, down to a self-contained binary with no dependencies. You can even statically link a Nim program against musl libc to ship without even a dependency on glibc.

This puts a completely new spin on writing performant code - just skip the C and write your code in pure Nim. It's a lot like writing Python except you produce comparable results to what you would get from writing your code in C or Go.

kazinator 11 years ago |

Way too cumbersome, sorry.

TXR Lisp:

  @(do
    (macro-time
      (defun abc-proc (n)
        ^(defun ,n () (pprinl ',n))))

    (defmacro abc-procs (. n)
      ^(progn ,*[mapcar abc-proc n]))

    (abc-procs a b c)

    (defun exec (order callbacks)
      (each ((i order))
        [[callbacks i]]))

    (exec '(0 0 1 2 1 2) '(a b c)))

  $ txr test.txr
  a
  a
  b
  c
  b
  c

Variation on exec:

  (defun exec (order callbacks)
    (mapdo (op [callbacks @1]) order))

def- 11 years ago | |

You can do it a bit shorter and easier in Nim as well:

    import macros, strutils
    
    macro abcProcs(n: varargs[expr]): stmt =
      result = newStmtList()
      for c in n.children:
        result.add parseStmt("proc $1 = echo \"$1\"" % $c)
    
    abcProcs("A","B","C")
    
    proc execute(order: openarray[int], callbacks: openarray[proc]) =
      for i in order:
        callbacks[i]()
    
    execute([0,0,1,2,1,2], [A,B,C])

andybak 11 years ago | |

Yes but on the plus side there's a lot fewer parentheses.

kazinator 11 years ago | | |

If you're counting tokens, you should count all of them: all symbols and punctuation, as well as any whitespace outside of a string literal that cannot be replaced by a single space character without affecting the syntax.

ldlework 11 years ago | | |

You were down-voted but I secretly agree.

wait - oops. :)

shasta 11 years ago |

I think the author should post a follow-up after he's tried to do substantial work with this style meta-programming. My guess is that you want to keep templated code to an absolute minimum.

ldlework 11 years ago | |

You were down-voted but I actually agree. I did conclude the article by saying that templates seem really nice for closing the gap on refactoring code that not even generics could wrap up. So the intention was to convey that templates are really a last resort secret weapon. They just also seem to be pretty easy to understand :)

kbd 11 years ago |

It's a small thing, but I'm so glad they renamed it to "Nim". Its prior name carries such a negative connotation, while just shortening that gave a name that's cute and simple.

jwecker 11 years ago | |

Fun fact- Nimrod means mighty hunter. The negative connotation came from early Bugs Bunny cartoons where he applies the name sarcastically to Elmer Fudd.

evilduck 11 years ago | | |

Kind of. https://en.wikipedia.org/wiki/Nimrod

There's definitely a much older negative connotation than the Bugs Bunny usage.

sigzero 11 years ago | | |

Also a very cool future sentinel in the X-Men comics.

Dewie3 11 years ago | | |

The voices of American programmers are loud and many.

vezzy-fnord 11 years ago | |

I'm one who actually preferred Nimrod, but it's done by now.

david-given 11 years ago | | |

Ah --- I didn't know this was Nimrod! I remember looking at that a few years ago and thinking 'this is awesome but not quite ready yet'.

I need to have another look at Nim. It even looks like it's in Debian!

Dewie3 11 years ago | |

`git` also carries negative connotations. But at least that was intentional.

import macros $(for:A in A,B,C) proc $(A)() = echo "$(A)" proc execute(order: seq[int], callbacks: seq[proc]) = for i in items(order): callbacks[i]() execute(@[0,0,1,2,1,2], @[A, B, C])

cat <<END $(for x in A B C; do echo "proc $x() = echo \"$x\""; done) proc execute(order: seq[int], callbacks: seq[proc]) = for i in items(order): callbacks[i]() execute(@[0,0,1,2,1,2], @[A, B, C]) END

%: %.ct cpp -P $(shell env | sed -e "s/.*/-D_ENV_'&'/") $< > $@ %: %.st ( export __FILE__=$< ; echo "cat <<!" ; cat $< ; echo "!" ) | bash > $@ %: %.mt rm -f $@.err m4 -D__FILE__=$< $(shell env | sed -e "s/$[^=]*$=$.*$/-D'_ENV_\\1=\\2'/") $< > $@ if [ -s $@.err ] ; then cat $@.err ; exit 1 ; fi rm -f $@.err

function execute($order, $callbacks){ foreach($order as $i){ $callbacks[$i](); } } function abcProcs(){ foreach(func_get_args() as $f){ eval("function $f() { echo '$f'; };"); } } abcProcs("A","B","C"); execute([0,0,1,2,1,2], ['A','B','C']);

@(do (macro-time (defun abc-proc (n) ^(defun ,n () (pprinl ',n)))) (defmacro abc-procs (. n) ^(progn ,*[mapcar abc-proc n])) (abc-procs a b c) (defun exec (order callbacks) (each ((i order)) [[callbacks i]])) (exec '(0 0 1 2 1 2) '(a b c))) $ txr test.txr a a b c b c

import macros, strutils macro abcProcs(n: varargs[expr]): stmt = result = newStmtList() for c in n.children: result.add parseStmt("proc $1 = echo \"$1\"" % $c) abcProcs("A","B","C") proc execute(order: openarray[int], callbacks: openarray[proc]) = for i in order: callbacks[i]() execute([0,0,1,2,1,2], [A,B,C])