Mirror of forum.nim-lang.org

7455 :: enforcing a const or literal in a proc parameter?

• JohnAD (orginal) [2021-01-31T20:31:48+01:00] view original

  I apologize for bugging folks if this is already answered in the docs somewhere.

  Is there there a way to enforce that the parameter to a procedure is resolvable at compile time?

  Or, if not that, that the passed in parameter is a string literal?

  Something like:

  proc fooBar(a: const string): string =
    # stuff about `a` goes here blah blah
    result = "[" & a & "]"
  
  const hello = "hello"
  var maybeHello = "hello"
  
  var x = fooBar("hello")     # good
  var y = fooBar(hello)       # also good
  var z = fooBar(maybeHello)  # generates a compile-time error
  Run

  I know I can do this via a macro, but am curious if there is some way to do this with a proc.

---

• Yardanico (orginal) [2021-01-31T20:34:16+01:00] view original

  Yep, there's AST-based overloading in Nim :)

  proc fooBar(a: string{lit|`const`}): string =
    # stuff about `a` goes here blah blah
    result = "[" & a & "]"
  
  const hello = "hello"
  var maybeHello = "hello"
  
  var x = fooBar("hello")     # good
  var y = fooBar(hello)       # also good
  var z = fooBar(maybeHello)  # generates a compile-time error
  Run

  See https://nim-lang.org/docs/manual_experimental.html#ast-based-overloading

---

• inventormatt (orginal) [2021-01-31T20:37:18+01:00] view original

  for another non experimental option using static may also achieve the same result you are looking for

  proc fooBar(a: static string): string =
    # stuff about `a` goes here blah blah
    result = "[" & a & "]"
  
  const hello = "hello"
  var maybeHello = "hello"
  
  var x = fooBar("hello")     # good
  var y = fooBar(hello)       # also good
  var z = fooBar(maybeHello)  # generates a compile-time error
  Run

---

• exelotl (orginal) [2021-01-31T21:07:31+01:00] view original

  If I understand correctly: whenever code size is a consideration the "AST-based overloading" solution may be preferable, because the static solution would result in a new version of the proc being created for each different value it's called with. On other other hand, if code size is not a consideration, it's probably best to go with static because it's a more stable / future-proof.

---

• mratsim (orginal) [2021-02-01T11:22:05+01:00] view original

  • another non experimental option using static
  • it's probably best to go with static because it's a more stable / future-proof.

  Now you've done it @Araq, @zahary, static is considered stable! Time sure flies.

---