Better type annotations for ->? operator

questionable/options.nim

@@ -10,19 +10,17 @@ export chaining
 template `?`*(T: typed): type Option[T] =
   Option[T]
 
-template `->?`*(option: ?typed, expression: untyped): untyped =
+template `->?`*[T,U](option: ?T, expression: U): ?U =
-  type T = type expression
   if option.isSome:
     expression.some
   else:
-    T.none
+    U.none
 
-template `->?`*(options: (?typed, ?typed), expression: untyped): untyped =
+template `->?`*[T,U,V](options: (?T, ?U), expression: V): ?V =
-  type T = type expression
   if options[0].isSome and options[1].isSome:
     expression.some
   else:
-    T.none
+    V.none
 
 template `=?`*[T](name: untyped{nkIdent}, option: ?T): bool =
   template name: T {.used.} = option.unsafeGet()

questionable/results.nim

@@ -15,19 +15,17 @@ proc success*[T](value: T): ?!T =
 proc failure*(T: type, error: ref CatchableError): ?!T =
   err(?!T, error)
 
-template `->?`*(option: ?!typed, expression: untyped): untyped =
+template `->?`*[T,U](value: ?!T, expression: U): ?!U =
-  type T = type expression
+  if value.isErr:
-  if option.isErr:
+    U.failure(value.error)
-    T.failure(option.error)
   else:
     expression.success
 
-template `->?`*(options: (?!typed, ?!typed), expression: untyped): untyped =
+template `->?`*[T,U,V](values: (?!T, ?!U), expression: V): ?!V =
-  type T = type expression
+  if values[0].isErr:
-  if options[0].isErr:
+    V.failure(values[0].error)
-    T.failure(options[0].error)
+  elif values[1].isErr:
-  elif options[1].isErr:
+    V.failure(values[1].error)
-    T.failure(options[1].error)
   else:
     expression.success