ок

можно вынести эту функцию с её определениями в отдельный модуль

да я лучше таплами обойдусь в таком случае ? спасибо, модуль тут не нужен

в таком случае будет писать "error: parse error on input ‘do’"

я думаю тут вся сложность в IO

о, это самая типичная проблема новичков в Хаскеле

почему-то в юнит-тестах do нотации не любит компилятор

хм, а можете по-простому объяснить в чем принципиальное отличие The Elm Architecture от FRP? извиняюсь, если вопрос звучит глупо

монадичностью

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

в таком случае будет писать "error: parse error on input ‘do’"

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

почему-то в юнит-тестах do нотации не любит компилятор

всё просто. компилятор не любит неправильный код

в принципе, интуиция в отступах довольно быстро вырабатывается

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

-- with monadic effects system main :: IO () main = do input <- getLine print input exit -- without getLine :: (String -> s) -> IO s print :: String -> s -> IO s exit :: IO s data State = A | B String | C String step :: State -> IO State step A = getLine (\input -> B input) step (B input) = print input (C input) step (C input) = exit app :: App State app = App { initial = A, step }

Вот сделал https://gist.github.com/odr/7907998753255ff86b23e816b5d9b621

тут есть проблема в этом инстансе instance HasFieldB (name == name') name ((name' ::: c) ': s) ((name' ::: c) ': t) a b => HasField name ((name' ::: c) ': s) ((name' ::: c) ': t) a b where field = fieldB @(name == name') @name

если (name == name'), то вместо типа c должны быть a и b, а вместо s/t должны быть одинаковые r r какие

а если name /= name', то оба c, а дальше s и t

то есть нужно как-то на два инстанса разбить что ли

и это приводит к первоначальной проблеме вроде

если будешь еще пробовать, то тестировать можно на этом примере: type User a = Record ["nickname" ::: String, "age" ::: Int, "payload" ::: a] kana = record @(User Int) "kana" 20 1000 andrew = kana & #nickname .~ "andrew" & field @"age" +~ 10 & field @"payload" .~ ""

как правильно писать тесты зависящие от времени, если не хочется вводить MonadTime ?

передавать время явно

явно передавать функцию доставания времени тоже не хочется

некуда

ну а monadtime ты куда собрался передавать?

передача времени явно это не очень хороший интерфейс

нужный только для тестов

смотря для чего

для lru

т.е. поидее часы это внутренняя деталь реализации

запилил в ядре сервиса передачу времени и внешний метод, прячущий

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

по числу использований не удобно

там надо размер рядом хранить, а вычисление его O(n)

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

если (name == name'), то вместо типа c должны быть a и b, а вместо s/t должны быть одинаковые r r какие

Изменил gist. Изменения только тут instance HasFieldB (name == name') name ((name' ::: x) ': s) ((name' ::: y) ': t) a b => HasField name ((name' ::: x) ': s) ((name' ::: y) ': t) a b

правильный путь — передавать функцию времени явно странный путь — подменять библиотеку time в тестах

мне больше понравилось, что @lonokhov предложил, если честно

по хорошему нужно подменять модуль же

бэкпек и это всё

ну хорошее не скоро придёт

/stat@combot

combot.org/c/-1001043143583

Добрый день.

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

Такую программу я писал на С и С++ и там ничего сложного небыло

Но в функциональном варианте что-то ничего непонятно

Может кто-то сможет помочь, буду очень благодарен

что именно не понятно?

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

Как организовать сдвиг массива и умножения клиентов которые находятся один над вторым

самое просто - точно так же как и в любой императивной программе: https://hackage.haskell.org/package/vector-0.12.0.1/docs/Data-Vector-Unboxed-Mutable.html https://hackage.haskell.org/package/vector-0.12.0.1/docs/Data-Vector-Unboxed-Mutable.html#v:read https://hackage.haskell.org/package/vector-0.12.0.1/docs/Data-Vector-Unboxed-Mutable.html#v:write

для более удобной индексации можно использовать Ix: https://hackage.haskell.org/package/base-4.11.1.0/docs/Data-Ix.html

Спасибо

Буду разбираться

но вообще лучше вопросы в формате, хочу X, есть Y (ссылка на gist), не получается Z, пробовал W

тогда ответы будут более точными

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

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

ну или если повезет

ура встретил место где atomicModifyIORef' (с prime) было не правильно, а надо atomicModifyIORef

ура встретил место где atomicModifyIORef' (с prime) было не правильно, а надо atomicModifyIORef

а как так может быть что strict version может быть неправильной? семантика же одна и та же, если только не пихать туда бесконечных списков и всякого такого

любой узел, например

если то, модификация зависит от результата дальшейшего

правда я радостно что-то наврал и оно у меня виснет в более сложном случае

:/

причем почему - не ясно

Как организовать сдвиг массива и умножения клиентов которые находятся один над вторым

zipWith для перемножения ряда на ряд, reverse для обращения ряда, init и tail для сдвигов

ERROR: S client not available

Что там ещё может понадобиться... Может cycle для зацикливания

если то, модификация зависит от результата дальшейшего

хм окей, мне надо помедитировать над этим

x <- atomicallyModifyIORef ref $ f z z <- g x

грубо говоря

Что там ещё может понадобиться... Может cycle для зацикливания

Спасибо

x <- atomicallyModifyIORef ref $ f z z <- g x

а! действительно типа классическая проблема laziness + IO

я вот правда не уверен, что так надо часто делать

Спасибо

Пиши в чат, если не получится. И какая свёртка кстати, линейная или циклическая?

new :: (Hashable a, Ord a) => Config -> IO (Cache a b) new Config{..} = do ref <- newIORef PSQ.empty pure $ Cache { requestOrInternal = \tm k f -> mdo mbox <- atomicModifyIORef ref $ swap . PSQ.alter (\case Just (p,~v) | p >= tm ^-^ cacheLongestAge -> (Just v, Just (tm, v)) _ -> (Nothing, Just (tm, Lazy result))) k result <- maybe (trace "f" $ f k) (evaluate . getLazy) mbox atomicModifyIORef ref $ swap . PSQ.alterMin (\case Nothing -> ((), Nothing) Just (kk,p,v) | p < tm ^-^ cacheLongestAge -> ((), Nothing) | otherwise -> ((), Just (kk,p,v)) ) pure result }

так сработало

^-^ - найс

но добавление Lazy и getLazy не очевидно

из бонусов, что неявный лок на вызове evaluate . getLazy

т.е. только 1 тред будет работу работать

я очень люблю эту фишку, но я боюсь, что это accidental complexity

с другой стороны если не это, то мне бы сложные вещи пришлось бы переизобретать

^-^ - найс

оператор "котик спрятался, видно только ушки"

оператор nya

а можно ли в семействах добавлять новые типопеременные?

оператор "котик спрятался, видно только ушки"

хотя я думал так в аниме радость изображают

И это тоже. Псто я предложил менее виабушный вариант

f :: HasField "a" r0 r1 String Int => HasField "b" r1 r2 Int String => Record r0 -> Record r2 вот имею такой код, хочу написать хелпер для композиции HasField, но для этого придется скрыть из внешнего скоупа r1 и добавить в скоуп внутри семейства, это реально?

type family RecordDelta fs r0 rn :: Constraint where RecordDelta '[] r r = () RecordDelta ('(name, a -> b) ': fs) r0 rn = forall r1. (HasField name r0 r1 a b, RecordDelta fs r1 rn) типа такого

И это тоже. Псто я предложил менее виабушный вариант

а это всего-лишь AdditiveGroup

type family RecordDelta fs r0 rn :: Constraint where RecordDelta '[] r r = () RecordDelta ('(name, a -> b) ': fs) r0 rn = forall r1. (HasField name r0 r1 a b, RecordDelta fs r1 rn) типа такого

я такое никогда не делал

а это всего-лишь AdditiveGroup

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

Обычно сложением называют коммутативную операцию

Обычно сложением называют коммутативную операцию

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

википедия ссылаясь на "Каргаполов М. И., Мерзляков Ю.И. Основы теории групп. — 3-е изд.. — Москва: Наука, 1982. — С. 18. — 288 с. — 11 800 экз." использует аддитивная

но вообще это класс из vector-space пакета

и я не знаю что и как принято называть там откуда родом автор пакета

ещё в Хаскеле иногда нужна просто полурешётка, а иногда отдельно верхняя и нижняя. и эти классы никак друг с другом не связать. печалька