This document discusses macros in the Nemerle programming language. It provides an overview of the different types of macros in Nemerle, including lexical level macros, AST level macros, and custom attribute macros. AST level macros allow transforming AST nodes similar to Lisp macros. Custom attribute macros enable global rewriting of a program at compile time. Examples demonstrate using macros for tasks like solving mazes at compile time and custom syntax like json data literals.

1. Macros in Nemerle
Parser Enthusiast
Kota Mizushima(@kmizu)

2. 2
Self Introduction
Twitter ID: @kmizu
GitHub: https://github.com/kmizu
Like: PEG, Nemerle, Scala, etc.
Interested In: Formal Languages, Parsing

3. 3
What's Nemerle?(1)
Object & functional programming language
➢On .NET Framework (CLR or Mono)
From: 2003
➢Old
Original Developer: Kamil Skalski, etc.
Last stable: v1.2.503.0 （ 2016-03-15 ）

4. 4
What's Nemerle?(2)
Macro
Powerful type inference
➢Can infer type from call-site
Pattern matching & variant
First-class function
, etc.

5. 5
Powerful Type Inferences
There exist type inferences in recent languages.
Nemerle's type inference is different from:
def fact(n){
| 0 => 1
| _ => n * fact(n - 1)
} // recursive function （ without type annotation ）
fact(4) // int -> int is inferred from use-site

6. 6
What's Macro?
Features so-called cacros
➢Lisp's macro
➢Lisp's reader macro
➢Preprocessor macro (in C family language)
➢Hidemaru Macro ← Different meaning
➢Excel Macro(VBA) ← Different meaning
Nemerle's macro is inspired by Lisp's macro

7. 7
What's Nemerle's Macros?
Lexical level macros
➢[Token] -> [Token]
AST level macros
➢ASTNode -> ASTNode
Custom attribute macros
➢Global rewriting of program is allowed using such macros
➢Compile time MOP

8. 8
AST Level Macros
Similar with Lisp's macros
Receive AST of expression and return AST
➢Transformation is written in Nemerle itself
➢Typed AST is handled
Many language constructs is just macros
➢If, while, for, using, printf, lock, etc.

9. 9
Hello, World! In Nemerle
Statically checked printf
using Nemerle.IO;
printf("%d + %d = %dn", 1, 2, 1 + 2) //OK
printf("%d + %d = %dn", 1, 2, "3") //NG
printf("%d + %d = %dn", 1, 2, 3.0) //NG
def format = "%d + %d = %dn"
printf(format, 1, 2, 3) //NG. format must be string literal

10. 10
Using Macros(1)
using System;
macro fact(n: int) {
def loop(m) {//type inference for recursive function
| 0 => 1
| _ => m * f(m - 1)
}
{ def r = f(n); Console.WriteLine("fact({0}" = {1}", n, r); <[ $(r: int) ]> }
}
fact(4) // → 24

11. 11
Using Macros(2)
using System.Text.RegularExpressions;
using Nemerle.Compiler
macro regex(n: String) {
def r = <[ Regex($(n: string)) ]>;
try { _ = Regex(n); r; } catch { | _ is ArgumentException =>
Message.Warning("illegal pattern " + n); r }
}
regex(".*") // OK
regex("**") // → "illegal pattern **" in compile time

12. 12
Using Macros(3)
Swap macros
macro swap(n, m) syntax("swap", n, "and", m) {// new syntax: swap n and m
<[ def tmp = $n; $n = $m; $m = tmp; ]>
}
using System;
mutable x = 10; mutable y = 20;
swap x and y; // diffent syntax
Console.WriteLine("({0}, {1})", x, y); // → "(20, 10)"

13. 13
Solving Maze in Compile Time(1)
using System; using System.Console;
using System.IO.File; using Nemerle.Collections;
using Nemerle.Imperative; using Nemerle.Compiler;
macro SolveMaze(inputFile: String) {
def maze = ReadAllLines(inputFile)
def h = maze.length;
...
}

14. 14
Solving Maze in Compile Time(2)
**************************
*S* * *
*** * * ************* *
* * * ************ *
* * *
************** ***********
* *
** ***********************
* * G *
* * *********** * *
* * ******* * *
* * *
**************************
**************************
*S* * $$$$ *
*$* *$$* $************* *
*$* $$* $$************ *
*$$$$* $$$$$ *
**************$***********
* $$$$$$$$$$$$$ *
**$***********************
* $$$$$* $$$$$$$$$$$$$G *
* * $$$$*********** * *
* * ******* * *
* * *
**************************

15. 15
Custome Attribute Macro(Compile Time MOP)
using Nemerle.Compiler; using Nemerle.Collections;
namespace DesignPatterns {
[Nemerle.MacroUsage
(Nemerle.MacroPhase.WithTypedMembers,
Nemerle.MacroTargets.Field)]
macro Proxy (t : TypeBuilder, f : FieldBuilder, iface) { ... }
}
using DesignPatterns;
class Point { public X : int { ... }; public Y() : int { ... }; }
class PointProxy {
[Proxy()] //invocation of Proxy macro
point_ : Point;
}

16. 16
Lexical Level Macros
macro JSONData (group : Token)
syntax ("json", group) {
...
}
...
json({"languages":[
"Java", "Scala", "Nemerle", "C#", "Haskell", "OCaml"
]}) //custom lexer is used

17. 17
Builtin Custom Attribute Macros
ProxyPublicMembers macro
➢also known as first class delegation
Lazy macro
➢Lazy evalution
Memoize macro
Etc.

18. 18
Concolusion
Overview of Nemerle's macros
➢Lexical level macros
➢AST level macros
➢Custom attribute macros
Nemerle is awesome!
Try Nemerle!
➢http://nemerle.org