First

Author: alehander92

.gitignore

@@ -0,0 +1 @@
+*.o

LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Alexander Ivanov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -0,0 +1,67 @@
+# breeze
+
+A dsl for writing macros in Nim
+
+## rationale
+
+I read a comment by Araq about how karax might be a good fit for the ast nodes in
+the compiler and I've always found building the nodes in `macro`-s in Nim tedious.
+`breeze` is a karax-like dsl for building nim nodes in macros:
+
+```nim
+macro s(b: untyped): untyped =
+  var e = newIdentNode(!"e")
+  result = buildMacro:
+    call:
+      dotExpr(e, ident("f"))
+      infix(ident("+"), 2, 3)
+```
+
+expands to
+
+```nim
+nnkCall.newTree(nnkDotExpr.newTree(e, newIdentNode(! "f")),
+                nnkInfix.newTree(newIdentNode(! "+"), newLit(2), newLit(3)))
+```
+
+## functionality
+
+You use it invoking `buildMacro` with a singular child corresponding to the node you want to build
+
+Each child is either of the form 
+
+```nim
+node:
+  child
+  child
+```
+
+or 
+
+```nim
+node(child, child)
+```
+
+They're equivalent in most cases and they usually expand to `nnk<capitalized_node>.newTree(<visited children>)`
+
+Special cases are literals which are expanded to `newLit` and `ident(name)` which are expanded to `newIdentNode`.
+
+You can build dynamically macros (with variables) just by passing them directly,
+e.g. 
+
+```nim
+var e = newIdentNode(!"f")
+result = buildMacro:
+  call:
+    e
+```
+
+expands to
+
+```nim
+Call
+  Ident !"f"
+```
+
+
+

breeze.nim

@@ -0,0 +1,90 @@
+import macros, strutils, sequtils, tables
+
+const debugMacro = false
+
+proc build(b: NimNode): NimNode
+
+proc buildCall(args: NimNode): seq[NimNode] =
+  result = args.mapIt(build(it))
+
+proc buildInline(args: NimNode): seq[NimNode] =
+  result = @[]
+  var isArg = false
+  for child in args:
+    if isArg:
+      result.add(build(child))
+    else:
+      isArg = true
+
+proc labelOf(b: NimNode): string =
+  assert b.kind in {nnkIdent, nnkAccQuoted}
+  if b.kind == nnkAccQuoted:
+    result = labelOf(b[0])
+  else:
+    result = $b.ident
+
+proc buildIdent(b: NimNode): NimNode =
+  result = nnkCall.newTree(
+    newIdentNode(!"newIdentNode"),
+    nnkPrefix.newTree(
+      newIdentNode(!"!"),
+      newLit($b)))
+
+proc build(b: NimNode): NimNode =
+  case b.kind:
+  of nnkStmtList:
+    result = build(b[0])
+  of nnkCall:
+    var label = labelOf(b[0])
+    case label:
+    of "ident":
+      result = buildIdent(b[1])
+    else:
+      var args: seq[NimNode]
+      if len(b) == 2:
+        args = buildCall(b[1])
+      else:
+        args = buildInline(b)
+      result = nnkCall.newTree(
+        nnkDotExpr.newTree(
+          newIdentNode(!("nnk$1" % capitalizeAscii(label))),
+          newIdentNode(!"newTree")))
+      for arg in args:
+        result.add(arg)
+  of nnkCharLit..nnkUInt64Lit, nnkFloatLit..nnkFloat64Lit, nnkStrLit..nnkTripleStrLit:
+    result = nnkCall.newTree(
+      newIdentNode(!"newLit"),
+      b)
+  of nnkIdent:
+    if $b == "true" or $b == "false":
+      result = nnkCall.newTree(
+        newIdentNode(!"newLit"),
+        b)
+    else:
+      result = b
+  of nnkAccQuoted:
+    result = build(b[0])
+  of nnkNilLit:
+    result = nil
+  else:
+    when debugMacro:
+      echo treerepr(b)
+    else:
+      discard
+
+macro buildMacro*(b: untyped): untyped =
+  result = build(b)
+  when debugMacro:
+    echo "build: $1" % repr(result)
+
+# macro s(b: untyped): untyped =
+#   var e = newIdentNode(!"e")
+#   result = buildMacro:
+#     call:
+#       dotExpr(e, ident("f"))
+#       infix(ident("+"), 2, 3)
+#   when debugMacro:
+#     echo treerepr(result)
+
+# var e = (f: (proc(x: int) = echo(x)))
+# s(2)

breeze.nimble

@@ -0,0 +1,7 @@
+version         = "0.0.1"
+packageName     = "breeze"
+author          = "Alexander Ivanov"
+description     = "macro dsl"
+license         = "MIT"
+
+requires "nim >= 0.16.1"