Having `:` as return type for func/proc is actually consistent. Seeing ":"
means afterward "there's a type for it".
It's the consistent with `var ident: ThisIsTheType` or change that `var`,
`let`, `const` etc.
To reinforce that observation, the argument of function also has `:` for its
type symbol.
Of course there's like `block:` or `if...:` or `for ... :`, but then the block
body can return something that has type like for example
from std/sugar import dump
from std/random import randomize, sample
proc main =
randomize()
let marble = block:
let marbles = ["red", "blue", "green", "yellow", "purple"]
let pick = sample(marbles)
pick
dump marble.type
main()
Run
So the marble has type, because block has type, with that you can immediately
know (or glancing to the last line) to see what kind of type it could have.
Since I often need to look for the last block, traversing the cursor position
for `:` not at fast as `{` in others but it's just a small annoyance.
Visually-wise, it's consistent. Much more consistent than random `->`. I'm
desperately avoiding arrow that could hit me on knee.
