(или наоборот)

Попробую прояснить. Императивный IoC, - это такой, для которого нечистый (IO) рантайм подменяется на время действия клиентской части. То есть, клиентские сценарии написаны в IO, и действуют непосредственно в нем. Иными словами, сценарии не отделены от IO-рантайма ничем, кроме, быть может, стека из других монад.

в MTL стеке не обязан быть IO внизу

в MTL стеке не обязан быть IO внизу

Это решает немного другие задачи

как щитаете

существует 10х девелопер?

но IO же абстрактный если он имплементирован как АСТ, которое интерпретируется - это уже будет неимперативный IoC?

Думаю, нет

существует 10х девелопер?

"Думаю, нет" ответ был сюда

Думаю, существуют 10x нубы ;)

0.1x developers

но IO же абстрактный если он имплементирован как АСТ, которое интерпретируется - это уже будет неимперативный IoC?

Это философский вопрос. Разграничение можно провести по возможности отлавливать эксцепшны

0.1x developers

Ага

Есть мнение, что 1x developer настолько же мифический, как и любой другой kx developer

в MTL стеке не обязан быть IO внизу

mtl стеке внизу не обязан быть IO, возможно имели вы ввиду

да, слов порядок вышел хороший не слишком

final tagless это императивщина, так и запишем

ну так-то зига возможно бы сказал, что final tagless - терминальный интерпретатор в категории коалгебр, то есть ооп. Ну и в принципе был бы прав по моим суждениям

Вы упороты :)

И коупороты друг другу :P

блин уменя дилема

поидее нужно сделать типизированное GADT, но это так лень

А является ли ООП с необходимостью императивщиной?

и усложнит часть кода, с другой стороны 100500 случаев рассматривать не надо

стрелочка от кого к кому?

А является ли ООП с необходимостью императивщиной?

что такое ООП?

что такое ООП?

Вот тут ты меня и подловил

"Оголтело-отбитая парадигма"

Вот тут ты меня и подловил

?

Операционное отделение психиатрии.

Или особое отделение психиатрии.

Очень Относительное Понятие

ООП == мутабельные ссылки

IORef это ООП теперь?

OOPRef

IOOP

ООП это использование & вместо $

IORef это ООП теперь?

конечно

IOOP

POOP

А такая аббревиатура даже есть. Но во что раскрывается, я забыл...

Я бы сказал, что в первом приближении ООП это когда есть объекты, то есть группы методов, манипулирющих скрытым (инкапсулированным) состоянием. Типа data Object = Obj { doX :: IO (), doY :: A -> IO () } где doX и doY оперируют общим IORef

И иногда так делать очень даже удобно, так что особо гнать на ООП я бы не стал

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

Как всегда "технология ок, но люди - тупые"

Всю жизнь думал, что ООП это структурная подтипизация

> Как всегда "технология ок так никогда не бывает

Технологии тоже плохие?

Всю жизнь думал, что ООП это структурная подтипизация

она в ООП крайне редко структурная

Технологии тоже плохие?

Технологии плохие в следствие того, что что люди глупые

в одном языке, проще говоря

POOP

https://www.acronymattic.com/Proper-Object-Oriented-Programming-(POOP).html

https://www.acronymattic.com/Proper-Object-Oriented-Programming-(POOP).html

Смешно :)

Технологии тоже плохие?

Хорошие технологии закончились вместе с историей в 68'ом

Интересно, а в чате какого-нибудь C++ ведутся такие же упоротые разговоры о ФП? ? Типа - ФП это std::transform - Нет, ФП это attribute _((pure)) - Нет же лол, ФП это [](auto a, auto b) {return a*b;};

да

Вы бы видели что в JS называют фп

в ФП чатах тоже решить что такое ФП не могут

ладно, раз тут @int_index появился надо повторить вопрос

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

Интересно, а в чате какого-нибудь C++ ведутся такие же упоротые разговоры о ФП? ? Типа - ФП это std::transform - Нет, ФП это attribute _((pure)) - Нет же лол, ФП это [](auto a, auto b) {return a*b;};

Да, участвовал пару раз в таком

интересное начало, а как мы его выбираем?

и до того как мы его выбрали, то как код пишется, если он не знает, из какого класса ему тёрмы доступны?

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

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

вопрос в том, как это сделать с минимальными аннотациями типов

если я правильно понял, то нам дано class Foo a where foo :: ... instance Foo A instance Foo B class Bar x where bar :: ... instance Bar X instance Bar Y и мы хотим Quux a, который дает метод quux, где quux = foo для A и B, и quux = bar для X и Y?

Вот да https://www.reddit.com/r/haskell/comments/8ilw75/there_are_too_many_prettyprinting_libraries/

что мы точно можем: > foo :: Ord a => ([Down a] -> [Down a]) -> [a] -> [a]; foo = coerce > foo sort [1..10] [10,9,8,7,6,5,4,3,2,1] что хотелось бы получить > (sort @@ Down) [1..10] [10,9,8,7,6,5,4,3,2,1] вопрос в том, насколько мы можем продвинутся из пункта А в пункт Б

@int_index ^

Я не понял где тут "выбирать тайпкласс", работаем только с Ord

инстанс

import Data.Coerce (@@) :: (Ord b, Coercible a b) => ([b] -> [b]) -> (a -> b) -> ([a] -> [a]) (@@) f _ = coerce f *Main Data.List Data.Ord> (sort @@ Down) [1,2,3] [3,2,1]

Вот так что ли?

это должно работать не только для sort

тут есть два пути добавления большего числа аннотаций, как я понимаю 1) описывать "структуру" того, что мы кастим т.е. (sort @@ map Down) [1..10] 2) конкретные типы и семейства типов, которые конструируют "обернутый" тип (foo @Int @Down sort) [1..10::Int] что не весело совсем

Что делает >>= Можно примеры?

Что делает >>= Можно примеры?

https://habr.com/post/183150/

(>>=) :: m a -> (a -> m b) -> m b

Что делает >>= Можно примеры?

> (tail >>= flip zip) [1..5] [(1,2),(2,3),(3,4),(4,5)]

ну наконец-то начали ругать https://gist.github.com/chexxor/23ccf35add7dbdd33ecdd26888663140

> (tail >>= flip zip) [1..5] [(1,2),(2,3),(3,4),(4,5)]

издеваешься?

Что делает >>= Можно примеры?

лучше почитай «Learn you a Haskell»

> [1..5] >>= (:[]) [1,2,3,4,5]

это должно работать не только для sort

Ну если уж McBride ничего лучше ala не придумал, то я и подавно

Ну если уж McBride ничего лучше ala не придумал, то я и подавно

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

Ну если уж McBride ничего лучше ala не придумал, то я и подавно

потом на линзы перенесли с Wrapped

Ну если уж McBride ничего лучше ala не придумал, то я и подавно

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

или может для конкретных но с меньшими аннотациями в месте использования

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

звучит как type Apply f x = f x. чего я недопонял?

а, там предыстория выше

Скорее такое type family Modify (a :: k1) (b :: k2) (f :: k3) :: k3 where Modify a b a = b Modify a b (f x) = (Modify a b f) (Modify a b x)

Но я не знаю как от аннотаций избавляться

Хм, оно еще не редьюсится почему-то

*Main Data.List Data.Ord> :kind! Modify Int (Down Int) ([Int] -> [Int]) Modify Int (Down Int) ([Int] -> [Int]) :: * = Modify Int (Down Int) (->) (Modify Int (Down Int) [] (Down Int)) (Modify Int (Down Int) [] (Down Int))

Я ожидал [Down Int] -> [Down Int] получить

Всё, разгадал

Третий кейс забыл

type family Modify (a :: k) (b :: k) (f :: kf) :: kf where Modify a b a = b Modify a b (f x) = (Modify a b f) (Modify a b x) Modify a b c = c

В общем оборачивает оно нормально