docker совсем не zerocost

а в своём скрипте я использую https://hackage.haskell.org/package/linux-namespaces-0.1.2.0

в 8.2.3 вроде пофиксили?

наверное не стоит

Хорошо ли так писать: someFunc x= do ••• someFunc y

?

Ну это обычная рекурсия, почему нет

Но часто (или всегда) рекурсию можно заменить свертку/развертку

так хорошо, а вот так, скорее всего не очень: someFunc x = (z +) <$> someFunc y

Хаскель не мемоизирует из коробки? double f a = f a + f a f a будет выполнен дважды, верно?

> Хаскель не мемоизирует из коробки? да > double f a = f a + f a > f a будет выполнен дважды, верно? нет

Неожиданный ответ. А почему так?

благодаря equational reasoning компилятор может переписать в double f a = fa + fa where fa = f a

Может, или перепишет? :)

это оптимизация

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

если ничего не помешает, то перепишет

Понял. Вопрос в общем то был про fix. fix f = f $ fix f fix $ \a -> (4, fst a) -- (4,4) Поведение логично, но, сколько раз будет выполнена лямбда.

join (+) $! (f a) можно как-то так

join (+) $! (f a) можно как-то так

можно, но зачем делать грязную работу вместо компьютера?

чтобы понимать bang =)

Понял. Вопрос в общем то был про fix. fix f = f $ fix f fix $ \a -> (4, fst a) -- (4,4) Поведение логично, но, сколько раз будет выполнена лямбда.

подозреваю, что 1

А если туда trace бахнуть?

а если просто руками бета редукцию на бумажке написать?

А если туда trace бахнуть?

тогда ответ сразу увидишь, скучно

а если просто руками бета редукцию на бумажке написать?

Если руками, то 2. (4, fst $ fix ...) -> (4, fst (4, fst $ fix ...)) -> (4, 4)

лучше всего понимать на лямбде (основа для Y комбинатор) (\x -> x x)(\x -> x x) :D

fix $ \a -> trace "Alle Ap" (4, fst a) -- Output: -- Alle Ap (4,Alle Ap 4)

Таки 2.

И теперь мы плавно переходим в MonadFix. Почему это вообще работает. В частности mdo.

лучше всего понимать на лямбде (основа для Y комбинатор) (\x -> x x)(\x -> x x) :D

но в стандартной библиотеке не игрек, а let x = f x in x

это понятно) но никто не мешает выразить fix даже через рекурсивные схемы

Prelude Data.Function> :m +Debug.Trace Prelude Data.Function Debug.Trace> fix (\a -> trace "A" (4, fst a)) A (4,4)

fix :: (a -> a) -> a fix f = let x = f x in x

в этом случае явно есть мемоизация и шаринг

Понятно. Т.е. мой наивный фикс делает редукцию дважды.

в случае с fix f = f $ fix f - нет

да

Так. Хорошо. Самое интересное, для меня: mfix :: (a -> ma) -> ma

Он же производит join контекстов?

почему оно работает или что?

Чисто игрушка. Работать не будет. Но такова ли суть? mfix mf = mfix mf >>= mf

Где mf :: a -> ma

считай что mfix это fix но только еще может применять эффекты

лучше начать смотреть на cata и потом на cataM (все эти fix лучше через рекурсивные схемы и алгебры надо понимать)

Да, вот есть у нас 2 фикса fix f = f $ fix f fix f = let x = f x in x Первый вызывает нашу игрушечную функцию дважды Для mfix это будет критично, т.к. join контекстов.

лучше начать смотреть на cata и потом на cataM (все эти fix лучше через рекурсивные схемы и алгебры надо понимать)

Спасибо, посмотрю. И всё же.

Суть вопроса, понять mdo

для Monad должно быть MonadFix инстанс

Как этот сахарок развернуть

через mfix :: MonadFix m => (a -> m a) -> m a

для Monad должно быть MonadFix инстанс

Т.е. мы там определяем mfix без join-а контекстов?

так давай на примере, что ты хочешь в mdo запустить?

А нет примера. Что-то. В общем хочу понять

лучше начать смотреть на cata и потом на cataM (все эти fix лучше через рекурсивные схемы и алгебры надо понимать)

обкурются своим теоркатом...

обкурются своим теоркатом...

ну почему) решение через алгебры всегда более законно =)

обкурются своим теоркатом...

Полезная штука. Я бы тоже обкурился. Но как-то очень медленно. И уровень мягко говоря очень поверхностный.

ну ладно mdo { tid <- forkIO $ use ref ; ref <- (Ref tid); return ref } подойдет?

Судя по всему, мы таки отбрасывем контекст. и mfix это не mfix mf = mfix mf >>= mf а скорее mfix mf = mf $ unwrapAndDropContext $ mfix mf

оно дешурагится в:

mfix (\ref' -> forkIO (use ref') >>= \tid -> return (Ref tid) >>= return

+-

mfix (return. h) = return (fix h) mfix ('\x.a >>= ! x) = a >>= \y.mfix ('\x.! x y) mfix ('\-(x, _).mfix ('\-(-, y).f (x, y))) = mfix f Figure 1: Axioms for mfix. In axiom 2, x is not free in a

https://digitalcommons.ohsu.edu/cgi/viewcontent.cgi?httpsredir=1&article=1060&context=csetech <- статья с подробностями

{-# LANGUAGE ExistentialQuantification #-} {-# LANGUAGE RankNTypes #-} data Key s = Key Int data W a s = W a data VK a = forall s. VK (W a s, Key s) doom :: a -> Int -> IO (VK a) doom a i = pure $ VK (W a, Key 0) redoom :: W a s -> Key s -> IO (VK a) redoom a k = pure $ VK (a, k) free :: W a s -> Key s -> IO () free _ (Key i) = print ("free", i) test :: IO (VK (IO ())) test = do vk1 <- doom (putStrLn "5") 0 vk2 <- doom (putStrLn "6") 1 case vk1 of VK (a1, k1) -> case vk2 of VK (a2, k2) -> do free a1 k1 -- fro a2 k1 --fails free a2 k2 -- fro a2 k2 --fails redoom a1 k1

это как-нить более человечески сделать можно?

Если бы понять, что такое W и VK. Ну, что сами имена раскрывают

ничего, буквы удобные // ладно VK - Value Key

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

в предположении, что конструктор W не экспортируется, а экспортируется только withW :: оно даже имеет шанс на то, что будет работать

https://www.reddit.com/r/programming/comments/7ctwi7/yaml_sucks/ @cblp_su хайпанем немножко?

да ладно!

Добавь пример с &/*

_foo: &baz foo: bar bar: baz qux: <<: *baz doo: doh

Добавь пример с &/*

пулреквестируйте

Оке

Добавь пример с &/*

а разве он покажет что-то, отличное от примеров с <<?

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

Питон и хаскель нормально инклюдят

rq -y -J < foo.yaml { "_foo": { "bar": "baz", "foo": "bar" }, "qux": { "<<": { "bar": "baz", "foo": "bar" }, "doo": "doh" } }