Details
New Feature
Closed
Major
Description
Current macro macro: syntax is a little unfriendly when it comes to handling and checking arguments.
Either you manually do a lot of manual checks and casting, either you use pattern matching to match arguments, but it is somewhat non-wrist-friendly to do it for simple patterns).
Macro definitions now support arguments definition in a wrist-friendly and intuitive way, including handling of variable number of (optional) arguments.
To match a variable number of arguments use T* (enumerable) notation (e.g 'arg as string*' for a variable number of string arguments).
To match argument type against macro's body, just name the argument `body` (e.g 'body as MethodInvocationExpression*' for allowing only method invocation expressions within the body).
Testcase (and documentation 
):
""" the sum of those 6 numbers is 108 foofoo barbar invocation #1 of 2 invocation #2 of 2 Line 'How do you bou?' contains unknown word 'bou'. Did you mean 'boo'? """ import System import Boo.Lang.Compiler.Ast import Boo.Lang.PatternMatching macro sum(numbers as int*): s = 0 for n in numbers: s += n yield [| print "the sum of those ${$(numbers.Count)} numbers is ${$s}" |] macro repeatLines(repeatCount as int, lines as string*): for line in lines: yield [| print $line * $repeatCount |] macro invokeWithCount(body as MethodInvocationExpression*): for invocation in body: invocation.Arguments.Add([| $(body.Count) |]) yield invocation macro spellCheck(lang as string, body as string*): raise "Unknown language `${lang}`" if lang != "en-EN" for line in body: if line.Contains("bou"): yield [| print "line '${$line}' contains unknown word 'bou'. Did you mean 'boo'?" |] sum 4, 8, 15, 16, 23, 42 repeatLines 2, "foo", "bar" invokeWithCount: Console.WriteLine("invocation #1 of {0}") Console.WriteLine("invocation #2 of {0}") spellCheck "en-EN": "Hello boo!" "How do you bou?"
Issue Links
Activity
Oh yeah nice 
I did not think about pattern matching for such simple patterns, but well indeed it could be implemented that way by macro `macro`.
The point still, is or isn't the syntax proposal a good idea?
I mean pattern matching is really nice of course but for such simple patterns it seems a little overkill to have to write these isn't it?
Also the new syntax can potentially provide better error reporting (as in display the 'macro' arguments like "Usage: macroname arg1 arg2..")
The nice thing about implementing this syntax with pattern matching would be to be able to write macro overloads in isolation:
macro option(name as string, value as string):
yield [| print "<string name="${$name}">${$value}</string>" |]
macro option(name as string, value as int):
yield [| print "<integer name="${$name}">${$value}</string>" |]
would produce simply two cases merged in the same 'option' macro
macro option: case [| option $(StringLiteralExpression(Value: name)), $(StringLiteralExpression(Value: value)) |]: yield [| print "<string name="${$name}">${$value}</string>" |] case [| option $(StringLiteralExpression(Value: name)), $(IntegerLiteralExpression(Value: value)) |]: yield [| print "<integer name="${$name}">${$value}</integer>" |]
I did not think about pattern matching for such simple patterns, but well indeed it could be implemented that way by macro `macro`.
The point still, is or isn't the syntax proposal a good idea?
I mean pattern matching is really nice of course but for such simple patterns it seems a little overkill to have to write these isn't it?
Also the new syntax can potentially provide better error reporting (as in display the 'macro' arguments like "Usage: macroname arg1 arg2..")
The nice thing about implementing this syntax with pattern matching would be to be able to write macro overloads in isolation:
macro option(name as string, value as string):
yield [| print "<string name="${$name}">${$value}</string>" |]
macro option(name as string, value as int):
yield [| print "<integer name="${$name}">${$value}</string>" |]
macro option: case [| option $(StringLiteralExpression(Value: name)), $(StringLiteralExpression(Value: value)) |]: yield [| print "<string name="${$name}">${$value}</string>" |] case [| option $(StringLiteralExpression(Value: name)), $(IntegerLiteralExpression(Value: value)) |]: yield [| print "<integer name="${$name}">${$value}</integer>" |]
The text misrepresents the way macros are expressed Today. The first macro could be: