fowlmouth

import macros

macro mac(n: expr): expr =
  return quote do:
    (proc(): int =
      `n`.int)

template samething(n): expr =
  (proc (): int = n.int)

fowlmouth

import jester, asyncdispatch, htmlgen

proc foo(s:string):string = return s&"!"

when isMainModule:
    let d:string="asdf"
    routes: get "/": resp foo(d) # self.render_movie(self.latest_movie_id)
    runForever()

fowlmouth

import macros

macro setIndices (obj; args: varargs[expr]): stmt =
  assert args.len mod 2 == 0, "need even # of args"
  result = newStmtList()
  for i in countup(0, len(args)-2, 2):
    result.add newAssignment(
      newNimNode(nnkBracketExpr).add(obj, args[i]),
      args[i+1]
    )

fowlmouth

getType() is the fucking shit

justify the cursewords here

examples

showty.nim attached can be used as a "dumptree" equivalent for this new api

• super() is the simplest of getType I have written yet, it looks up the super type of an object and returns a type conversion for you https://gist.github.com/fowlmouth/dbb43f560cdc67cc3601
• xcurry uses getType() to pull a proc's type for currying functions https://gist.github.com/fowlmouth/9b9010397ad5fe4b9872#file-xcurry-nim
• xeq implements an == for object type that properly handles variant types (something the std lib's == does not do correctly) https://gist.github.com/fowlmouth/9b9010397ad5fe4b9872#file-xeq-nim
• interfaces are instances of concept types, getType helps us wrap the functions needed to fulfill some behavior in a nice vtable https://bitbucket.org/fowlsoft/interfaces/wiki/Home

fowlmouth

# here is an implementation of curry, arguments passed are wrapped up in a new 
# closure and a function is returned that accepts the remaining arguments
# usage:
#   proc foo (a,b: int): int = a + b
#   let f = curry(foo, 10)
#   assert f(10) == 20
#
# note: to use an overloaded function you must annotate its type
#   curry((proc(c:char,len:int):string)strutils.repeat, 'x') 
#

fowlmouth

BracketExpr(Sym(typeDesc), Sym(test_obj))
  ObjectTy(Empty(), RecList(Sym(x), Sym(y), Sym(z), Sym(a)))
  x:int
  y:float
  z:string
  a:array[range[0, 4], int]

BracketExpr(Sym(typeDesc), BracketExpr(Sym(array), BracketExpr(Sym(range), IntLi
t(0), IntLit(4)), Sym(int)))

fowlmouth

Call
  Sym "m"
  IntLit 1
  HiddenStdConv
    Empty
    Bracket
      StrLit str
      FloatLit 4.3
      Sym "x"
Bracket

fowlmouth

import macros


macro foo (t: expr): stmt =
  t.treerepr.echo
  t.getType.typeKind.echo
  quit 0

fowlmouth

type MyObj = ref object of RootObj

method output(self:  MyObj) =
    echo "Output something"

type ChildObj = ref object of MyObj
    customvar: string

method newOutput(self: ChildObj) =
    self.customvar = "Child output custom var too"

fowlmouth

import macros

dumptree:
  type x = array[0..1, int]

macro matrixType (t): expr {.immediate.} = 
  
  let cs = callsite()
  result = t
  var i = len(cs)-1