Nate Ackerman's questions

Estou tentando usar nnkDotExpr em uma macro e estou recebendo um erro. Especificamente, estou tentando escrever uma macro que escreverá um procedimento que retorne um campo específico. Eu tentei três abordagens que parecem falhar e não sei por quê.

Este é o código que tenho.

import macros 

type
    Test_Type = object of RootObj
        Name_HIDDEN: string

macro Name_MacroA*(vType: untyped): untyped =
    var tName = nnkDotExpr(ident("self"), ident("Name_HIDDEN"))
    
    quote do:
        proc Name*(self: var `vType`): string =
            return `tName`

macro Name_MacroB*(vType: untyped): untyped =
    var tName = newNimNode(nnkDotExpr)
    tName.add(ident("self"))
    tName.add(ident("Name_HIDDEN"))

    quote do:
        proc Name*(self: var `vType`): string =
            return `tName`

macro Name_MacroC*(vType: untyped): untyped =
    var tName = nnkDotExpr.newTree(ident("self"), ident("Name_HIDDEN"))

    quote do:
        proc Name*(self: var `vType`): string =
            return `tName`

Name_MacroB(Test_Type)

var tTest: Test_Type
tTest.Name_HIDDEN = "Hello"
echo tTest.Name

Quando uso Name_MacroA recebo o erro:

Error: attempting to call routine: 'nnkDotExpr'
  found 'nnkDotExpr' [enumField declared in /usr/local/Cellar/nim/2.0.0_1/nim/lib/core/macros.nim(45, 5)]

Name_MacroA é uma tentativa de corresponder ao código da referência nnkDotExpr em Nim Macros .

Quando uso Name_MacroB ou Name_MacroC recebo o erro:

template/generic instantiation of `Name_MacroB` from here test4.nim(17, 20) Error: undeclared identifier: 'self'
candidates (edit distance, scope distance); see '--spellSuggest': 
 (2, 4): 'del'
 (2, 4): 'ref'
 (2, 4): 'send'

Name_MacroB é uma tentativa de corresponder ao código do Nim Macros

Name_MacroC é uma tentativa de combinar o código do Nim Macros

Trabalhando no Nim, minha intuição para templates é que, em tempo de compilação, eles são simplesmente expandidos em seu código (com as devidas substituições). Mas o seguinte código:

type
    New_Type = ref object of RootObj

template Template_Procedure(T: untyped, vProc: bool = true) = 

    proc ProcedureA(self:var T, vInt: var int): int 

    when vProc == true:
        proc ProcedureA(self:var T, vInt: var int): int =
            var tReturn = vInt * vInt 
            return tReturn

    proc ProcedureB(self: var T, vInt: var int): int = 
        var tI = ProcedureA(self, vInt)
        return 2 * tI 

Template_Procedure(New_Type, vProc = false)

proc ProcedureA(self:var New_Type, vInt: var int): int =
    var tReturn = vInt * vInt * vInt
    return tReturn

var tNew = new(New_Type)
var tInt = 5
echo $ProcedureB(tNew, tInt)    

dá o erro:

test3.nim(9, 10) Error: implementation of 'test3.ProcedureA(self`gensym0: var New_Type, vInt`gensym0: var int)' expected

Se, no entanto, eu ligar

Template_Procedure(New_Type, vProc = true)

então não há erros.

Por outro lado, se eu substituir manualmente o texto do modelo no local onde ele é chamado, ocorre o oposto. Ou seja, o código é compilado se eu substituir false por vProc e receber o erro

Error: redefinition of 'ProcedureA'; previous declaration

se eu substituir true por vProc.

Alguém pode me explicar onde minha intuição está incorreta em relação aos modelos? (ou me dê referências apropriadas)

Além disso, existe uma maneira de escrever código que em tempo de compilação seja simplesmente expandido?

Especificamente, eu gostaria de poder chamar Template_Procedure(X, vProc = false) onde X é um tipo e então, para os tipos X apropriados, escrever manualmente

ProcedureA(self: var X, vInt var int): int

procedimentos. E para outro X basta chamar Template_Procedure(X) e não precisar definir manualmente o ProcedureA.