только сортировки на swap`ах

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

т.е. это другой класс

что не удивительно, т.к. там ты требуешь новую операции над элементами

Optparse applicative

А что, в хачкеле есть ограничения на переносы и отступы, как в пайтоне? Объявляю strOption, ставлю закрывающую скобку отдельной строкой — parse error. Сливаю с предыдущей строкой — компилится. Треш какой-то

Отступы играют роль, да

Если переносишь на другую строку, то отступ должен быть увеличен

Впрочем, можно писать с {, } и ; :)

И execParser возвращает кортеж, получается? Из него можно достать конкретный аргумент по имени?

fst / snd

или через паттерн матчинг

let (foo, bar) = execParser ...

execParser возвращает то, что конструирует аппликатив - потому и -applicative в имени пакета

Если пасер вернет record, то и доступ к опциям будет по имени (по имени поля рекорда)

Прямо в README у optparse-applicative есть пример

execParser тащемта IO возвращает

Хм, что-то System.Random теперь отвалился

execParser тащемта IO возвращает

Ну не IO, а IO smth, положим :)

но a внутре IO a - тот, что конструируется аппликативом

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

Мде, и после отката не компилится, по ходу, cabal пакет потерял, это как вообще?

Отступы играют роль, да

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

вроде же не такая сложная штука?

т.е. where не в конце, а где-нибудь в середине, по месту надобности

ну про let я знаю, если что

то есть let есть, а where нет, как-то странно

Ну лет - выражение же

where же - захардкоренный синтаксический стейтмент

да, я понимаю:) что трудно придумать рассахаренную версию такого локального where

но почему вообще это должно быть решающим фактором

возможность развернуть любую do-нотацию в >>= и >>

foo = do bar baz where baz = .... qux doox where doox = ... where doox = ... ?

такое что-то?

foo = do bar baz where baz = .... qux doox where doox = ... where doox = ... ?

отступы ужасно скачут

я пытаюсь понять этого ли хочет @Masteroid

или это про то, что у меня 2 первые where на разном уровне?

foo = do bar baz where baz = .... qux doox where doox = ... where doox = ... ?

так работает main = do x <- f print x where f = readLn :: IO Int а так нет main = do x <- f where f = readLn :: IO Int print x

то, что я напсал не поддерживается

я спрашиваю, такое ли хочется

хочется как во втором варианте здесь

так работает main = do x <- f print x where f = readLn :: IO Int а так нет main = do x <- f where f = readLn :: IO Int print x

Я правильно понимаю, что все, что в where, будет видно всему коду выше ?

у меня да

в первом варианте

do f a f b where a = 1 f c where f x = ...

не надо такого, это попахивает жаваскриптом!

Не очень понимаю, зачем это нужно, если есть лет, который субъективно лучше читается

Я с каждым днем лучше и лучше понимаю Эвана, который отказывается впилить where в элм

let в do понятно рассахаривается - слева-направо сверху-вниз

where нормально смотрится вне тела функции, т.к. не является выражением

@Masteroid как должен рассахариваться where в середине do при условии, что where не может быть частью выражения?

да, я понимаю:) что трудно придумать рассахаренную версию такого локального where

но почему вообще это должно быть решающим фактором

возможность развернуть любую do-нотацию в >>= и >>

Потому что это говорит об отсутствии магии.

Есть чуть другая форма записи, но то что является выражением (do - является) - им и остаётся.

Если хочется where в do, то почему бы тогда let не убрать вообще? И data разрешить внутри do

И классы с инстансами и импорты!

И получим s/говно/питон/

И получим s/говно/питон/

как будто это что-то плохое 😌

f :: D -> D f = do data D = Foo | Bar g :: D -> D g Foo = Bar g Bar = Foo export D g . g

не хочу такое

Процедурный код в определениях попахивает Скалкой. За ним - туда

а чо, как будто что-то плохое

я вот очень хочу data внутри функций

и во что оно будет превращаться?

да, в Скале это плохое. так можно легко обратиться к неинициализированной переменной

а вот кстати, по-моему в идрисе над do-нотацией как-то поиздевались^W улучшили?

расскажите, кто в курсе

че там

можно сказать, там по-дефолту включён RebindableSyntax

Тож интересно. Знаю, что можно как-то самому определять поведение + всякие something x in y работают с до как лет do let x = 1 rewrite z ..

@Masteroid можно определить (») для своего типа

@Masteroid можно определить (») для своего типа

а что это дает?

@HaskellMouse ты уже с настройками GC игрался?

Да, выставил как рекомендует разработчик Accelerate.

ну можно для всякой дурости типа моноид через do: do "aa" "bb" "aa,bb"

я думаю @voidlizard бы обрадовался, ему я помню приходилось часто делать monad только ради того, чтобы do-notation был, например в emut-fat

плюс для отладки можно использовать, можно пример в ditrsibuted-process-test посмотреть, там автоматом лог событий пишется

Э... ApplicativeDo же, не?

когда-то его не было