type exitError struct {
  err error
  exitCode int
}

func (e exitError) Error() string {
  return e.err.Error()
}

func (e exitError) ExitCode() int {
  return e.exitCode
}

func (e exitError) Unwrap() error {
  return err.err
}

// This could be a preferred alternative to Exit, or just an alternative.
func WrapErrorWithExitCodeButAlsoWithBetterFunctionName(err error, exitCode int) error {
  return exitError{
    err: err,
    exitCode: exitCode,
  }
}

// Exit can now return the new version of the unexported type without breaking the interface
func Exit(message interface{}, exitCode int) ExitCoder {
  // If we wanted to get fancy here, we could check if the "message"
  // was already an error, and if so, wrap it. I'm coding in GitHub so
  // I'm not going to write it out, but I recommend it

  return exitError{
    err:  fmt.Errorf("%v", message),
    exitCode: exitCode,
  }
}

// Exit returns an ExitCoder. If err is an error then it is directly wrapped, otherwise err is
// treated as an error message and a new error is created.
//
// This is done to be backwards comparable with previous v2 versions.
func Exit(err interface{}, exitCode int) ExitCoder {
    if e, ok := err.(error); ok {
        return exitError {
            err: e,
            exitCode: exitCode,
        }
    }

    return exitError {
        err: fmt.Errorf("%v", message),
        exitCode: exitCode,
    }
}