byRef => byAddr

changelog.md

@@ -59,7 +59,7 @@
   This simplifies code by reducing need for if-else branches around intermediate maybe nil values.
   Eg: `echo ?.n.typ.kind`
 
-- Added `sugar.byRef` allowing a ref syntax for lvalue expressions
+- Added `sugar.byAddr` allowing a ref syntax for lvalue expressions
 
 ## Library changes
 

lib/pure/sugar.nim

@@ -367,8 +367,8 @@ when (NimMajor, NimMinor) >= (1, 1):
 
 proc splitDefinition*(def: NimNode): tuple[lhs: NimNode, rhs: NimNode, exported: bool] {.since: (1,1).} =
   ## allows library constructs such as:
-  ## `byRef: a2=expr`
-  ## `byRef: a2*=expr` (to indicate `export`)
+  ## `byAddr: a2=expr`
+  ## `byAddr: a2*=expr` (to indicate `export`)
   doAssert def.kind == nnkStmtList and def.len == 1
   let def2 = def[0]
   case def2.kind
@@ -383,13 +383,13 @@ proc splitDefinition*(def: NimNode): tuple[lhs: NimNode, rhs: NimNode, exported:
   else: doAssert false, $def2.kind
   expectKind(result.lhs, nnkIdent)
 
-macro byRef*(def: untyped): untyped {.since: (1,1).} =
+macro byAddr*(def: untyped): untyped {.since: (1,1).} =
   ## Defines a ref alias for lvalue expressions. The expression is evaluated
   ## only once, and any side effects will only be evaluated once, at declaration
   ## time.
   runnableExamples:
     var x = @[1,2,3]
-    byRef: x1=x[1]
+    byAddr: x1=x[1]
     x1+=10
     doAssert type(x1) is int and x == @[1,12,3]
 

tests/stdlib/msugar.nim

@@ -6,4 +6,4 @@ type Foo = object
   bar: Bar
 
 var foo*: Foo
-byRef: barx*=foo.bar.x
+byAddr: barx*=foo.bar.x

tests/stdlib/tsugar.nim

@@ -1,30 +1,30 @@
 import sugar
 import macros
 
-block byRefBlock:
+block byAddrBlock:
   var count = 0
   proc identity(a: int): auto =
     block: count.inc; a
   var x = @[1,2,3]
-  byRef: x1=x[identity(1)] # the lvalue expression is evaluated only here
+  byAddr: x1=x[identity(1)] # the lvalue expression is evaluated only here
   doAssert count == 1
   x1 += 10
   doAssert type(x1) is int # use x1 just like a normal variable
   doAssert x == @[1,12,3]
   doAssert count == 1 # count has not changed
-  doAssert compiles (block: byRef: x2=x[0])
-  doAssert not compiles (block: byRef: x2=y[0])
+  doAssert compiles (block: byAddr: x2=x[0])
+  doAssert not compiles (block: byAddr: x2=y[0])
     # correctly does not compile when using invalid lvalue expression
 
 block byPtrfBlock:
   type Foo = object
     x: string
   proc fun(a: Foo): auto =
-    doAssert not compiles (block: byRef: x=a.x)
+    doAssert not compiles (block: byAddr: x=a.x)
   let foo = Foo(x: "asdf")
   fun(foo)
 
-# test byRef with export
+# test byAddr with export
 import ./msugar
 barx += 10
 doAssert $foo == "(bar: (x: 10))"