Почему в Qt не рекомендуют использовать исключения?

И кстати в Scala примерно для того же есть тип Option с паттерн-матчингом.

Ну ахренеть, уже в монады скатились.

Переведи

Комментарий? Примерно так:

Если вызов lookup "foo" завершится неудачей (вернёт Nothing), то myFunc незамедлительно также вернёт Nothin. То же самое самое произойдет далее с lookup "bar". И только если оба вызова lookup завершатся успешно, результаты их работы будут использованы дале в return $ i * mult + j.

Без монад этот код выглядел бы примерно так:

lookup :: Eq a => a -> [(a, b)] -> Maybe b
-- Looks up a value in a key-value association list

myFunc :: Int -> [(String, Int)] -> Maybe Int
myFunc mult assocList = do
    let mi = lookup "foo" assocList
    case mi of
        Nothing -> Nothing
        Just  i -> do
            let mj = lookup "bar" assocList
            case mj of
                Nothing -> Nothing
                Just  j -> return $ i * mult + j

А что мешает зафигачить монады на Scala?

Монады как таковые - никто. Но do-нотация отсутствует. DSL здесь вроде тоже не запилить нормальный...

Скатили такой тред в монады.

А чем С++б!@#$тво лучше? Да и к тому же не обязательно монады, достаточно выразительных средств для «сопоставления по образцу». В том же rust можно так писать, вроде по читаемости почти сравнимо с исключениями, зато намного надежнее.

достаточно выразительных средств для «сопоставления по образцу»

Средств сопоставления _и_ алгебраических типов.

В том же rust можно так писать, вроде по читаемости почти сравнимо с исключениями

Как «так»? В Rust проверки возвращаемого результата выливаются в лапшу вроде сишной или использование макро try!, который разворачивается в return. Преимущество Rust в том, что проверку результата нельзя пропустить.

А чем С++б!@#$тво лучше?

Ну так давай любой тред в монады скатывать, включая ЕОТ. С++ хоть кто-то пользуется.

Это уже (минимум) однажды обсуждали и как контрпример приводили монады, позволяющие не писать портянку проверок возврата.

Они по сути лишь синтаксический сахар над сишным «if (ret) return ret;» после каждой строки, только в сишке можно еще логгирование сделать и массу прочей порой нужной логики навесить.

Главное ресурсы очистить не забыть.

Зато царь съедет с темы рефкаунтинга в unique_ptr.

Главное ресурсы очистить не забыть.

Ну да, разумеется. А в том же go на это няшный defer придумали.

Ну в gcc есть __attribute__(__cleanup__(my_cleunup_function)) + локальные функции. Жаль в стандарте нет ничего похожего.

Кусок говна обосанного, тупые ублюдки запретили его в тайпдефах - он харен такой не нужен. Какой жопой надо было думать, чтобы такое говно сделать? Плюс ещё хрен передашь лямбду.

Клеанап кусок говна, это наверное самое убогое в гнус.

Средств сопоставления _и_ алгебраических типов.

Ну да, а есть язык с первым, но без второго? Со статической типизацией. А то если примитив - то зачем новый термин заместо switch, а если структура - то уже есть «multiple variable assignment».

В Rust проверки возвращаемого результата выливаются в лапшу вроде сишной

Без промежуточных переменных уже получше смотрится, и однотиповые обертки потенциально можно макросами соединить. А если с исключениями сравнивать, то наверное честнее на том же уровне гибкости, чтоб все отдельно ловить и т.д. Впрочем, не исключаю, что те примеры, что смотрел были слишком простыми.

Ну для сишечки ничего лучше нет. В оффтопиковском cl есть __try __finally но это костыль по сравнению с cleanup... Мне кажется, что сишке не повредил бы такой(нормально сделанный) механизм.

Потому, что qt рассчитан на обезьянок. А обезьянки не умеют исключения в C++. Вернее они могут пытаться, но получается говно. Так что лучше их отгородить от этого. Так же делает Гугл и др.

Ты наркоман? Есть и то, и другое.

Ну покажи раз есть.

do-нотация здесь называется for-comprehension

Что же касается DSL, смотреть любой скаловый ORM, типа http://slick.typesafe.com/ http://squeryl.org/index.html

do-нотация здесь называется for-comprehension

Нет, это разные вещи. DSL там есть, я говорил, что do-нотацию не сделать(в смысле я не знаю как).

Не согласен - покажи монады-то. Желательно приведенный выше пример на haskell.

«Навыворот»:

def lookup[A, B](key: A, pairs: Seq[(A, B)]) = for (p <- pairs.find(_._1 == key)) yield p._2

def myFunc(mult: Int, assocList: Seq[(String, Int)]) = {
	lookup("foo", assocList) map { i =>
	  lookup("bar", assocList) map { j =>
	    i * mult + j
	  }
	}
}

Лапша без do-нотации:

def lookup[A, B](key: A, pairs: Seq[(A, B)]) = { 
  pairs.find(_._1 == key) match {
    case Some(k, v) => Some(v)
    case _ => None 
  }
}

def myFunc(mult: Int, assocList: Seq[(String, Int)]) = {
  lookup("foo", assocList) match {
    case Some(i) => lookup("bar", assocList) match {
      case Some(j) => Some(i * mult + j)
      case _ => None
    }
    case _ => None
  }
}

Круто! =) Спасибо, понял, был не прав.