nimforum mirror - On term rewriting macros

Araq (orginal) [2021-04-22T09:00:59+02:00] view original

Since it came up in the other thread, TR macros are not used (much) in the standard library because they currently slow down compilations too much. They are also hard to write, not because you end up with wrong optimizations (though that's a possibility too), but because the optimizations are not applied reliably because Nim's AST has too many invisible parts (nkHiddenDeref, implicit type conversions).

Better API design can often (but not always) produce better solutions: table.mgetOrPut, sugar.dup, writing a macro that takes varargs come to mind.

timothee (orginal) [2021-04-22T09:26:24+02:00] view original

also:

they hide infinite recursion bugs by truncating to a max depth

the syntax is too foreign and not flexible enough (major point against)

the TRW general idea is useful though:

optimization (eg: ret &= a & b & c)

debugging + other use cases where you want to change behavior globally with minimal code changes

it's a more principled way to handle things like dotOperators as I've argued here: https://github.com/nim-lang/RFCs/issues/341#issuecomment-778572488

instead how about introducing something that fits better with the language and is more flexible:

# instead of: template optMul{`*`(a, 2)}(a: int): int = a+a

proc myCustomTRW(a: NimNode): NimNode {.rewrite.} =
  ## if returns nil, the expression is not rewritten, else it's rewritten
  if a.kind == nnkInfix and a[0].strVal == "*":
    result = genAst(lhs = a[1], rhs = a[2]): lhs + rhs

the semantics: each expression is matched (recursively) against each TRW in scope

the only question IMO is whether this would be more expensive (at CT) than current TRW, but I don't see why.

links

https://nim-lang.github.io/Nim/manual_experimental.html#term-rewriting-macros

Araq (orginal) [2021-04-22T10:15:11+02:00] view original

the only question IMO is whether this would be more expensive (at CT) than current TRW, but I don't see why.

It looks equally expensive to me, that's not an improvement. ;-)

In my opinion the optimization needs an explicit anchor point. Like so:

proc `*`(x, y: Matrix): Matrix {.anchor: matrixMul.} = ...
proc `+`(x, y: Matrix): Matrix {.anchor: matrixAdd.} = ...

macro matrixAdd(n: NimNode): NimNode =
  # turn (a * b) + c  into  `*+`(a, b, c)
  if n[0].matches(matrixMul):
    result = newCall("*+", a, b, c)
  else:
    result = nil # no match

haxscramper_ (orginal) [2021-04-22T13:33:55+02:00] view original

Another possible use case for term rewriting macros is user-defined warnings - for example when converting from older API to a new one. Implicitly rewriting everything is a bad idea, but making it easier to migrate old code, or prevent accidental misuses is still useful. Paired with pattern matching it might be possible to get something like this working quite easily:

macro optNot*{not a}(a: bool{nkCall}): untyped =
  if a.matches(Call[
    Sym(strVal: "[]"),
    Sym(getTypeInst: Sym(strVal: "Lex")),
    .._
  ]):
    warning("Deprecated use of `not lex[]`, convert to `lex.not []`", a)
  
  result = nnkPragmaBlock.newTree(
    nnkPRagma.newTree(ident "noRewrite"),
    newCall("not", a)
  )

The only issue is that {.noRewrite.} pragma seems to be broken again (I'm not 100% sure if I'm using it correctly here, but considering example from the manual also gives repeated macro expansions ...).

template pwnEcho{echo(x)}(x: typed) =
  {.noRewrite.}: echo("pwned!")

echo "ab"

Creates

/usercode/in.nim(4, 6) Hint: pwnEcho(["ab"]) --> ' {.noRewrite.}: echo(["pwned!"])' [Pattern]
/usercode/in.nim(2, 22) Hint: pwnEcho(["pwned!"]) --> ' {.noRewrite.}: echo(["pwned!"])' [Pattern]
/usercode/in.nim(2, 22) Hint: pwnEcho(["pwned!"]) --> ' {.noRewrite.}: echo(["pwned!"])' [Pattern]
/usercode/in.nim(2, 22) Hint: pwnEcho(["pwned!"]) --> ' {.noRewrite.}: echo(["pwned!"])' [Pattern]
/usercode/in.nim(2, 22) Hint: pwnEcho(["pwned!"]) --> ' {.noRewrite.}: echo(["pwned!"])' [Pattern]
/usercode/in.nim(2, 22) Hint: pwnEcho(["pwned!"]) --> ' {.noRewrite.}: echo(["pwned!"])' [Pattern]
/usercode/in.nim(2, 22) Hint: pwnEcho(["pwned!"]) --> ' {.noRewrite.}: echo(["pwned!"])' [Pattern]
/usercode/in.nim(2, 22) Hint: pwnEcho(["pwned!"]) --> ' {.noRewrite.}: echo(["pwned!"])' [Pattern]
... N lines omitted

Araq (orginal) [2021-04-23T08:22:57+02:00] view original

To make it clear: Enough people have tried to use "TR macros" for things other than optimizations so a more general "rewrite system" would be acceptable too. Then it cannot be disabled anymore but it's a price I'm willing to pay.

hamidrb80 (orginal) [2023-06-30T05:19:54+02:00] view original

the examples in the docs does no convenience me, why not use a template?

instead of

template optMul{`*`(a, 2)}(a: int): int = a+a

just write:

template `*`(a: int, b: static[2]): int = a+a

Mirror of forum.nim-lang.org

7837 :: On term rewriting macros

links