Document callable behavior of `static`

[metagn]

The section for static expressions/statements only covers static: doFoo() notation. It should also be shown that it is "callable" and that UFCS works on it, possible examples being static foo(), static(foo()), maybe even foo().static and foo().static().

(I know static behaves like an operator, specifically a prefix only operator like not, but I don't think this would be great to put in the spec)

[kaushalmodi]

@hlaaftana

I created a t.nim as below and ran nim c t.nim, but it failed.

proc hello() = echo "hello"

static: hello() # works

static hello()  # Error: expected: ':', but got: 'hello'

[metagn]

That's because of how the parser treats static as the first term in a top level statement. (static hello()) parses correctly but doesn't compile due to hello returning void. from is the same, it expects import when the first term at top level, but acts as an operator otherwise.

[kaushalmodi]

@hlaaftana OK, then I don't understand what static foo() is supposed to do..

e.g. I understand that static: doFoo() calls doFoo() at the time of compilation. But what is static foo() expected to do?

For example, here's some dummy code.. I am unable to tell what (static getNum()) is doing here.. It seems like it makes no difference whether or not I call static there:

proc getNum(): int = 123

static: echo getNum()

var a = (static getNum())
echo a
a = 222
echo a

var b = getNum()
echo b
b = 222
echo b

[kaushalmodi]

ok.. I think I now understand...

proc getNum(a: int): int = a

static: echo getNum(123)

let inp = 123

var a = getNum(inp)
echo a

var bWorks = (static getNum(123))
echo bWorks

var bFails = (static getNum(inp)) # Error: cannot evaluate at compile time: inp
echo bFails

[kaushalmodi]

So, is my understanding correct, that the static call allows putting a "compile time" qualifier on specific function calls, where the function might not always be called at compile time.

Compared to that, something like below requires that {.compileTime.} declared procs be only called in a way that's always valid at compile-time:

let inp = 123
proc getNum2(a: int): int {.compileTime.} = a
echo getNum2(inp) # Error: request to generate code for .compileTime proc: getNum2