diff --git a/questionable/binding.nim b/questionable/binding.nim
index 488caa2..bdd0ee1 100644
--- a/questionable/binding.nim
+++ b/questionable/binding.nim
@@ -30,14 +30,50 @@ template bindVar(name, expression): bool =
     placeholder(T)
   option.isSome
 
+proc newUnpackTupleNode(names: NimNode, value: NimNode): NimNode =
+  # builds tuple unpacking statement, eg: let (a, b) = value
+  let vartuple = nnkVarTuple.newTree()
+  for i in 0..<names.len:
+    vartuple.add names[i]
+  vartuple.add newEmptyNode()
+  vartuple.add value
+  nnkLetSection.newTree(vartuple)
+
+macro bindTuple(names, expression): bool =
+  let opt = ident("option")
+  let evaluated = ident("evaluated")
+  let T = ident("T")
+
+  let value = quote do:
+    if `opt`.isSome:
+      `opt`.unsafeGet()
+    else:
+      bindFailed(`evaluated`)
+      placeholder(`T`)
+
+  let letsection = newUnpackTupleNode(names, value)
+
+  quote do:
+    let `evaluated` = `expression`
+    let `opt` = `evaluated`.option
+    type `T` = typeof(`opt`.unsafeGet())
+    `letsection`
+    `opt`.isSome
+
 macro `=?`*(name, expression): bool =
   ## The `=?` operator lets you bind the value inside an Option or Result to a
   ## new variable. It can be used inside of a conditional expression, for
   ## instance in an `if` statement.
 
-  name.expectKind({nnkIdent, nnkVarTy})
+  when (NimMajor, NimMinor) < (1, 6):
+    name.expectKind({nnkIdent, nnkVarTy, nnkTupleConstr, nnkPar})
+  else:
+    name.expectKind({nnkIdent, nnkVarTy, nnkTupleConstr})
+
   if name.kind == nnkIdent:
     quote do: bindLet(`name`, `expression`)
+  elif name.kind == nnkTupleConstr or name.kind == nnkPar:
+    quote do: bindTuple(`name`, `expression`)
   else:
     let name = name[0]
     quote do: bindVar(`name`, `expression`)
diff --git a/testmodules/options/test.nim b/testmodules/options/test.nim
index f0699bb..e79140c 100644
--- a/testmodules/options/test.nim
+++ b/testmodules/options/test.nim
@@ -165,6 +165,82 @@ suite "optionals":
     else:
       fail()
 
+  test "=? binds and unpacks tuples":
+    if (a, b) =? (some ("test", 1)):
+      check a == "test"
+      check b == 1
+    else:
+      fail()
+
+    if (a, b) =? none (string, int):
+      discard a
+      discard b
+      fail()
+
+  test "=? binds and unpacks tuples with named fields":
+    if (a, b) =? (some (desc: "test", id: 1)):
+      check a == "test"
+      check b == 1
+    else:
+      fail()
+
+  test "=? binds and unpacks tuples returned from proc":
+    proc returnsTuple(): ?tuple[name: string, id: int] = some ("test", 1)
+
+    if (a, b) =? returnsTuple():
+      check a == "test"
+      check b == 1
+    else:
+      fail()
+
+  test "=? binds and unpacks tuples returned from proc with unnamed fields":
+    proc returnsTuple(): ?(string, int,) = some ("test", 1,)
+
+    if (a, b,) =? returnsTuple():
+      check a == "test"
+      check b == 1
+    else:
+      fail()
+
+  test "=? binds and unpacks tuples with _":
+    if (_, b) =? some ("test", 1):
+      check b == 1
+    else:
+      fail()
+
+  test "=? binds and unpacks tuples with named fields":
+    if (a, b) =? some (desc: "test", id: 1):
+      check a == "test"
+      check b == 1
+    else:
+      fail()
+
+  test "=? binds variable to tuples with named fields":
+    if t =? some (desc: "test", id: 1):
+      check t.desc == "test"
+      check t.id == 1
+    else:
+      fail()
+
+  test "=? binds to tuple types":
+    type MyTuple = tuple
+      desc: string
+      id: int
+
+    let mt: MyTuple = ("test", 1)
+
+    if t =? (some mt):
+      check t.desc == "test"
+      check t.id == 1
+    else:
+      fail()
+
+    if (a, b) =? (some mt):
+      check a == "test"
+      check b == 1
+    else:
+      fail()
+
   test "without statement can be used for early returns":
     proc test1 =
       without a =? 42.some:
diff --git a/testmodules/result/test.nim b/testmodules/result/test.nim
index 169d915..66aa2d6 100644
--- a/testmodules/result/test.nim
+++ b/testmodules/result/test.nim
@@ -165,6 +165,82 @@ suite "result":
 
     check called
 
+  test "=? binds and unpacks tuples":
+    if (a, b) =? (success ("test", 1)):
+      check a == "test"
+      check b == 1
+    else:
+      fail()
+
+    if (a, b) =? (string, int).failure(error):
+      discard a
+      discard b
+      fail()
+
+  test "=? binds and unpacks tuples with named fields":
+    if (a, b) =? (success (desc: "test", id: 1)):
+      check a == "test"
+      check b == 1
+    else:
+      fail()
+
+  test "=? binds and unpacks tuples returned from proc":
+    proc returnsTuple(): ?!tuple[name: string, id: int] = success ("test", 1)
+
+    if (a, b) =? returnsTuple():
+      check a == "test"
+      check b == 1
+    else:
+      fail()
+
+  test "=? binds and unpacks tuples returned from proc with unnamed fields":
+    proc returnsTuple(): ?!(string, int,) = success ("test", 1,)
+
+    if (a, b,) =? returnsTuple():
+      check a == "test"
+      check b == 1
+    else:
+      fail()
+
+  test "=? binds and unpacks tuples with _":
+    if (_, b) =? success ("test", 1):
+      check b == 1
+    else:
+      fail()
+
+  test "=? binds and unpacks tuples with named fields":
+    if (a, b) =? success (desc: "test", id: 1):
+      check a == "test"
+      check b == 1
+    else:
+      fail()
+
+  test "=? binds variable to tuples with named fields":
+    if t =? success (desc: "test", id: 1):
+      check t.desc == "test"
+      check t.id == 1
+    else:
+      fail()
+
+  test "=? binds to tuple types":
+    type MyTuple = tuple
+      desc: string
+      id: int
+
+    let mt: MyTuple = ("test", 1)
+
+    if t =? (success mt):
+      check t.desc == "test"
+      check t.id == 1
+    else:
+      fail()
+
+    if (a, b) =? (success mt):
+      check a == "test"
+      check b == 1
+    else:
+      fail()
+
   test "without statement works for results":
     proc test1 =
       without a =? 42.success: