мне правда пришлось патчить сервант

* https://github.com/wireapp/hscim/blob/master/src/Web/SCIM/Server.hs#L98-L116 * https://github.com/wireapp/hscim/blob/master/src/Web/SCIM/Class/Auth.hs#L31-L68

Ну и в апишке это тупо выглядит как Header "Authorization" SCIMAuthData :> "Groups" :> GroupAPI

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

Есть еще servant-auth, но там придумали делать глобальный type family, у которого ты прописываешь инстанс и он во всем приложении может быть только один (http://hackage.haskell.org/package/servant-auth-server-0.4.1.0/docs/Servant-Auth-Server.html#t:BasicAuthCfg)

Это конечно мда

стоп в servant-auth не обязан быть один на все приложение или есть несколько разных servant-auth

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

Народ, Что я делаю не так? ➜ ~ stack exec -- ghci GHCi, version 8.4.3: http://www.haskell.org/ghc/ :? for help Prelude> :set -XPatternSynonyms Prelude> pattern Single x <- [x] Prelude> pattern Pair x y <- [x, y] Prelude> Prelude> f [] = 0 Prelude> f (Single True) = 1 Prelude> f (Single False) = 2 Prelude> f (Pair _ _) = 3 Prelude> f (_:_:_) = 4 Prelude> f [] *** Exception: <interactive>:9:1-20: Non-exhaustive patterns in function f

это отдельные функции

вы тут несколько раз переопределяете функцию f

аааааа

мне надо этот синтаксис с фигурными скобочками?

можно репл в многострочный режим переключить

:{

и обратно :}

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

Кстати, при наличии проекта с .cabal-ом, с установленными зависимостями, как экспериментировать с отдельными файлами в ghci? Например, вызывать какую-нить ф из какого-нить модуля..

cabal new-ghci

О. И в до н.э. (до ню) кабале тоже есть такая возможность?

cabal ghci/repl

new-repl наверное

https://cabal.readthedocs.io/en/latest/nix-local-build.html Блин. Слона-то я и не приметил. Ну, всяко лучше поздно, чем никогда ☺️ Пасиб! ?

тоже полностью перешел на cabal

Я-то в нём только и сижу по самые уши. И пропустил.. Ну, можно отметить. Сделаю чайку.

а можно в ghci посмотреть тип функции в выражении без (_foo) ?

мне охота понять можно ли там дырки type applications заткнуть

Народ, Что я делаю не так? ➜ ~ stack exec -- ghci GHCi, version 8.4.3: http://www.haskell.org/ghc/ :? for help Prelude> :set -XPatternSynonyms Prelude> pattern Single x <- [x] Prelude> pattern Pair x y <- [x, y] Prelude> Prelude> f [] = 0 Prelude> f (Single True) = 1 Prelude> f (Single False) = 2 Prelude> f (Pair _ _) = 3 Prelude> f (_:_:_) = 4 Prelude> f [] *** Exception: <interactive>:9:1-20: Non-exhaustive patterns in function f

Можно на одной строке через ; написать все случаи, но лучше в отдельный файл перенести, да

а можно в ghci посмотреть тип функции в выражении без (_foo) ?

Я без компа. Но руки чешутся попробовать..

coerce (mconcat @ (First Integer)) [Just 1, Just 2] :: Maybe Integer <- мне кажется это великолепно

Ну да.. ?

ещё бы _ вместо Integer

мечтаю о такой фиче, чтоб болько ньютайп указывать надо было

но тайплевелокостылями это точно не сделать

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

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

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

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

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

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

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

если я правильно понял, то нам дано 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?

что мы точно можем: > 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] что не весело совсем

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

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

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

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

Скорее такое 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 молодцы, что у них все семьи типов ассоциированы с классом, у них поэтому такой проблемы нет. Но сами скалисты не понимают, какой участи избежали, потому что даже не задумывались над этой проблемой (опять же по словам Эйзенберга)

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

но тайплевелокостылями это точно не сделать

похоже на то

может плагином можно

ну в этом примере мне не хватило 2 вещей: тип результата указать, то, что нельзя сказать First _

так что уже почти

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

вот только на семействах типов такую полиморфную сигнатуру не вычислить из другой полиморфной сигнатуры

ну я не знаю, как тут не указывать

т.е. только @ First это явно мало

т.к. это может быть @ (First anyTypeWithMatchingRepr)

что мы точно можем: > 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] вопрос в том, насколько мы можем продвинутся из пункта А в пункт Б

ну вот как тут

у нас есть "необернутая " сигнатура мконката

и нам надо сконструировать обернутую и скастить из нее в необернутую

> 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

> coerce (id (sort @ (Down Int))) [1,2::Int] :: [Int] [2,1]

@A64m_qb0 ^ покатит?

слишком много писанины

id лишний