Version:	1.0.0
Author:	luxick <op@luxick.de>

OP stands for "Operation Result".

This module contains a generic type that can be used as a return type for operations that could fail. It adds additional messages to the result.

This module improves upon the options module in that additional messages can be passed along with the presence or absence of a value.

Basic Usage

proc divide(a, b: int): OP[float] =
  ## This could fail
  if b == 0:
    return fail "Cannot divide by zero!"
  else:
    return ok a / b   # Wrap the result

let r = divide(42, 0)
assert r.isOk == false
assert r.error == "Cannot divide by zero!"

Types

Either[A; B] = object case isA*: bool of true: a*: A of false: b*: B

An Either object can hold either one value or the other, but never both

OP[T] = Either[T, string]

Object to wrap the result of an operation. Alias of Either with a string as error message

The type is discriminated by the isOK bool. So it is an compiler error to try to access the value without checking if the operation was successful.

isOk: Indicates if the operation was successful
val: If successful, this will hold the real result value
error: Otherwise this will hold an error message

Templates

template checkA(self: Either): bool

template getA[A; B](self: Either[A, B]): A

template getB[A; B](self: Either[A, B]): B

template isOK(self: OP): bool

template val(self: OP): auto

template error(self: OP): auto

template ok[T](val: T): OP[T]

Wraps the given value in a successful operation result.

template ok[T](self: var OP[T]; val: T)

Set the result to the given value

template fail[T; ](O: type OP[T]; msg: string): O:type

Will create a new operation result with the given error message. The type for the operation result is given explicitly.

See Also:

fail proc
fail template

template fail(T: typedesc; msg: string): OP[T]

Will create a new operation result with the given error message. The type for the operation result is given explicitly.

See Also:

fail proc
fail template

template fail(op: OP; msg: string): OP

Will create a new operation result with the given error message. The type for the operation result is taken from the op argument.

Examples:

proc someProc(): OP[int] =
  result.fail "Not implemented!"

let data = someProc()
assert data.isOk == false
assert data.error == "Not implemented!"

template fail(msg: static[string]): auto