так?

хм, ну вручную мы f не подставляем, но это делают всякие over/view за нас, правильно?

что такое поэтому если мы говорим пользователю, что требуем от функции больше (Applicative) у нас все продолжает работать

@kana_sama что такое линза, это функция которая для любого f подставленного пользователем делает (b -> f b) -> (a -> f b) испольщуя только ту информацию, что f это функтор

(b -> f b) -> (a -> f a)

ну да, очень плохой язык, но линза ничего не знает о типе f кроме того, что он функтор

@banana_is ?

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

что такое поэтому если мы говорим пользователю, что требуем от функции больше (Applicative) у нас все продолжает работать

вот это не распарсил

если твоя функция подставляет f которая Applicative, как это требует Traversable, то такая функция автоматически работает и для Lens, которому нужен только Functor

Да, это понятно, если функция может работать как траверсабл, то он может работать и как линза

Кстати, господа, есть ли где-то стажировки для хаскеллистов?

@fizruk31337, @voidlizard?

а что?

@jagajaga тогда уж ещё

там вопрос про стажировки

Да, это понятно, если функция может работать как траверсабл, то он может работать и как линза

нет!

если у нас есть функция работающая как линза, то она будет работать как траверсабл

я это написал

обратное неверно!

мы с женой прям поржали

про _|_

черт, я же написал то же самое, что и ты в предпоследнем сообщении)

никогда бы в голову не пришла такая аналогия

@kana_sama давай что-нить попроще, type X a = forall Traversable f => a -> f a

а это один из переводов слова bottom

и реализация pure :: X a

а это один из переводов слова bottom

скорее зад 🙂

bottom ~ ass

и пусть есть type Y a = forall f . Functor f => a -> f a

pure не может быть типа Y a

ну, а ascii-art _|_ вообще в приличном обществе не переведёшь

bottom - это в общем-то не ругательство

а теперь рассмотрим, type Z a = forall f . Functor f => f a -> f ()

стой

и fmap (const ()) :: Z a

стою

Кстати, господа, есть ли где-то стажировки для хаскеллистов?

Есть

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

и пусть есть type Y a = forall f . Functor f => a -> f a

pure не может быть типа Y a

а теперь рассмотрим, type Z a = forall f . Functor f => f a -> f ()

@kana_sama да из-за этого

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

да

хочешь я полный гист сделаю

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

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

я не уверен, чот отдает/ждет терминология здесь точная, но направление вроде верное

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

{-# LANGUAGE RankNTypes #-} type X a = forall f . Applicative f => a -> f a type Y a = forall f . Functor f => a -> f a p :: X a p = pure -- q :: Y a -- q = p -- • Could not deduce (Applicative f) arising from a use of ‘pure’ type V a = forall f . Functor f => f a -> f () type W a = forall f . Applicative f => f a -> f () v :: V a v = fmap (const ()) w :: W a w = v

полный код

Благодарю. Пока не щелкнуло, но почему не работает мне понятно

Так, слева от стрелки у нас негативная позиция, типы там контрвариантны. Справа положительная, там все ковариантно. f a тут именно справа...

когда у нас тип (a -> f a) -> (b -> f b)то a -> f a у нас в негативной позиции, а f a в положительной, значит f a в негативной (1 * (-1) = -1), аналогично f b в положительной. То есть у нас f сразу и в положительной позиции, и в отрицательной

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

я ничего не понимаю (всегда путаюсь в ко и контр-вариантности), но что-то мне подсказывает, что разница в

type X f = ... vs type X = forall f. ...

и важно где тут f относительно =

@kana_sama ^

капец

примерно так же как и с forall x . S x vs S (forall x. x)

здесь у нас случай аналогичный S (forall x.x)

нужно попробовать это как-то нарисовать

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

type Traversal' a b = forall f . Applicative f => (b -> f b) -> (a -> f a)

type Lens' a b = forall f . Functor f => (b -> f b) -> (a -> f a)

что ты понимаешь под юзер?

caller может

caller собственно это и делает подставляет Const и Identity

а линза работает для всех

так, caller это кто в нашем случае?

view/over/...?

вся магия в поведении функторов Const и Identity fst f (a, b) = fmap (\a' -> (a', b)) (f a) и как бы все видно что происходи смотря что передать в f (Const, Identity, (Identity . fn))

modifyLens f lens = runIdentity . lens (Identity . f)

setLens x = modifyLens (const x)

viewLens lens = getConst . lens Const

даже вместо . лучше #.

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

так, caller это кто в нашем случае?

да

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

ты напиши руками view и over и посмотри, как они работают с разными линзами и траверсалами

там не в этом же вопрос был