init

Author: nonnil

Diff for: LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Luca
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Diff for: README.md

@@ -0,0 +1,30 @@
+# resultutils
+[resultutils](https://github.com/nonnil/resultutils) to make [Result](https://github.com/arnetheduck/nim-result) handling easier.
+
+inspired by [optionsutils](https://github.com/PMunch/nim-optionsutils).
+
+## Usage
+
+```nim
+import results, resultutils
+
+func greet(name: string): Result[string, string] =
+  if name.len > 0:
+    return ok("hi, " & name)
+  return err("No name? 😐")
+
+let hiNim: string = match greet "Nim":
+  Ok(greet):
+    greet
+  Err(_):
+    "Oh no! something went wrong 😨"
+
+assert hiNim == "hi, Nim"
+```
+
+more code examples can be found [here](https://github.com/nonnil/resultutils/tree/main/tests)
+
+## Installation
+```bash
+nimble install https://github.com/nonnil/resultutils
+```

Diff for: resultsutils.nimble

@@ -0,0 +1,13 @@
+# Package
+
+version       = "0.1.0"
+author        = "Luca (@nonnil)"
+description   = "Utility macros for easier handling of Result"
+license       = "MIT"
+srcDir        = "src"
+
+
+# Dependencies
+requires "result >= 0.3.0"
+
+requires "nim >= 1.6.0"

Diff for: src/resultutils.nim

@@ -0,0 +1,117 @@
+## Utility macros for easier handling of Result
+import std / [ macros ]
+import results
+
+macro match*(results: untyped, node: untyped): untyped =
+  ## It can be used like a general ``case`` branch, but expect ``Result`` as the first argument.
+  ## 
+  ## Use ``_`` ident for the return value discard.
+  ## 
+  ## ``ident`` is not required for ``void`` type.
+  ## 
+  ## .. code-block:: nim
+  ##   func example(): Result[string, void] =
+  ##     ok("something is ok")
+  ## 
+  ##   match example():
+  ##     Ok(someOk):
+  ##       assert someOk == "something is ok"
+  ##     # not required an ident
+  ##     Err():
+  ##       break
+  ## 
+  ## Assign a content of ``Result`` directly from ``match`` to a variable:
+  ## 
+  ## .. code-block:: nim
+  ##   func greet(name: string): Result[string, string] =
+  ##     if name.len > 0:
+  ##       return ok("hi, " & name)
+  ## 
+  ##     return err("No name? 😐")
+  ## 
+  ##   let msg: string = match greet "Nim":
+  ##     Ok(greet):
+  ##       greet
+  ##     # discard an error content
+  ##     Err(_):
+  ##       "Oh no! something went wrong 😨"
+  ##    
+  ##    assert msg == "hi, Nim"
+  ## 
+  ## more code examples can be found `here<https://github.com/nonnil/resultutils/blob/main/tests/test_match.nim>`_
+
+  expectKind results, { nnkCall, nnkIdent, nnkCommand, nnkDotExpr }
+  expectKind node, nnkStmtList
+
+  type
+    ResultKind = enum
+      Ok
+      Err
+
+  func isResultKind(str: string): bool =
+    case str
+    of $Ok, $Err:
+      true
+
+    else: false
+
+  var
+    okIdent, okBody: NimNode
+    errIdent, errBody: NimNode
+  
+  for child in node:
+    expectKind child, nnkCall 
+    # a case label. expect `Ok` or `Err`.
+    expectKind child[0], nnkIdent
+      
+    let resultType = $child[0]
+    var resultIdent, body: NimNode = nil
+
+    # an ident
+    if child[1].kind == nnkIdent:
+      # a body
+      expectKind child[2], nnkStmtList
+      resultIdent = child[1]
+      body = child[2]
+
+    # if ident is not passed on
+    else:
+      expectKind child[1], nnkStmtList
+      body = child[1]
+
+    if not resultType.isResultKind(): error "Only \"Err\" and \"Ok\" are allowed as case labels"
+    case resultType
+    of $Ok:
+      okIdent = if (resultIdent.isNil) or ($resultIdent == "_"): nil
+                else: resultIdent
+      okBody = body
+
+    of $Err:
+      errIdent = if (resultIdent.isNil) or ($resultIdent == "_"): nil
+                else: resultIdent
+      errBody = body
+
+  let
+    tmp = genSym(nskLet)
+    getSym = bindSym"get"
+    errorSym = bindSym"error"
+
+    # ignore assign if the ident is `_` or nil
+    okAssign = if okIdent.isNil: newEmptyNode()
+               else: quote do:
+      let `okIdent` = `getSym`(`tmp`)
+
+    # ignore assign if the ident is `_` or nil
+    errAssign = if errIdent.isNil: newEmptyNode()
+                else: quote do:
+      let `errIdent` = `errorSym`(`tmp`)
+
+  result = quote do:
+    let `tmp` = `results`
+    if `tmp`.isOk:
+      `okAssign`
+      `okBody`
+    
+    else:
+      `errAssign`
+      `errBody`

Diff for: tests/config.nims

@@ -0,0 +1 @@
+switch("path", "$projectDir/../src")

Diff for: tests/test_match.nim

@@ -0,0 +1,82 @@
+import std / [ unittest ]
+import results
+import ../ src / resultutils
+
+suite "match macro":
+
+  func example(): Result[string, void] =
+    ok("something is ok")
+
+  func greet(name: string): Result[string, string] =
+    if name.len > 0:
+      return ok("hi, " & name)
+    return err("No name? 😐")
+
+  test "general":
+
+    match example():
+      Ok(someOk):
+        check:
+          someOk == "something is ok"
+      Err(_):
+        fail
+    
+  test "with void type":
+
+    func returnVoid(flag: bool): Result[void, void] =
+      if flag:
+        ok()
+      
+      else:
+        err()            
+
+    match returnVoid(true):
+      Ok():
+        checkpoint("void ok")
+      Err():
+        fail
+
+    match returnVoid(false):
+      Ok():
+        fail
+      Err():
+        checkpoint("void err")
+
+  test "assigned from match":
+
+    let msg: string = match example():
+      Ok(someOk):
+        "ok msg"
+      Err():
+        "sorry, error"
+
+    check:
+      msg == "ok msg"
+
+    # test with nnkCommand
+    let hiNim: string = match greet "Nim":
+      Ok(greet):
+        greet
+      Err(_):
+        "Oh no! something went wrong 😨"
+
+    check:
+      hiNim == "hi, Nim"
+
+  test "nested":
+    let msg = match example():
+      Ok(_):
+        let inside = match "Rust".greet():
+          Ok(greet):
+            # check:
+            #   greeted == "hi, Rust"
+            greet
+          Err(_):
+            "internal error"
+        inside
+      Err():
+        fail
+        "external error"
+
+    check:
+      msg == "hi, Rust"