да поясни

https://simonmar.github.io/posts/2017-01-24-asynchronous-exceptions.html

+ асинхронные ещё

в хаскеле проверяемые экспешены невозможны

тоесть ексцепшены в такой ситуации это канонично и не рассматривается как изъян?

которые прилетуют в любой момент

а ещё Either пока тормозит

это вам не раст

unboxed sum types пока не довезли

тоесть ексцепшены в такой ситуации это канонично и не рассматривается как изъян?

да, это нормально, исключения это то что предполагается нормальным обрабатывать, это не error, который значит что программа неправильно написана

чего там выше очередные генерогенные рекорды?

пытаюсь generic осилить, но чет это слишком сложно

И как заменеджить это лучше, кроме как предварительной проверкой инкримента?

А чем плох бесконечный список в ленивом языке? И если-таки плох для какой-то предметной области, то откуда там нулевой инкремент берется?

да, это нормально, исключения это то что предполагается нормальным обрабатывать, это не error, который значит что программа неправильно написана

понятно, я думал что наоборот и думал что на эту тему есть история как такое получилось

ну окей конкаренси совсем боль. ну вот в сишке например возвращается null из fopen почему в хаскеле обязательно должен быть эксепшен

я просто не понимаю этого фатализма резкого

что мол спросили вполне конкретный вопрос, а вы такие резко в крайности ушли

мол мы ничего с этим поделать не можем - жизнь опасна и жестока

потому что уже в IO, в чистом коде есть смысл не исключения использовать, в IO уже нет, они просто удобнее будут

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

А чем плох бесконечный список в ленивом языке? И если-таки плох для какой-то предметной области, то откуда там нулевой инкремент берется?

Да ничем, но вот >Когда начало и конец интервала совпадают площадь должна равняться нулю. интегралы - интегральчики

более того нельзя перечислить все типы ошибок которые могут вернуться

2 раза написал минимум

но похоже это никому не интересно, т.к. мне не отвечали

ну ладно. я первый свернул тему не туда)

расширяемые исключения обычно удобнее чем Either

хотя я бы честно хотел видеть какие-то аннотации

типа функция может бросить вот это вот, и может что-то ещё

я так понял, если есть class C a b | a -> b type family F a b :: Constraint то сделать instance F a b => C a b не получится, так как в F нет некой выводимости b из a (lhs type 'a' do not jointly determine rhs type ‘b’)

просто с EItherT все быстро печально становится

и толку нету все равно

експириенс с обработкой ексцепшенов в хаскеле это одна из причин быстрого падения моей воодушевлённости к хаскелю после прочтения LYAH и написания первых програм

а чего их ловить то?

експириенс с обработкой ексцепшенов в хаскеле это одна из причин быстрого падения моей воодушевлённости к хаскелю после прочтения LYAH и написания первых програм

далее попробуй вектора и конкаренси с пробиванием эксепшенов из одного потока в другой

да вроде как везде: в эффектном коде try/catch, в чистом either/except со своими try/catch

Да ничем, но вот >Когда начало и конец интервала совпадают площадь должна равняться нулю. интегралы - интегральчики

Это, в общем случае, довольно большая натяжка: выводить поведение в предельных случаях для дискретных конструкций из континуальных или наоборот.

а чего их ловить то?

1. когда "исключительная ситуация" это ожидаемая ситуация в моей програме 2. показать нормальное сообщение об ошибке вместо хаскелевского стактрейса

а смысле в чем сложность с этим?

у меня с catch получалось дико уродливая конструкция которую я ещё долго соображал как сделать

ну это как спрашивать в чём проблема писать без типов ты не знаешь наверняка захендлился эксепшен где-то во вложенных функциях или нет

(хотя лол - я сам же за сегодня дважды написал Left e -> error $ show e)

Это, в общем случае, довольно большая натяжка: выводить поведение в предельных случаях для дискретных конструкций из континуальных или наоборот.

Логично. но все же, как тогда лучше, просто ветвление?

у меня с catch получалось дико уродливая конструкция которую я ещё долго соображал как сделать

*catches простой case там был бы проще и понятнее

Да ничем, но вот >Когда начало и конец интервала совпадают площадь должна равняться нулю. интегралы - интегральчики

ну кстати ты наверное должен же задать интеграл как (x1 - x0) * (f(x1) - f(x0))

Логично. но все же, как тогда лучше, просто ветвление?

Тут, полагаю, да.

*catches простой case там был бы проще и понятнее

для этого есть try

с интегралами, почему не (b-a)/n?

чтобы ошибку то не накапливать

и потом [0..n] и все

ну или (b-a)/delta

если хочется так по немногу, то проще уже врапперы написать конечно

ну или (b-a)/delta

кажется это численная производная ну и особо не понял про накопление ошибки точнее не помню как оно оценивается вроде деление всё равно даст гораздо больше ошибки (ну это интуитивно)

2 варианта, или фиксированная дельта, тогда делим конец - начало на дельту получаем число шагов

или фиксированное число шагов, тогда длину шага считаем

каждая операция с IEEE будет накапливать ошибку, если не использовать спец схемы

поэтому a+d+d+d+d....

будет не тоже самое что a+d*n, для какого-то n

@vlastachu ^

каждая операция с IEEE будет накапливать ошибку, если не использовать спец схемы

мм ну ок

@kana_sama что если оба?

ветки

предположительно в обе не получится, но не уверен, что компилятору можно об этом сказать

вообще OVERLAPPABLE + {-# OVERLAPPING #-}

с некоторой долей олегинга можно наверное сказать

доп параметр дать + фундеп

@vlastachu ^

Здравствуйте

Пытаюсь разобраться с сервантом

Подскажите пожалуйста

Что означают вот эти две строки

api :: Proxy Api api = Proxy

тайп левел магию)

api :: Proxy Api api = Proxy

data Proxy (a :: k) = Proxy тут Proxy-тип - конструктор типа с фантомным аргументом-типом любого каинда по сути своей api - просто Proxy-значение с типом-фантомом Api нужен для того, чтобы на термлевеле контролировать передачу чего-то на тайплевел (в данном случае Api) idP :: Proxy a -> a -> a idP Proxy x = x x :: _ -- will be Int x = idP (Proxy :: Proxy Int) 1 stringProxy :: Proxy String stringProxy = Proxy y :: _ -- String y = idP stringProxy "123" z = idP stringProxy 1 -- type error, String /= Int (or no Num String)

А это случайно не Geometric Numerical Integration?

А что такое каинд?

А что такое каинд?

тип типа, а вооще есть чатик для начинающих

Вроде же писали что сюда можно задавать подобные вопросы

А это случайно не Geometric Numerical Integration?

оно

забавно через столько лет встретить снова в хаскель чате )

Вроде же писали что сюда можно задавать подобные вопросы

можно, сейчас отвечу

тип типа, а вооще есть чатик для начинающих

НЕТУ ЧАТИКА ДЛЯ НАЧИНАЮЩИХ!!!!1 азаза

ЕСТЬ @haskell_learn

забавно через столько лет встретить снова в хаскель чате )

забавно, у меня со времён универа лежит, классная книга, жалею что лишь слегка осилил

ЕСТЬ @haskell_learn

хватит пиарить вредные вещи

что за кибербуллинг чатов

вообще смешно как-то работает

тут всех гонят в один

@al_bl https://wiki.haskell.org/Kind

а там всех гонят в другой

мол, эта тема не для начинающих

@al_bl если после прочтения будут вопросы, то можно попытаться по русски объяснить:)

я уже писал почему я считаю разделение чятиков очень вредной вещью

уже один gitter так поломали

сепаратисты

А что такое каинд?

вот есть у нас терм 2, он имеет тип Int эта же логика переносится на уровень выше: есть у нас тип Int, он имеет каинд Type есть у нас терм-функция succ, которая принимает терм типа Int и отдает терм типа Int, то есть succ :: Int -> Int succ 2 :: Int эта же логика переносится на уровень выше: если конструкттор типа Maybe, который принимает тип каинда Type и отдает тип каинда Type, то есть Maybe :: Type -> Type Maybe Int :: Type есть функция $, которая принимает функцию типа (a -> b) и значение типа a, отдает значение типа b ($) :: (a -> b) -> a -> b f $ x = f x succ $ 2 == 3 есть тип $, который принимает конструктор типов (Type -> Type) и тип Type и отдает тип Type ($) :: (Type -> Type) -> Type -> Type type f $ x = f x Maybe $ Int == Maybe Int 1 :: Int :: Type не все типы имеют каинд Type или (Type -> k), где k - один из этих двух