да

Вы бы видели что в 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

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

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

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

жаль что вот такие вот штуки forall a. Modify a (Down a) (a -> a -> a) не редьюсятся, конечно

да, печально

может на плагинах можно накостылить что-то более приближенное к цели

Это потому что там на бесконечные типы поправка. Например, в *Main Data.List Data.Ord> :kind! forall a. Modify a (Down a) (Maybe a) forall a. Modify a (Down a) (Maybe a) :: * = Modify a (Down a) (Maybe a) оно фейлится, потому что предполагает, что a ~ Maybe a возможно

У Эйзенберга это упомянуто в его пейпере про constrained type families

Для того чтобы продвинуться, нам нужно взять вот эту ветку: Modify a b (f x) = (Modify a b f) (Modify a b x) Чтобы ее взять, надо исключить вероятность всех предыдущих, в нашем случае: Modify a b a = b А чтобы это исключить, надо знать, что a /~ f, и GHC a /~ Maybe a не предполагает.

Хотя мог бы в теории, если бы все семьи типов были тотальными

type family Loop :: * type instance Loop = Maybe Loop

а пока возможно такое, то мы имеем Loop ~ Maybe Loop, а значит потенциально a ~ Maybe a

а, т.е. даже могут пофиксить в некоем неопределенном будущем. хорошо

Ну да, там весь пейпер про то, как это фиксить

А потом он еще с докладом про это выступал

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

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

Известная картиночка https://i.redditmedia.com/FlXKab4jiLW1X5lBWAE8YzwOGb-ALF0reRqW3BULpYs.png?s=926985cc55c2e143b334c7537b438e4d точно так же применима к спорам об ООП/ФП

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

Пересечение социалисты+экономисты не пересекается с капиталистами? ;)

Странно сравнивать теорию типов с economics

Хотя бы потому, что теория типов основана на вере в познание, а economics на вере в невозможность познания

марксисты теперь в экономике разочаровались?

Почему это прям в economics вера в невозможность познания?

марксисты теперь в экономике разочаровались?

Так economics это ж не экономика, это набор практик, основанных на положениях Хайека. Ты с political economy и neoclassical economy его перепутал

Почему это прям в economics вера в невозможность познания?

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

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

в худшем случае на положениях фридмана

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

А нельзя ли ссылочку? Как-то не приходилось такое встречать. То, что фальсификационализм сложно натянуть (как и наши типы порой), это понятно. А вот что прям непознаваемо...

в худшем случае на положениях фридмана

Фридман ж ученик Хайека, у них и общие работы есть.

тем не менее он левее хайека

Ты под левее понимаешь прогосударственнее? Или речь про отношение к знанию?

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

А нельзя ли ссылочку? Как-то не приходилось такое встречать. То, что фальсификационализм сложно натянуть (как и наши типы порой), это понятно. А вот что прям непознаваемо...

Хайека ж читать надо. http://www.libertarium.ru/10181

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

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

в экономике нормально коррелирует обычно