int plus2([неявно ExecutionFlow executionFlow], int x)
{
    if (x < 10)
        return RangeError("bla-bla"); // Выход из функции и установка ошибки executionFlow.setError(RangeError("bla-bla"))

    return x + 2; // Просто выход и возврат значения, неявно оборачивается в ReturnValue<int>
}

void foo() { ... }

var y = foo(5);
if (y.success) // проверка, также устанавливает в объекте ReturnValue<int> и ExecutionFlow флажок checked = true
   int z = bar(y); // неявно приводится к int, если перед приведением не проверить success, то программа пишет стек и завершается

if (!foo().success)
   print(executionFlow.stackTrace());
   var error = executionFlow.error();
   print(error.message())
   return error

foo(); // не проверили success, флажок не установился, значит при вызове следующей функции (любой) будет стек и аварийное завершение

try {
  const x = await something();
} catch (e) {
  console.warn(e);
}

  value=method1(args) or method2(args);
  action1(); // если код возврата никем не обрабатывается то компилятор автоматически делает примерно такое
  // { var res=action1(); if (res && executionFlow.NoErrorAllowed && !executionFlow.DisableThisError(here)) return executionFlow.ReturnError(here,res,"action1" ... ); }
  action2() or action2b();
  action3() or ignore;
  action4()

1. Haskell
   
2. F#
   
3. OCaml
   
4. Idris

Option<int> plus(Option<int> x) {
   return x.map(el -> el + 2);
}

try {
   print(x.get());
catch(BadOptionException) {
   print("фигня какая-то");
}

Option<int> a = plus(a); //тут ошибка

Option<string> b = getWeirdString(a); //Внутри getWeirdString мы делаем get у Option и ловим эксепшн

T>Option<int> a = plus(a); //тут ошибка

T>Option<string> b = getWeirdString(a); //Внутри getWeirdString мы делаем get у Option и ловим эксепшн

Option<int> a = x.foo(); //тут ошибка

...

x.bar(); //пытаемся работать с кривым x

T>>Option<int> a = plus(a); //тут ошибка

T>>Option<string> b = getWeirdString(a); //Внутри getWeirdString мы делаем get у Option и ловим эксепшн
NB>

NB>Option<int> a = x.foo(); //тут ошибка

NB>...

NB>x.bar(); //пытаемся работать с кривым x
NB>

int a = -1;
try {
    a = x.foo();
} catch(Exception e) {
   Log.Info("нехорошо вышло, да"); //хрень какая-то с a вышла, но это нас не очень волнует
}

x.bar(); //а обработать проблему с кривым иксом в блоке catch мы забыли

MTD>int plus2([неявно ExecutionFlow executionFlow], int x)
MTD>{
MTD>    if (x < 10)
MTD>        return RangeError("bla-bla"); // Выход из функции и установка ошибки executionFlow.setError(RangeError("bla-bla"))

MTD>    return x + 2; // Просто выход и возврат значения, неявно оборачивается в ReturnValue<int>
MTD>}

MTD>void foo() { ... }
MTD>

MTD>var y = foo(5);
MTD>if (y.success) // проверка, также устанавливает в объекте ReturnValue<int> и ExecutionFlow флажок checked = true
MTD>   int z = bar(y); // неявно приводится к int, если перед приведением не проверить success, то программа пишет стек и завершается

MTD>if (!foo().success)
MTD>   print(executionFlow.stackTrace());
MTD>   var error = executionFlow.error();
MTD>   print(error.message())
MTD>   return error

MTD>foo(); // не проверили success, флажок не установился, значит при вызове следующей функции (любой) будет стек и аварийное завершение
MTD>

Either<Error, Int> plus2([неявно ExecutionFlow executionFlow], int x)
{
    if (x < 10)
        return Left(RangeError("bla-bla"));

    return Right(x + 2);
}

int z = plus2(4).getOrElse { throw WtfException } //если произошла любая ошибка, бросаем исключение. Фигурные скобки - это лямбда.
int z = plus2(4) match {   // если RangeError, бросаем исключение, если другая ошибка - возвращаем -1
  case Right(result) => result
  case Left(RangeError(msg)) => throw WtfException("Error: " + msg)
  case Left(otherError) => -1
}
Either<Error, Int> result = plus2(4)
if (result.isLeft) {
  // ошибка
}
return result.get() // бросит исключение, если ошибка

It is not recommended to use this function for a general try/catch mechanism. The `Result` type is more appropriate to use for functions that can fail on a regular basis. Additionally, this function is not guaranteed to catch all panics, see the "Notes" section below.

отдельная операция
    для списка файлов
        отрываем файл
        пишем данные
        закрываем

Our overall solution was to offer a two-pronged error model. On one hand, you had fail-fast – we called it abandonment – for programming bugs. And on the other hand, you had statically checked exceptions for recoverable errors. The two were very different, both in programming model and the mechanics behind them. Abandonment unapologetically tore down the entire process in an instant, refusing to run any user code while doing so. (Remember, a typical Midori program had many small, lightweight processes.) Exceptions, of course, facilitated recovery, but had deep type system support to aid checking and verification.