Source Edit

This module implements nice syntactic sugar based on Nim’s macro system.

Imports

since, macros, underscored_calls

Macros

  1. macro `->`(p, b: untyped): untyped

Syntax sugar for procedure types. It also supports pragmas.

Warning: Semicolons can not be used to separate procedure arguments.

Example:

  1. proc passTwoAndTwo(f: (int, int) -> int): int = f(2, 2)
  2. # is the same as:
  3. # proc passTwoAndTwo(f: proc (x, y: int): int): int = f(2, 2)
  5. assert passTwoAndTwo((x, y) => x + y) == 4
  7. proc passOne(f: (int {.noSideEffect.} -> int)): int = f(1)
  8. # is the same as:
  9. # proc passOne(f: proc (x: int): int {.noSideEffect.}): int = f(1)
  11. assert passOne(x {.noSideEffect.} => x + 1) == 2

Source Edit 

  1. macro `=>`(p, b: untyped): untyped

Syntax sugar for anonymous procedures. It also supports pragmas.

Warning: Semicolons can not be used to separate procedure arguments.

Example:

  1. proc passTwoAndTwo(f: (int, int) -> int): int = f(2, 2)
  3. assert passTwoAndTwo((x, y) => x + y) == 4
  5. type
  6.   Bot = object
  7.     call: (string {.noSideEffect.} -> string)
  9. var myBot = Bot()
  11. myBot.call = (name: string) {.noSideEffect.} => "Hello " & name & ", I'm a bot."
  12. assert myBot.call("John") == "Hello John, I'm a bot."
  14. let f = () => (discard) # simplest proc that returns void
  15. f()

Source Edit 

  1. macro capture(locals: varargs[typed]; body: untyped): untyped

Useful when creating a closure in a loop to capture some local loop variables by their current iteration values.

Example:

  1. import std/strformat
  3. var myClosure: () -> string
  4. for i in 5..7:
  5.   for j in 7..9:
  6.     if i * j == 42:
  7.       capture i, j:
  8.         myClosure = () => fmt"{i} * {j} = 42"
  9. assert myClosure() == "6 * 7 = 42"

Source Edit 

  1. macro collect(body: untyped): untyped

Same as collect but without an init parameter.

See also:

Example:

  1. import std/[sets, tables]
  2. let data = @["bird", "word"]
  4. # seq:
  5. let k = collect:
  6.   for i, d in data.pairs:
  7.     if i mod 2 == 0: d
  8. assert k == @["bird"]
  10. ## HashSet:
  11. let n = collect:
  12.   for d in data.items: {d}
  13. assert n == data.toHashSet
  15. ## Table:
  16. let m = collect:
  17.   for i, d in data.pairs: {i: d}
  18. assert m == {0: "bird", 1: "word"}.toTable

Source Edit 

  1. macro collect(init, body: untyped): untyped

Comprehension for seqs/sets/tables.

The last expression of body has special syntax that specifies the collection’s add operation. Use {e} for set’s incl, {k: v} for table’s []= and e for seq’s add.

Example:

  1. import std/[sets, tables]
  3. let data = @["bird", "word"]
  5. ## seq:
  6. let k = collect(newSeq):
  7.   for i, d in data.pairs:
  8.     if i mod 2 == 0: d
  9. assert k == @["bird"]
  11. ## seq with initialSize:
  12. let x = collect(newSeqOfCap(4)):
  13.   for i, d in data.pairs:
  14.     if i mod 2 == 0: d
  15. assert x == @["bird"]
  17. ## HashSet:
  18. let y = collect(initHashSet()):
  19.   for d in data.items: {d}
  20. assert y == data.toHashSet
  22. ## Table:
  23. let z = collect(initTable(2)):
  24.   for i, d in data.pairs: {i: d}
  25. assert z == {0: "bird", 1: "word"}.toTable

Source Edit 

  1. macro dump(x: untyped): untyped

Dumps the content of an expression, useful for debugging. It accepts any expression and prints a textual representation of the tree representing the expression - as it would appear in source code - together with the value of the expression.

See also: dumpToString which is more convenient and useful since it expands intermediate templates/macros, returns a string instead of calling echo, and works with statements and expressions.

Example: cmd: -r:off

  1. let
  2.   x = 10
  3.   y = 20
  4. dump(x + y) # prints: `x + y = 30`

Source Edit 

  1. macro dumpToString(x: untyped): string

Returns the content of a statement or expression x after semantic analysis, useful for debugging.

Example:

  1. const a = 1
  2. let x = 10
  3. assert dumpToString(a + 2) == "a + 2: 3 = 3"
  4. assert dumpToString(a + x) == "a + x: 1 + x = 11"
  5. template square(x): untyped = x * x
  6. assert dumpToString(square(x)) == "square(x): x * x = 100"
  7. assert not compiles dumpToString(1 + nonexistent)
  8. import std/strutils
  9. assert "failedAssertImpl" in dumpToString(assert true) # example with a statement

Source Edit 

  1. macro dup[T](arg: T; calls: varargs[untyped]): T

Turns an in-place algorithm into one that works on a copy and returns this copy, without modifying its input.

This macro also allows for (otherwise in-place) function chaining.

Since: Version 1.2.

Example:

  1. import std/algorithm
  3. let a = @[1, 2, 3, 4, 5, 6, 7, 8, 9]
  4. assert a.dup(sort) == sorted(a)
  6. # Chaining:
  7. var aCopy = a
  8. aCopy.insert(10)
  9. assert a.dup(insert(10), sort) == sorted(aCopy)
  11. let s1 = "abc"
  12. let s2 = "xyz"
  13. assert s1 & s2 == s1.dup(&= s2)
  15. # An underscore (_) can be used to denote the place of the argument you're passing:
  16. assert "".dup(addQuoted(_, "foo")) == "\"foo\""
  17. # but `_` is optional here since the substitution is in 1st position:
  18. assert "".dup(addQuoted("foo")) == "\"foo\""
  20. proc makePalindrome(s: var string) =
  21.   for i in countdown(s.len-2, 0):
  22.     s.add(s[i])
  24. let c = "xyz"
  26. # chaining:
  27. let d = dup c:
  28.   makePalindrome # xyzyx
  29.   sort(_, SortOrder.Descending) # zyyxx
  30.   makePalindrome # zyyxxxyyz
  31. assert d == "zyyxxxyyz"

Source Edit