RedOnion

Error handling

throw and raise are for error propagation and can be used with any object/value. try, catch and finally are for handling errors (including exceptions originating from C# code).

throw and raise work the same, throw is from C#/Java, raise from Python, both exist in Ruby, but with different meanings (there is no rescue in ROS). Python uses except instead of catch (which can be added in future ROS version - consider it reserved keyword).

Catch

The following code will return true:

try                 // start of error-handling block
  throw true        // throw/raise error to be propagated
  return false      // not executed because of the error above
catch var e         // handle error (if there is one)
  return e          // do something with the error-object/value

catch may be followed by variable declaration (var e) so that the following code can use the error-object/value for some logic (e.g. e.message for C# exceptions), but that is optional, simple catch without var ... will also work (if you do not care what the error is).

Future plan: catch var e:type and catch type

Finally

finally is designed for cleanup - to ensure that the code inside is always executed, regardless of any error/exception. It can be combined with catch but does not have to:

var wnd = new ui.window
var err = null
try
  something
catch var e
  err = e
finally
  wnd.dispose
if err != null
  print err

C# does not allow return inside finally, but Java does, so ROS allows it too:

def test
  try
    if true         // raise/throw can be inside any block
      raise "error" // errors propagate until caught
  finally
    return null     // would return null if no exception
    irrelevant      // never gets executed
try
  test              // the raised/thrown "error" is propagated
catch var e         // until caught here
  print e
  throw e           // and can be rethrown / raised again