Alexander
cabal new-ghci
Anonymous
О. И в до н.э. (до ню) кабале тоже есть такая возможность?
Alexander
cabal ghci/repl
Alexander
new-repl наверное
Anonymous
https://cabal.readthedocs.io/en/latest/nix-local-build.html Блин. Слона-то я и не приметил. Ну, всяко лучше поздно, чем никогда ☺️ Пасиб! 👍
М
тоже полностью перешел на cabal
Anonymous
Я-то в нём только и сижу по самые уши. И пропустил.. Ну, можно отметить. Сделаю чайку.
Alexander
а можно в ghci посмотреть тип функции в выражении без (_foo) ?
Alexander
мне охота понять можно ли там дырки type applications заткнуть
Anonymous
а можно в ghci посмотреть тип функции в выражении без (_foo) ?
Я без компа. Но руки чешутся попробовать..
Alexander
coerce (mconcat @ (First Integer)) [Just 1, Just 2] :: Maybe Integer <- мне кажется это великолепно
Anonymous
Ну да.. 🤓
Alexander
ещё бы _ вместо Integer
A64m
мечтаю о такой фиче, чтоб болько ньютайп указывать надо было
A64m
но тайплевелокостылями это точно не сделать
A64m
ладно, раз тут @int_index появился надо повторить вопрос
A64m
допустим, мы хотим выбирать тайпкласс в месте использования функции
A64m
интересное начало, а как мы его выбираем?
A64m
и до того как мы его выбрали, то как код пишется, если он не знает, из какого класса ему тёрмы доступны?
A64m
мы выбираем указанием ньютайпа, для которого имплементирован тот инстанс, который нам нужен
A64m
после чего кастим функцию к тому типу, который нужен в месте использования
A64m
вопрос в том, как это сделать с минимальными аннотациями типов
A64m
если я правильно понял, то нам дано 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?
A64m
что мы точно можем: > 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] вопрос в том, насколько мы можем продвинутся из пункта А в пункт Б
A64m
@int_index ^
A64m
Я не понял где тут "выбирать тайпкласс", работаем только с Ord
A64m
инстанс
A64m
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]
A64m
Вот так что ли?
A64m
это должно работать не только для sort
A64m
тут есть два пути добавления большего числа аннотаций, как я понимаю 1) описывать "структуру" того, что мы кастим т.е. (sort @@ map Down) [1..10] 2) конкретные типы и семейства типов, которые конструируют "обернутый" тип (foo @Int @Down sort) [1..10::Int] что не весело совсем
A64m
Ну если уж McBride ничего лучше ala не придумал, то я и подавно
A64m
он все же эту задачу решал, когда многих нынешних средств не было
A64m
ну и мой вопрос в основном, насколько хорошо теперь можно написать тайпсемейство, которое будет оборачивать указанный тип в указанный конструктор типа, и может быть можно как-то и не для конкретных типов такое сделать
A64m
или может для конкретных но с меньшими аннотациями в месте использования
A64m
Скорее такое 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)
A64m
Но я не знаю как от аннотаций избавляться
A64m
Хм, оно еще не редьюсится почему-то
A64m
*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))
A64m
Я ожидал [Down Int] -> [Down Int] получить
A64m
Всё, разгадал
A64m
Третий кейс забыл
A64m
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
A64m
В общем оборачивает оно нормально
A64m
*Main Data.List Data.Ord> :kind! Modify Int (Down Int) ([Int] -> [Int]) Modify Int (Down Int) ([Int] -> [Int]) :: * = [Down Int] -> [Down Int]
A64m
но как этим дальше пользоваться у меня быстро разобраться не получилось
A64m
жаль что вот такие вот штуки forall a. Modify a (Down a) (a -> a -> a) не редьюсятся, конечно
A64m
да, печально
A64m
может на плагинах можно накостылить что-то более приближенное к цели
A64m
Это потому что там на бесконечные типы поправка. Например, в *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 возможно
A64m
У Эйзенберга это упомянуто в его пейпере про constrained type families
A64m
Для того чтобы продвинуться, нам нужно взять вот эту ветку: Modify a b (f x) = (Modify a b f) (Modify a b x) Чтобы ее взять, надо исключить вероятность всех предыдущих, в нашем случае: Modify a b a = b А чтобы это исключить, надо знать, что a /~ f, и GHC a /~ Maybe a не предполагает.
A64m
Хотя мог бы в теории, если бы все семьи типов были тотальными
A64m
type family Loop :: * type instance Loop = Maybe Loop
A64m
а пока возможно такое, то мы имеем Loop ~ Maybe Loop, а значит потенциально a ~ Maybe a
A64m
а, т.е. даже могут пофиксить в некоем неопределенном будущем. хорошо
A64m
Ну да, там весь пейпер про то, как это фиксить
A64m
А потом он еще с докладом про это выступал
A64m
И сказал, типа, в Scala молодцы, что у них все семьи типов ассоциированы с классом, у них поэтому такой проблемы нет. Но сами скалисты не понимают, какой участи избежали, потому что даже не задумывались над этой проблемой (опять же по словам Эйзенберга)
A64m
я теперь даже вспомнил, что смотрел этот доклад
A64m
может плагином можно
Alexander
ну в этом примере мне не хватило 2 вещей: тип результата указать, то, что нельзя сказать First _
Alexander
так что уже почти
A64m
ну если кастить к достаточно подиморфному типу то указывать ничего и не надо
A64m
вот только на семействах типов такую полиморфную сигнатуру не вычислить из другой полиморфной сигнатуры
Alexander
ну я не знаю, как тут не указывать
Alexander
т.е. только @ First это явно мало
Alexander
т.к. это может быть @ (First anyTypeWithMatchingRepr)
A64m
что мы точно можем: > 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] вопрос в том, насколько мы можем продвинутся из пункта А в пункт Б
A64m
ну вот как тут
A64m
у нас есть "необернутая " сигнатура мконката
A64m
и нам надо сконструировать обернутую и скастить из нее в необернутую
A64m
> f :: Monoid a => ([First a] -> First a) -> [Maybe a] -> Maybe a; f = coerce > :t f mconcat [Just 1, Just 2] f mconcat [Just 1, Just 2] :: (Num a, Monoid a) => Maybe a
Alexander
> coerce (id (sort @ (Down Int))) [1,2::Int] :: [Int] [2,1]
Alexander
@A64m_qb0 ^ покатит?
A64m
слишком много писанины
Alexander
id лишний
Alexander
ну с полной сигнатурой для coerce не интересно