хотя тут наверное непонятно у меня

uniteBytecode :: [ASMLine] -> String uniteBytecode asm = foldl (++) "" [ bytecode x | x <- asm ]

* encounters line break after let * throw `ParseError`s

data ASMLine = ASMLine -- String String { instr :: String , operand :: String , bytecode :: String , offset :: Int } deriving (Eq)

ну мне удобнее line break after let

строчки экономлю

оно 100% законно

Да так даже читаемее, на самом деле. > bytecode :: String Я вот не помню. Любая ли байтовая последователность ли представима в виде Char? foldl (++) "" можно смело заменить на concat или mconcat. Экономишь туалетную^W бумагу для принтера?

ага, спс

> Любая ли байтовая последователность ли представима в виде Char? да, но зачем

Во, ещё лучше! uniteBytecode = (bytecode =<<)

код считает оффсеты строчки от начала

а получаются оффсеты от конца

foldl (+) 0 заменимо на sum

Во, ещё лучше! uniteBytecode = (bytecode =<<)

э, это че?

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

t - length (bytecode x)

type String = [Char] bytecode :: ASMLine -> String => bytecode :: ASMLine -> [Char] concatMap :: (a -> [b]) -> [a] -> [b] (flipped concatMap) assume a ~ ASMLIne, b ~ Char => concatMap bytecode :: ASMLine -> [Char] => concatMap bytecode :: ASMLine -> String

В общем, uniteBytecode = concatMap bytecode, что выражает

@termslang чтобы не считать два раза, можно протащить параметр-аккумулятор длины

И попытайся выразить через foldl или foldr

Всю computeOffsets, я имею ввиду. Кстати, зачем compute? Почему просто не offsets?

Мы ж не в жаве

потому что оно будет меняться тыщу раз

Что будет меняться-то? У нас тут иммутабельность и функциональная чистота, вроде как

Достаточно просто написать в документации, что оно O(n^2), например

у меня все норм с иммутабельностью

вот main

module Main where import System.Environment import Emasm main :: IO () main = getArgs >>= return . head >>= readFile >>= return . parseAsmFileContents >>= return . unfoldPseudoasm -- >>= return . splitInitSection >>= return . computeBytecode -- >>= return . uniteBytecode -- >>= return . addLoader -- >>= print >>= mapM_ print

Технически, можно сделать zip... господи

offsets больше звучит как переменная

У нас тут своя атмсфера и переменные живут в модулях Data.IORef и Control.Concurrent. Ты из принципов не используешь do-syntax?

говорят это плохо

Кто?

https://wiki.haskell.org/Do_notation_considered_harmful

Исходную задачу можно сделать, как zip asmLines (scanl _offset [] (map bytecode asmLines)), и останется реализовать только _offset.

https://wiki.haskell.org/Do_notation_considered_harmful

там не написано, что плохо, написано что иногда плохо

Ньюкомерс майт think

Если поискать, можно и мнение о том, что Monads considered harmful найти. Зачем верить всему подряд?

Ну понятно. Кто автор?

ну без монад никак же

а без do можно

аргументация норм вроде

И без монад можно, какие проблемы

+1, на продолжениях всё делать, как в '92 было

как в Node.js

Надо на самом деле надо прочитать просто эту статью в вики

и там примерно во втором абзаце, в топике Didactics написано, что имеется ввиду

А не только её заголовок :)

ну где-то кроме монад do лепить точно не надо

а где-то кроме монад в хаскелле можно?

там побочные жффекты описываются

ApplicativeDo ?

Где-то кроме монад заюзать do-нотацию будет затрднительно, потому как оно переписывается в вызовы (>>=) и (>>), ну и (*>), да

В общем, нормально все с do-нотацией, ее вполне можно использовать, часто она улучшает читаемость кода.

В monadic expression описывается последовательность действий, если что

ApplicativeDo ?

о, норм, не видел такого

Вброшу https://blog.jle.im/entry/io-monad-considered-harmful.html

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

{-# language RebindableSyntax #-}?

https://ocharles.org.uk/blog/guest-posts/2014-12-06-rebindable-syntax.html @termina1

ну такое

Оно делает именно то, что ты хотел

нет

я говорил, что если ты на типе определил просто >>=, то автоматом юзаешь do-syntax, так это тоже можно делать, но это не очень понятно имхо потом

еще и семантику меняешь

нельзя определить просто >>=

этим хаскель и хорош, кстати

Правда?

Другого не завели. Кстати, никогда не пытайтесть выполнить throw $ fix SomeException. По Ctrl-C ghci не прибивается

Почему это хорошо?

потому что такие вещи пакуются в неймспейсы

Можно определить >>=, в локальном контексте. Но do-нотация всё равно рассахаривается в Prelude.>>=

в целом можно рассахаривать и в >>=

через RebindableSyntax

Например, если не любишь прелюдию

Мы его только что поминали)

вот да

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

собственно, внезапно, все что имеет >>= и return это монада