ну понятное дело

а стоп id не нужен же

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

а насколько это вообще возможно

вот возьмем $f concat [Just 1, Just 2]

я хочу чтобы это было (самое обобщенное) чем-то типа forall a b c . Num a, Coercible (Maybe a) b, Coercible b c => c`

это плохой случай

нам надо без констрейнтов коэрсибл

почему, я же хочу указать откуда словарь

мне ж нужно указать что форма та же?

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

т.е. в принципе ничего невозможного я не вижу

если человек напишет $f concat @First

то тут уже Coercible могут уходить

я не понимаю, где указана обёртка

в этом и смысл фичи, если все констрейнты на коэрсибл убрать - вывод типов будет отличный

т.е. в моём предложении мы должны сгенерировать функцию, которой только обёртку поставить

указана как First

где?

@@?

ну в идеале есть какой-то волшебный оператор mconcat @@ First

т.е. concat @@First [Just 1, Just 2]

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

мне тут не очень нравится, что мы можем в тоже самое время написать concat @@(First Mod15) [Just 1, Just 2]

и код останется максимально полиморфным

мне тут не очень нравится, что мы можем в тоже самое время написать concat @@(First Mod15) [Just 1, Just 2]

ну это работать не должно

почему?

только некий стек параметризованных оберток

может это и можно оставить

> newtype P = P Int deriving (Eq, Ord) > coerce (sort @ (Down P)) [1,2::Int] :: [Int] [2,1]

сейчас я могу так сделать

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

собственно из-за этого coercible и лезут, и нельзя написать @ (Down _)

т.е. это именно выбор инстанса средствами указания обертки, а не более общий каст

я понимаю, но я теряюсь в том как это правильно сформулировать

я могу хотететь что-то (не знаю как придумать хороший пример), скажем у меня Down Int а я хочу для него инстанс Down Sum

т.е. не внешний слой, а внутренний поменять

текущий coerce + type application это позволяют, но очень дорогой ценой

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

или я что-то упускаю

примерно это можно и с параметризованными обертками сделать, т.е. кастануть Down a к Down (Sum a)

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

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

т.е. скажем: sort @@ X делает преобразование`sort :: forall a . Ord a => [a] -> [a]` : ((coerce (sort' :: [X a] -> [X a]) )::[a] -> [a])

тогда та штука будет очень полиморфной

но при этом мы не "увеличиваем" количество полиморфизма

X - что-то вроде type family (что-то вроде, но принимает то, что сохраняет структуру *->*

@A64m_qb0 я правильно понял идею?

(то что выше можно переписать просто дав нужный тип coerce да)

ну да

т.е. грубо говоря в фунции forall a . ... меняем все вхождения a на X a?

где X это штука

только байндед a

которые ограничены классом для которого у данной обертки инстанс есть

т.е. maximum :: forall a. [a] -> a будет: coerce (maximum :: [X a] -> X a)) :: Ord a => [a] -> a

я так понимаю тайпчеккер ругнётся если что

coerce (maximum :: Ord a => [X a] -> X a)) :: Ord a => [a] -> a

лень писать внутри было

и safeMaximum :: forall a . Ord a => [a] -> Maybe a будет: coerce (safeMaximum :: Ord a :: [X a] -> Maybe (X a)) :: [a] -> Maybe a

т.е. для Functor f => (a -> b) -> f a -> f b будет (a -> b) -> Id f a -> Id f b неограниченные параметры никак не трогаются

(Id f) a ? так скобочки

да

проблем с ко-контр вариантостью есть?

хотя такой каст коэрсибл не осилит

типа forall a . (a -> b) -> (b -> a) -> ..

это из Maybe сделать First скажем?

ну там-то в определении обертки все есть, так что

ничем принципиально от Down не отличается

let z :: forall a b . ((a->b) -> Maybe a -> Maybe b); z = coerce (fmap :: (a->b) -> First a -> First b)

да

ну т.е. достаточно техническое преобразование, которое TH (уродский синтаксис) или плагином возможно

да

была бы ещё специализация в плагине, и тогда можно было бы результат возвращаемый делать полиморфным

хотя это наверное не нужно если все функции такие

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

выбор инстанса для функции

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

не синтаксис

синтаксис-то пока особо не обсуждается

чтобы из: liftA2 @@ZipList (+) [1,2,3] [4,5,6] получалось: > let f ::forall a b c. (a->b->c) -> [a] -> [b] -> [c] ; f g = coerce (liftA2 g :: ZipList a -> ZipList b -> ZipList c) > f (+) [1,2,3] [4,5,6] [5,7,9]

но синтаксис не важен, важно преобразование

и какими средствами его можно сделать

@A64m_qb0 а что делать с (+) <$> [1,2,3] <*> [4,5,6]

> let f ::forall a b c. (a->b->c) -> [a] -> [b] -> [c] ; f = coerce (liftA2 :: (a->b->c) -> ZipList a -> ZipList b -> ZipList c)

вот так точнее согласно тому, что обсуждали

class HasMethod c m t | c m -> t where method :: c => t instance HasMethod (Monoid a) "mempty" a where method = mempty -- instance HasMethod (Monoid a) "mappend" (a -> a -> a) (@@) :: (Coercible t1 t2, HasMethod c1 m t1, HasMethod c2 m t2) => t1 -> (t1 -> t2) -> m2 x @@ w = undefined x :: String x = method @(Monoid String) @"mempty"

@alexandra_rosenthal будет жить. Поприветствуем!

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

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

прием платежей qiwi wallet конструктор insales вся документация есть плачу 5000

на хаскеле?

?

?

@haskell_cv

это чат о Хаскеле