var value = Add(2,3)?

Result<int> result = Add(2,3);
if (result.is_err())
     return result
T value = result.ok();

fn try_to_parse() -> Result<i32, ParseIntError> {
    let x: i32 = "123".parse()?; // x = 123
    let y: i32 = "24a".parse()?; // returns an Err() immediately
    Ok(x + y)                    // Doesn't run.
}

data ApplicationException =
      ReadException
    | WriteException

instance ThrowsRead ApplicationException where
    throwRead = ReadException

instance ThrowsWrite ApplicationException where
    throwWrite = WriteException

final String content;
try {
  content = readFile(...);
} catch (IOException e) {
  throw new ReadException();
}

final String content;
try {
  writeFile(...);
} catch (IOException e) {
  throw new WriteException();
}

data ApplicationException =
      ReadException IOException
    | WriteException IOException

data InputException =
     FileDoesNotExist
   | ReadProtected
   deriving (Show, Eq, Enum)

data OutputException =
     DiskFull
   | FileCountNotBeCreated
   | WriteProtected
   | NoSpaceOnDevice
   deriving (Show, Eq, Enum)   deriving (Show, Eq, Enum)

data ApplicationException =
      ReadException InputException
    | WriteException OutputException

copyFile src dst =
    writeFile dst =<< readFile src

consumeFile src consumer =
    consumer =<< readFile src
copyFile src dst = consumeFile src (writeFile dst)

applyTemplate :: String => String => Exceptional TemplateApplicationIssue String
applyTemplate template data =
  do
    parsedTemplate <- liftTemplateErrors(parseTemplate template)
    parsedData <- liftDataErrors(parseData data)
    return (applyTemplateToData parsedTemplate parsedData)


applyFileTemplate templateFile dataFile =
  do
    template <- readFile templateFile
    data <- readFile dataFile
    return (applyTemplate template data)

parseTemplate :: String => Exceptional TemplateIssue Template
parseData :: String => Exceptional DataIssue Data
liftTemplateErrors :: Exceptional TemplateIssue Template => Exceptional TemplateApplicationIssue Template
liftDataErrors :: Exceptional DataIssue Template => Exceptional TemplateApplicationIssue Template

var (result, error) = some_func();
if (error)
  // kak-to obrabotat
  return (_, error);

try {
  var result = some_func();
} catch (error) {
  // kak-to obrabotat
  throw error;
}

1. Вид ошибки прописан в прототипе функции
   
2. Явно прокидываем ошибку, а не "я не знаю кинет оно или нет" что частенько приводит к сюрпризам в проде и перечитыванию доков. Просто нужно написать "?". При этом задумываешься. Ровно то же самое когда разворачиваешь optional<> (который тоже обретает лютую популярность в С++): всё что нужно сделать, написать "*", но задумываешься, ведь там объекта может и не быть.
   
3. В коде явно видно как ошибка обрабатывается.
   
4. Всегда есть опция обработать ошибку на месте, причём без специального очень шумного try/catch/finally/throw синтаксиса а просто получить тип и сматчить его как угодно — часто в одну строку (map, map_or_else, and, or, and_then, ...). Работа с обычной переменной.

S>try
S>{
S>  totalAmount *= (1 - getDiscount());
S>} catch(Exception e) {}
S>

try {

<...100500 stack frames...>

  totalAmount *= (1 - getDiscount());

<...100500 more frames...>

} catch (BadFileException)
   ...
  catch (TooPoorException)
   ...
  catch (NumberConvertException)
   ...
  catch (Exception)
   <тут какой-то совсем generic handler типа "не шмогла")

try
{
   const data = LoadData();
   const processedData = ProcessData(data);
   SaveData(processedData);
}
catch
{
    log.Error("Всё пропало");
}

while (tryCount++ < 10 && NotOkay == SaveData(processedData))
{
    await ThisFrameworkSleep(1000);
}

while (NotOkay == SaveData(processedData) && Yes == AskUser("Попытаться обратно?"));

void SetError(FacilityID facility, ErrorObject error);
ErrorObject *GetError(FacilityID facility, bool reset = false);

FileObject fo("/foo/bar", "w");
fo.WriteString("foo");
fo.WriteString("bar");
fo.WriteInteger(123);
fo.Flush();
if (fo.GetError()) ShowMessage(fo.GetError(true)->Text);

struct BarError {}

fn bar() -> Result<i32, BarError> {
    Ok(10)
}

struct BazError {}

enum BarOrBazError {
    BarError(BarError),
    BazError(BazError),
}

impl From<BarError> for BarOrBazError {
    fn from(bar_error: BarError) -> Self {
        Self::BarError(bar_error)
    }
}

impl From<BazError> for BarOrBazError {
    fn from(baz_error: BazError) -> Self {
        Self::BazError(baz_error)
    }
}

fn baz() -> Result<i32, BazError> {
    Ok(20)
}

fn foo() -> Result<i32, BarOrBazError> {
    Ok(bar()? + baz()?)
}

(1 [doSmth1] 2 [doSmth2]) condVar switch

condVar 1 = [
  doSmth1
] [
  condVar 2 = [
    doSmth2
  ] [
  ] if
]

foo: [ a: b: ;; // снять со стека две сущности и завести локальные переменные
  a 1 = [
    c:; // снять со стека ещё сущность
  ] [] if
];

1 2 3 foo // первая переменная 1, поэтому создастся инстанс foo который жрёт 3 аргумента
2 3 foo // первая переменная на 1, поэтому создастся инстанс foo который жрёт 2 аргумента
i: 42 dynamic; // создаём переменную i в которой лежит 42 и просим компилятор не делать с ней никаких вычислений времени компиляции
i 2 3 foo // а тут компилятор пытается создать инстанс для foo у которого первый аргумент неизвестен при компиляции. Правда в данном случае это не получится, потому что внутри находится иф, у которого разные ветки по-разному действуют на стек. Так что будет ошибка компиляции

  actor2 ! {do_smth, arg, 2},
  actor3 ! farewall,
  receive
    {success, Result} -> Result;
    %% а тут можно "поймать" исключение из связанного актора, например, так - {'EXIT', Reason} -> <обработка>
  after 1000 -> throw {"timed out"}
  end.

add(Left, Right) ->
  parse(Reft) + parse(Right).

add(Left, Right) ->
  case parse(Left) of
    {ok, ParsedLeft} ->
      case parse(Right) of
        {ok, ParsedRight} ->
            ParsedLeft + ParsedRight;
        {error, Reason} ->
            {error, {right, parse_failed, Reason}}
      end;
    {error, Reason} ->
      {error, {left_parse_failed, Reason}}
  end.

·>Так сложно вести беседу. Получается: "А вот исключения такие-то", а ты "но вот в криво отформатированном коде всё плохо". Отформатируй код по-другому. Делов-то..

A>>try
A>>{
A>>   const data = LoadData();
A>>   const processedData = ProcessData(data);
A>>   SaveData(processedData);
A>>}
A>>catch
A>>{
A>>    log.Error("Всё пропало");
A>>}
A>>

const data = LoadData();
const processedData = ProcessData(data);
SaveData(processedData);

List<Result> doSomething(List<File> files) throws WhatExceptions??
{
  var results = new ArrayList<Result>();
  for(var f : files)
  {
     var data = readData(f);
     var parsed = parseData(data);
     if(!good(parsed)) continue;
     var result = process(parsed);
     results.add(result);
  }
}

List<Result> doSomething(List<File> files) throws WhatExceptions??
{
  return files.parallelStream()
    .map(this::parseData)
    .filter(this::good)
    .map(this::process)
    .toList();
}

Result doSomething(Input in) throws X, Y {
  var r1 = calc1(in);//throws X
  var r2 = calc2(in);//throws Y
  return combine(r1, r2);
}

Result doSomething(Input inp) throws X, Y {
  var r1 = executor.submit(() -> calc1(inp));//future
  var r2 = executor.submit(() -> calc2(inp));//future
  return combine(r1.get(), r2.get());//throws here now!
}

    @Transactional
    public EmployeeDto createEmployee(@NonNull EmployeeDto dto) {
...

S>let x = getX(); // number | OutOfMemory | StackOverflow | ByteCodeVerificationError | DivisionByZero | NullPointer | ....
S>return (x.isNumber() 
S>  ? (x * 3.14).toString()
S>  : x) // string | OutOfMemory | StackOverflow | ByteCodeVerificationError | DivisionByZero | NullPointer | .... 
S>

S>let discount = getDiscount(); // number | OutOfMemory | StackOverflow | ByteCodeVerificationError | DivisionByZero | NullPointer | ....
S>discount = isNumber(discount) ? discount : 0; // number
S>totalAmount *= (1 - discount);
S>

double discount(Order o)
{
  double s = o.getStuff();// | OutOfMemory | StackOverflow | ByteCodeVerificationError | DivisionByZero | NullPointer | ....
  double x = db.loadX(o);// | + SQL Exceptions
  double y = rest.goSomewhere(x, s);//| + Rest Exceptions
  return s + x / y; // | ArithmeticOverflow | DivisionByZero
}

S>} catch(Exception e) {}

_>>data Expr
_>>  = Val Int
_>>  | Add Expr Expr
_>>  | Mul Expr Expr
_>>  | If Expr Expr Expr

_>>eval :: Expr -> Expr
_>>eval e = ...

_>>expr0 = If (Mul (Val 1) (Val 0))
_>>           (Add (Mul (Val 4) (Val 10))
_>>                (Val 2))
_>>           (Mul (Add (Val 7) (Val 14))
_>>                (Val 2))

_>>print (eval expr0) -- Val 42
_>>

data Expr
  = Val :: Int -> (Expr | OOM)
  | Add :: Expr -> Expr -> (Expr | OOM)
  | Mul :: Expr -> Expr -> (Expr | OOM)
  ...

eval :: Expr -> (Expr | OOM)
...

expr0 = If (Mul (Val 1) (Val 0)) -- упс, (Val 1) возвращает (Expr | OOM), а Mul ожидает чистый Expr
        ...

print (eval expr0) -- и снова: expr0 у нас имеет тип (Expr | OOM), а eval ожидает чистый Expr

data Expr
  = Val :: (Int | OOM) -> (Expr | OOM)
  | Add :: (Expr | OOM) -> (Expr | OOM) -> (Expr | OOM)
  | Add :: (Expr | OOM) -> (Expr | OOM) -> (Expr | OOM)
  ...

eval :: (Expr | OOM) -> (Expr | OOM)
...

expr0 = If (Mul (Val 1) (Val 0))
        ...

-- ну и print, конечно, должен иметь сигнатуру вида
-- print :: Show a => (a | OOM) -> (IO () | OOM)

SD>А потому что error-prone, блин.

{error, {right, parse_failed, Reason}}
{error, {left_parse_failed, Reason}}

S>А ведь было же хорошее решение — т.н. проверяемые исключения в Java. Когда компилятор требовал проверки того или иного исключения, но так же была возможно обернуть в RuntimeException, если оно утратило смысл бизнес-логики или ожидаемого

void MyCoolMethod(int a, int b) throws Exception
{
   int p;
   
   try
   {
       // 100500 строк кода
   }
   catch (Exception ex)
   {
   }
}

...Pokémon exception handling after the show's catchphrase "Gotta Catch ‘Em All!"

S>>Так сделайте наследника StreamException — в чем вопрос

_>Ага, и тут у разработчиков менеджера сертификатов дилемма — делать CertificateException наследником StreamException, или HTTPException, или послать всех нафиг

struct StreamError: Error {
  details: StreamErrorDetails 
}
protocol StreamErrorDetails {}
enum NetworkStreamError: Error, StreamErrorDetails {
  case certificate(details: CertificateError)
//... something else 
}

try
{
  serializer.Write(config, fileStream);
}
catch(UnserializableValueException uve) 
{
   Alert("Sorry, the current config cannot be saved. Try changing options and save again");
}
catch(FileAccessException fex) 
{
   ...
}
// все другие исключения успешно улетают наверх, чтобы дать вызывающему шанс их обработать. Компилятор следит за полнотой обработки

try
{
  serializer.Write(config, fileStream);
}
catch(StreamWriteException swe) 
{
  if(swe instanceof UnserializableValueException)
    Alert("Sorry, the current config cannot be saved. Try changing options and save again");
  else // забыли про FileAccessException :(
   throw;
}

SD>    {success, Result} -> Result;

SD>    %% а тут можно "поймать" исключение из связанного актора, например, так - {'EXIT', Reason} -> <обработка>