Mirror of forum.nim-lang.org

10503 :: Using Result library

• namngrg (orginal) [2023-09-21T08:05:00+02:00] view original

  I am using the results library (https://github.com/arnetheduck/nim-results)

  This is the function

  
  proc getValue(node: ValuesNode, key: Bytes32) : Result[Bytes32, string] =
    ## Returns the value stored at the given `key`
    if node.values[key[^1]] == nil:
      return err("Value not found")
    else:
      return cast[Bytes32](node.values[key[^1]])
  Run

  I simply want to return the Bytes32 type if everything is correct else return an error but I am not able to return the Bytes32 value

---

• 4n0n4me (orginal) [2023-09-21T12:53:06+02:00] view original

  I think it is unlikely to find other solutions (there are indeed other means to do it, but I think all of them work in similar ways as the Results lib), since Nim is a very strong typed language. You can also use throw newException(...) to throw exceptions, but I guess it is not what you want.

---

• ingo (orginal) [2023-09-21T14:51:39+02:00] view original

  there is std/options where you return some(result in Bytes32) or none(Bytes32) but no string. That than should be a separate message to logger or stderr or ...

---

• Tanguy (orginal) [2023-09-21T16:05:49+02:00] view original

  You are missing the ok in the success path:

  
  proc getValue(node: ValuesNode, key: Bytes32) : Result[Bytes32, string] =
    if node.values[key[^1]] == nil:
      err("Value not found")
    else:
      ok(cast[Bytes32](node.values[key[^1]]))
  Run

  (took the liberty to remove the returns, but that is not necessary)

---

• shirleyquirk (orginal) [2023-09-21T17:55:27+02:00] view original

  i've been working with a Result clone written on top of std::expected, and, while i miss pretty much everything else about nim-result, ive grown to enjoy being able to return a bare T from a function returning Result[T,E]

  #include <expected>
  #include <string>
  using err_t = std::string;
  template<class T> using Result = std::expected<T,err_t>;
  using err = std::unexpected<err_t>;
  
  Result<int> foo(bool x){
      if (x)
        return err("oh noes");
      else
        return 5;
  }
  Run

  if you've got a standard error type in your project like

  type R[T] = Result[T,string]
  Run

  then you can have that implicit conversion, too, for good or ill, with

  converter toR[T](x:T):R[T] = ok(x)
  
  proc foo(x:bool):Result[int,string] =
    if x:
      err("oh noes")
    else:
      5
  Run

  but embracing strict typing is more the Nim way

---