Mirror of forum.nim-lang.org

4211 :: Please help me to understand templates in nim

• kcvinu (orginal) [2018-09-20T15:08:33+02:00] view original

  Hi all, I am trying to learn templates in nim. This code is from nim tutorial.

  template `!=` (a, b: untyped): untyped =
    # this definition exists in the System module
    not (a == b)
  
  assert(5 != 6) # the compiler rewrites that to: assert(not (5 == 6))
  Run

  Here i have an example to understand how templates works. I can understand that the "!=" works an operator here. But i am confused with this example.

  const
    debug = true
  
  template log(msg: string) =
    if debug: stdout.writeLine(msg)
  
  var
    x = 4
  log("x has the value: " & $x)
  Run

  Here, template named "log" behaves like a proc. So how compiler understands this behavioral change ? And see this example from winim's github page.

  template `<<`(p: ptr char | ptr byte | cstring; s: mstring | string)
  Run

  They are saying that this will "Fill buffer by string." But how to use in our code. All i know about creating stringBuffer is like this;

  char myStr[5] ;
  # this C code can convert into nim like this;
  var myStr = newStringOfCap(5)
  Run

  OK, so, i have created a string buffer. Now, how can i use the above said template in this string buffer ? Like this ?

  myStr << "test"
  Run

  Is this the proper way to use of this template ?

---

• kcvinu (orginal) [2018-09-20T15:13:12+02:00] view original

  Does the "``" symbol (Acute symbol) is the one which differentiate the template from a proc and an operator

---

• DeletedUser (orginal) [2018-09-20T16:59:49+02:00] view original

  Procs can be operators as well as templates, and yes, the backticks make them operators.

---

• Stefan_Salewski (orginal) [2018-09-20T18:09:56+02:00] view original

  and yes, the backticks make them operators

  I think that wording is very wrong and lead to confusion for beginners.

  When I remember correctly, operator names can not be arbitrary letters, but only a combination of the operator chars like +-!< and many more. So we can not do

  proc `mySpecialPlus`(a, b: int): int =
  
  Run

  mySpecialPlus() is not an operator as its name is built with ordinary letters, and the surrounding backticks will not make it one.

---

• Araq (orginal) [2018-09-20T20:46:06+02:00] view original

  Let me try to explain it:

  • Nim has templates, procs, methods etc. These are sometimes subsumed under the term "routine".
  • Most of Nim's syntax consists of "routine calls".

  For a routine f (where f is an ordinary identifier consisting of letters) a call can be written as

  
  f a
  f(a)
  a.f
  Run

  For a routine @ (where @ is an operator symbol consisting of special characters) a call can be writen as:

  
  @a # unary operator call; only receives one argument
  a @ b  # binary operator call; receives two arguments
  `@`(a, b) # backticks to use the "ordinary" routine syntax
  a.`@`(b) # method invokation syntax, allowed for consistency
  Run

  And that's it, the syntax is independent of the concrete routine kind, whether it's a proc, a template, an iterator does not matter for the syntax.

---

• juancarlospaco (orginal) [2018-09-20T23:01:39+02:00] view original

  You are mixing a lot of Nim stuff on the same question, and get confused.

  Function calls:

  echo "a"
  echo("b")
  echo"c"
  "d".echo
  "e".echo()
  Run

  • echo"c" is equal to echo( r"c" ).

  The minimal possible example of Templates:

  template mini(body: untyped) =
    body
  
  mini():
    echo "foo"
  Run

  • Makes no sense, but still works.

  template times(integer: int, code_to_repeat: untyped): untyped =
    for i in 1..integer:
      code_to_repeat
  
  10.times:
    echo "This repeats 10 times"
  Run

  • Templates actually does something.

---