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

но когда попытался перенести этот опыт на другой код, то опять столкнулся с тем, что надо "просто каталог с кодом" превращать в "проект эклипса". Пободался час и плюнул

Ребят, я в haskell совсем новичок, делаю первые шаги. Однако, имею опыт работы на C# .NET. Так вот я привык в Visual Studio к тому, что где код пишешь, там его и танцуешь), ну т.е. дебажишь, всё просто. А как дела обстоят в haskell? Поставил vs code, накатил туд Haskero, всё вроде бы работает: код подсвечивается, на ошибки в коде мне выдаются сообщения и предупреждения и т.д. Но как запустить собсно интерпретатор? Как дебажить код и т.д.? До сего дня я пробовал юзать связку notepad++ и GHCI-консоль. В редакторе код сохранил, альттабнулся в консоль, там перезагрузил модуль, вызвал нужную мне функцию, посмотрел результат, и так по кругу. А можно ли этот процесс упростить, свести его к работе в одной программе, напрмер, vs code? Там и редактировать код, и выполнять его с выводом результатов? Спасибо.

Ctrl+` немного упростит - уберет альттабы

а принцип остаётся, как я описал?

т.е. поправил код, сохранил, из консоли релоад, выполнил, и т.д.?

Ну у меня просто stack run перезапускается по апдейтам файлов, для крупных вещей такое не подойдет

да вещи абсолютно мелкие. я пока еще хелло ворлд делаю, да числа фибоначчи))

но смысл такой, что всё выполнение кода производится из консоли? Т.е. ничего принципиально другого, более удобного нет на сегодняшний день? Т.е. все эти примочки для атома, вс кода и т.п. - просто подсветка синтаксиса и улучшение работы с самим текстом кода, а дебаг как был из консоли, так и остается сейчас? Правильно понимаю?

Можешь попробовать leksah, если он жив конечно

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

если все так работают, и это нормально, то ок, вопросов нет. Просто вдруг все юзают какую-то удобную штуку, о которой я не знаю, и из консоли мучаюсь... ))

но смысл такой, что всё выполнение кода производится из консоли? Т.е. ничего принципиально другого, более удобного нет на сегодняшний день? Т.е. все эти примочки для атома, вс кода и т.п. - просто подсветка синтаксиса и улучшение работы с самим текстом кода, а дебаг как был из консоли, так и остается сейчас? Правильно понимаю?

не вижу принципиальной разницы будет запущен repl в окне редактора или в отдельном окне

если же говорить, скажем, про подсветку ошибок и про всякие автокомплиты - это всё есть

не, про подсветку понятно

именно уже дебаг

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

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

Есть haskell for mac, там прямо плэйграунд, но вроде подходит только для учебных вещей

переключаться в ghci конечно неудобно, приходится по tdd писать и юзать только stack test ?

ну меня скорее интересует, как обстоит у хаскеллистов самый обычный рядовой будничный процесс разработки. Всякие там плейграунды и прочие изыски - это не так интересно)

а stack - это, я так понимаю, какая-то среда для хаскелла?

https://www.haskellstack.org/ Дока у него хорошая

спасибо

строгую типизацию не дебажат)) инхабитация и тайп дривен девелопмент

Есть haskell for mac, там прямо плэйграунд, но вроде подходит только для учебных вещей

автор обещал в вскоре сделать возможным открывать там норм проект (какой-нибудь уже готовый проект на хаскелл)

кстати, как в хаскеле с дебагом принтами? Есть какой-нибудь хак типа Debug.log : String -> a -> a как в элме, который ведет себя как id + выводит что-нибудь чисто для дебага?

да, нашел Debug.trace

не успел:)

кстати, как в хаскеле с дебагом принтами? Есть какой-нибудь хак типа Debug.log : String -> a -> a как в элме, который ведет себя как id + выводит что-нибудь чисто для дебага?

ты просто забил этот тип в hoogle?:)

да)

trace, traceM вроде

С дебугтрейсом в ленивой семантике порой неожиданные вещи получаешь на выход )

`

levelorder x = loop [x] where loop [] = [] loop (Empty:xs) = loop xs loop (Node v l r:xs) = v : loop (xs ++ [l, r])

Как это оптимизировать?

С дебугтрейсом в ленивой семантике порой неожиданные вещи получаешь на выход )

Неожиданные они только если не знаешь, чего ожидать

Неожиданные они только если не знаешь, чего ожидать

глубокая мысль)))

Ленивостью надо проникнуться

Как это оптимизировать?

Добавить в loop еще один параметр, в котором будут накапливаться эти [l, r] в обратном порядке, а потом, как дойдешь до [], начать их разбирать

Дерево в список элементов сплющить? Фолдом имхо, дерево дерайвит фолдабл.

Я думаю это какое-то упражнение

Иначе конечно фолд обычный

foldr (:) [] вроде, если не путаю. Ну или что-то подобное из 5 символов )

У меня кастомное дерево

levelorder x = loop [x] where loop [] = [] loop (Empty:xs) = loop xs loop (Node v l r:xs) = v : loop (xs ++ [l, r])

Мне кажется я один не понимаю, почему тут loop по списку, если функция принимает ровно один x

Ну напиши в конце твоего тривиального кастомного бинарного дерева дерайвинг все что надо - от еку до траверсабла

levelorder x = loop [x] where loop [] = [] loop (Empty:xs) = loop xs loop (Node v l r:xs) = v : loop (xs ++ [l, r])

stepik?

codewars

Но да, stepik тоже

ааа, там не просто сплющить, а определенный порядок чтобы был? ну свой фолд написать - какМосквин завещал )

Это и есть свой фолд

Лол

Но он медленный

Но да, stepik тоже

а напомни какой вариант и кинь ссылку на кодеварс

ясен пень xs ++ [l,r]

Ну это понятно

Но как

В обратном порядке хранить эти [l,r] мне уже советовали

Но как их потом разворачивать

Вот это загадка

Можно накопить в обратном порядке а потом все реверснуть. А вооюще задачу бы всю увидеть.

Это вся задача

Это вся задача

это 2 на степике курс?

Нет

Но да

на степике тесты убогие - на оптимальность реализации не проверяют вообще

Нет

кинь ссылку на codewars

поэтому там бы прошло )

https://www.codewars.com/kata/52bef5e3588c56132c0003bc/train/haskell

treeByLevels :: Maybe (TreeNode a) -> [a] treeByLevels x = loop [x] [] where loop [] [] = [] loop [] acc = loop (concat . reverse $ acc) [] loop (Nothing:xs) acc = loop xs acc loop (Just (TreeNode l r x) : xs) acc = x : loop xs ([l, r] : acc)

Все еще медленно

замени вектором)

а потом просто toList

Решил на списках

Решил на списках

решил или решил просто продолжить решать?

Решил

Ух, что-то интересное, а то всё редакторосрач, да редакторосрач

Тоже решил. Там все просто. МОжет мои каты порешаете, раз такое вызывает интерес? ;)

treeByLevels :: Maybe (TreeNode a) -> [a] treeByLevels x = loop [x] [] where loop [] [] = [] loop [] acc = loop (concat . reverse $ acc) [] loop (Nothing:xs) acc = loop xs acc loop (Just (TreeNode l r x) : xs) acc = x : loop xs ([l, r] : acc)

Насколько я понял, стоит задача обойти бинарное дерево в ширину. В таком случае, эффективное решение должно использовать тип данных "очередь". Очередь на списках эмулировать можно, но это будет неэффективно, т.к. нам надо прилеплять элементы с одно конца, а доставать с другого, а в х-ле списки "одностронние".

гугл по запросу "haskell queue" выдает Data.Sequence, Data.Dequeue, можешь попробовать их

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

вроде как речь шла про эффективную реализацию

Ну по крайней мере на их месте я бы именно так и сделал. Бесконечные структуры данных в тестах на сабже милы - они сразу отсеивают решения, подразумевающие дно.

по-крайней мере этого хотел автор

Речь шла чтобы тесты на кодоварсах пройти

И имхо именно этого хотел автор, а написал про "эффективную реализацию" )

Это пожалуйста. Но надо понимать, что сколько не усирайся - нормально на х-ль списках эту задачу не решишь.

def нормально = сравнимо с императивным алгоритмом, использующим очередь

Надо. Но кодоварс - сферической в вакууме, никаких секов/дипсеков, арраев, векторов и прочих эффективных практических ужасов там не нужно ) Там даже вектор не подключается, насколько я помню )

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

а тут и не обязательно императивно даже

просто блин, у списков доступ к концу это O(n), у очереди - O(1)

вы это никак не обойдете

а тесты можно сделать сколько угодно слабыми

чтобы какое угодно г. прошло