и StM IO () ~ ()

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

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

Придётся всё на MLTT переписывать

@qnikst а я правильно понимаю что UnliftIO сномановское решает туже проблему что и MonadBaseControl ?

без понятия

это moand-control без автовывода и только над IO ?

я насчет первого не очень понял

хотя тут ошибка по делу

правда не понимаю почему оно работало до этого

@cblp_su помнишь на на monad-control ругался

я нашёл у себя проблему похоже

правда я теперь не понимаю, почему оно раньше работало

@cblp_su помнишь на на monad-control ругался

не помню

я ещё минимальный case говорил что покажу

у меня withAsync не работало, когда поидее конексты все определяются

а, это

ты ругался, что сообщение об ошибке не соответствует реальной ошибке

да

это основной point

он остается

ах да, есть ещё "утиная типизация", которую легко спутать с динамической или со слабой

а утиная типизация это не структурная случайно?

ура

ассемблер — абсолютно слабый

Ну он хотя бы не приводит всё к строке

threaded haskell работает в nix в linux subsystem в windows

Но он не знает ничего кроме... э... слов?

(@qnikst про аутиную типизацию ты удалил?)

ytn

нет конечно

я даже не читаю чо мы там про типизации пишите

ну и это бы не трогал точно

(@qnikst про аутиную типизацию ты удалил?)

Я сам удалил. Флуд же :)

сорри за вопрос новичка: почему haskell не диагностирует незавершаемые выражения? например, x = x + 1 x -- overflow ?

потому что в общем случае это невозможно

Потому что в общем случае эта задача неразрешима, но есть liquid haskell, который умеет что-то похожее.

спасибо!

Траверсалы выглядят как функторы для линз, только ограниченее.

@anatolijs например x = 1:x

это незавершаемая или завершаемая операция?

это конструирование бесконечного списка

если она будет вызвана, то не завершится

в хаскеле - завершится

а take 10 x?

ибо лень

ибо лень

length x

а take 10 x?

да, я понял

length [1..] тоже не завершится :)

не смотря на бесконечное выполнение в некоторых контекстах, в данном случае все будет в порядке

не знаю, что такое бесконечное выполнение

то, что было бы бесконечным выполнением если нету шаринга или лени?

я пока не могу понять, как он делает так, что take 10 x завершается

а утиная типизация это не структурная случайно?

что есть структурная?

я пока не могу понять, как он делает так, что take 10 x завершается

take идет по ленивому списку, который создаёт элементы по требованию. Как только take говорит "хватит", список генериться перестает

я пока не могу понять, как он делает так, что take 10 x завершается

потому что нет причин ему работать бесконечно

круто, спасибо!

есть ещё более интересный вариант: any [ a^n + b^n == c^n | a <- [1..], b <- [1..], c<-[1..], n<-[1..]]

Хаскель всё вычисляет только тогда, когда это действительно нужно

это завершается или нет?

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

вообще есть такая проблема останова

и мы или выкинем кучу программ для которых доказыать не умеем или возьмем не тьюринг полный язык, который не позволит получить незавершаемость

что есть структурная?

кажется я только что придумал новый термин. но вообще это как записи в млях работают, даже статья в вики есть https://en.wikipedia.org/wiki/Structural_type_system

причем, haskell не допускает левую рекурсию при определении бесконечных последовательностей, что понятно y = y : 1 — не скомпилируется

А как ты пытаешься сделать 1 хвостом?

+

нет

Так оператор просто не работает

тут типы тупо не сходятся

let y = y++[1]

пожалуйста

точно, спасибо!

это завершается или нет?

Конечно:) При таком-то диапазоне на n

Правда тут уже take работать не будет afaik

Конкатенация слишком прожорливая штука

хорошая шутка

Конкатенация слишком прожорливая штука

лень же - дёшево конкатенировать, просто будет +1 санк :)

Ну как бы надо полностью пройти 1 и потом хвостом подсоединить второй

вы же не про пример выше?

Ну как бы надо полностью пройти 1 и потом хвостом подсоединить второй

Надо, но только когда приспичит :)

А что если это два бесконечных списка?

Ты не поверишь: λ> take 10 $ [1..] ++ [1..] [1,2,3,4,5,6,7,8,9,10]

конкатенация - тоже ленивая, начинает отдавать новый список поэлементно

Ты не поверишь: λ> take 10 $ [1..] ++ [1..] [1,2,3,4,5,6,7,8,9,10]

Слушайте, а где это приглашенька такая у интерпретатора? А то в ghci по дефолту вроде как просто написано "Prelude>"

в .ghci

Это конфиг всмысле?

:set prompt "\ESC[32mλ> \ESC[m"

можно прямо в репле попробовать

Ага, работает.

Спс.

Да, но не будет видно что за модули ты уже подключил

это можно узнать и по-другому

:show modules

Ты не поверишь: λ> take 10 $ [1..] ++ [1..] [1,2,3,4,5,6,7,8,9,10]

но в данном случае до ++ [1..] просто никогда не дойдет

Вопрос был про завершение и про дороговизну конкатенации :)

Так что в хаскеле конкатенация - сравнительно дешевая

Чет у меня получился какой-то сложный toListOf toListOf :: Optic (->) (K (Endo [a])) s s a a -> (s -> [a]) toListOf lens = flip appEndo [] . getK . lens (K . Endo . (<>) . (:[]))