My Go Resolutions for 2017(research.swtch.com)

    > Part of the intended contract for error reporting in Go
    > is that functions include relevant available context,
    > including the operation being attempted (such as the
    > function name and its arguments).

    > Today, there are newer attempts to learn from as well,
    > including Dart, Midori, Rust, and Swift.

   if err != nil {
       return err
   }

    type Error struct {
        Description string
        Cause       error
    }
    
    func NewError(cause error, descriptionFmt string, args ...interface{}) error {
        return Error{
            Description: fmt.Sprintf(descriptionFmt, args...),
            Cause:       cause,
        }
    }
    
    func (me Error) Error() string {
        if me.Cause == nil {
            return me.Description
        }
        return fmt.Sprintf("%v: %v", me.Description, me.Cause.Error())
    }
    
    func RootCause(err error) error {
        if err, ok := err.(Error); ok && err.Cause != nil {
            return RootCause(err.Cause)
        }
        return err
    }

  # A flag. We must start it as `false` because Monte doesn't allow uninitialized names.
  var flag :Bool := false
  def setFlag(value :Bool) :Void:
    flag := value
  # Set the flag to `true` immediately.
  setFlag(true)
  # Set the flag to `false` on the next turn.
  def first := setFlag<-(false)
  # Set the flag to `true` on the next turn.
  def second := setFlag<-(true)
  # And finally, when those two actions are done, use the flag to make a choice.
  when (first, second) ->
    if (flag) { "the flag was true" } else { "the flag was false" }