♻ Rework Error Types

[WillXuCodes]

Using errno is slightly obtuse of a way to check what type of error occured, and we currently don't follow convention with "Success" being 0 and errors being non-zero types.

Here's what I'm thinking:

• Enumerate error types to be a more approachable and readable format.
• The new "Success" type should be 0 instead of 1.
• Make a lookup table for the errors to provide some form of error print function.

Looking forwards to seeing how this project goes.

[SizzinSeal]

My concern with modern error handling in C++ is that incorrectly handled errors will throw an exception, and as a result crash the thread on which the exception was thrown. So, here's one solution:

// wraps any value. Can be implicitly cast to its wrapped value
template <typename T>
class Maybe {
  public:
    Maybe(T val,
          std::optional<Error> err = std::nullopt)
              : m_val(val),
                m_err(err) {}

    operator T() {
        return m_val;
    }

    std::optional<Error> get_error() {
        return m_err;
    }

    T get_val() {
        return m_val;
    }

    T m_val;
    std::optional<Error> m_err;
};

an example function using this class:

// example function
Maybe<double> Motor::get_temp() {
  constexpr auto ERROR = 0;
  // 0 is the error code
  if (error) return { ERROR, Error("a specific error has occurred", 0) };
  else return temp;
}

most of the time, users will do this:

double temp = Motor::get_temp();

but they can do this if they want to:

if (auto err = motor.move(100).get_error()) {
    std::cout << *err << std::endl; // prints the error string and code
}

it does mean that function signatures get slightly more complex, but this isn't a big deal imo

Maybe<double> get_temp();
// vs
double get_temp();