Evaluate =? expressions only once

questionable/options.nim

@@ -23,17 +23,19 @@ template `->?`*[T,U,V](options: (?T, ?U), expression: V): ?V =
   else:
     V.none
 
-template `=?`*[T](name: untyped{nkIdent}, option: ?T): bool =
+template `=?`*[T](name: untyped{nkIdent}, expression: ?T): bool =
+  let option = expression
   template name: T {.used.} = option.unsafeGet()
   option.isSome
 
-macro `=?`*[T](variable: untyped{nkVarTy}, option: ?T): bool =
+macro `=?`*[T](variable: untyped{nkVarTy}, expression: ?T): bool =
   let name = variable[0]
   quote do:
-    var `name` : typeof(`option`.unsafeGet())
+    let option = `expression`
-    if `option`.isSome:
+    var `name` : typeof(option.unsafeGet())
-      `name` = `option`.unsafeGet()
+    if option.isSome:
-    `option`.isSome
+      `name` = option.unsafeGet()
+    option.isSome
 
 template `|?`*[T](option: ?T, fallback: T): T =
   if option.isSome:

questionable/results.nim

@@ -38,17 +38,19 @@ template `->?`*[T,U,V](values: (?!T, ?!U), expression: V): ?!V =
 template `|?`*[T](value: ?!T, fallback: T): T =
   value.valueOr(fallback)
 
-template `=?`*[T](name: untyped{nkIdent}, value: ?!T): bool =
+template `=?`*[T](name: untyped{nkIdent}, expression: ?!T): bool =
+  let value = expression
   template name: T {.used.} = value.unsafeGet()
   value.isOk
 
-macro `=?`*[T](variable: untyped{nkVarTy}, option: ?!T): bool =
+macro `=?`*[T](variable: untyped{nkVarTy}, expression: ?!T): bool =
   let name = variable[0]
   quote do:
-    var `name` : typeof(`option`.unsafeGet())
+    let value = `expression`
-    if `option`.isOk:
+    var `name` : typeof(value.unsafeGet())
-      `name` = `option`.unsafeGet()
+    if value.isOk:
-    `option`.isOk
+      `name` = value.unsafeGet()
+    value.isOk
 
 proc option*[T,E](value: Result[T,E]): ?T =
   if value.isOk:

testmodules/options/test.nim

@@ -87,6 +87,17 @@ suite "optionals":
     if var a =? int.none:
       fail
 
+  test "=? evaluates optional expression only once":
+    var count = 0
+    if a =? (inc count; 42.some):
+      let b {.used.} = a
+    check count == 1
+
+    count = 0
+    if var a =? (inc count; 42.some):
+      let b {.used.} = a
+    check count == 1
+
   test "unary operator `-` works for options":
     check -(-42.some) == 42.some
     check -(int.none) == int.none

testmodules/result/test.nim

@@ -91,6 +91,17 @@ suite "result":
     if var a =? int.failure(error):
       fail
 
+  test "=? evaluates optional expression only once":
+    var count = 0
+    if a =? (inc count; 42.success):
+      let b {.used.} = a
+    check count == 1
+
+    count = 0
+    if var a =? (inc count; 42.success):
+      let b {.used.} = a
+    check count == 1
+
   test "catch can be used to convert exceptions to results":
     check parseInt("42").catch == 42.success
     check parseInt("foo").catch.error of ValueError