Скажем у меня есть некий класс FromTo { from, to }. А ещё есть class FromTo t => Encoder t where { encode = from }. Получить FromTo из Encoder с помощью только лишь encode я не смогу

Получается, что у меня "беззаконный класс" и так делать нельзя?

Где про это чётко написано?

Скажем у меня есть некий класс FromTo { from, to }. А ещё есть class FromTo t => Encoder t where { encode = from }. Получить FromTo из Encoder с помощью только лишь encode я не смогу

всё правильно

Получается, что у меня "беззаконный класс" и так делать нельзя?

нет

Констреинты, это же не сабклассинг какой-нить. Где нужно соблюдать принцип подстановки Лисков

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

@astynax это значит что требование From скорее всего ненужное

как Ord для Num

Хмм. Т.е. правильнее в default методах констреинты иметь для такого случая?

Это логично, если подумать

Нет, когда мы можем выразить методы класса родителя через методы класса наследника это такой важный частный случай. fmap через методы монады не выражается если мы её определяем через return & join

Ну или совсем крайний случай, клас не вводящий методов: class Monoid m ⇒ CommutativeMonoid m

уговорили, наверное

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

Можем ли мы определить аппликацию для своего типа?

Про это знаю <*>

что значит аппликацию?

myTypeValue arg

что это значит?

ты хочешь имя MyType применить к нему Foo и что-то получить?

напиши типы вещей и получишь ответ

если у тебя myTypeValue :: MyType, а arg :: B, то myTypeValue a - не типизируется

чтобы применить B к чему-то у тебя должен быть тип B -> ...

Ну, окей. Допустим data F a b c = F ( a -> b -> c )

fValue :: F Int Int Int

что такое FValue?

fValue = F (+)

ну

ты можешь сказать (\(F f) -> f 4) :: Int -> Int

Могу, но я хочу так: fValue 1 2 :: Int

data F a b c = F { applyF :: a -> b -> c } fValue :: F Int Int Int ... result = applyF fValue 1 2 ^ где-то видел такую идиому

Могу, но я хочу так: fValue 1 2 :: Int

какая разница, что ты хочешь

добавить деструктор

вон как Yx написал

applyF :: F a b c -> (a -> b -> c)

какая разница, что ты хочешь

Я просто интересуюсь. Сидел, вот, и подумал, что было бы прикольно.

как может быть прикольной штука у которой не сходятся типы?

не налазят!

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

в с++ такое есть вроде бы

ты хочешь написать (fValue :: F Int Int Int) (1::Int) и получить выражение типа Int -> Int ?

как?

Да, у меня плохой пример выше. data F a b = F ( a -> b )

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

нормальный вроде

Грубоват. Люди экспериментируют, это нормально

а какая разница, для того, чтобы применить агрумент к чему-то у тебя должен быть тип a -> ...

а не F``

устал и пора в отпуск

ты можешь определить новый оператор, чтобы fValue $$ 1 2 :: Int работало например

ты можешь определить новый оператор, чтобы fValue $$ 1 2 :: Int работало например

Да, могу. А без него?

Короче, ребята, сорян, я спать

а без него никак я думаю

@graninas вот смотри, какими словами я должен предложить человеку написать типы что он хочет, а не повторять А БЕЗ ЭТОГО

type F a b = a -> b

@graninas вот смотри, какими словами я должен предложить человеку написать типы что он хочет, а не повторять А БЕЗ ЭТОГО

Ну ок.

так можешь, но F это у тебя синоним для обычной функции

(+1) :: F Int Int — (Int -> Int)

Да, могу. А без него?

Никак. Применение аргументов к функции применяет аргументы к функции

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

возможно просто распаковать

например: data F a = F {unF :: a -> a} f = F (+1) unF f 0 contramap (+1) f

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

отлично грохнул ~/.cabal и ~/.ghc и стек сломался

кусок софта :/

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

вообще адище будет

:D

ещё скобки перегрузить

лисп получится сделать?

так если обновлять STACK_ROOT то норм

как может быть прикольной штука у которой не сходятся типы?

Но хаскель вообще даёт сделать два одноимённых терма с разными типами, если один из них -- название "типа", а другой -- конструктор. Не вижу причин, по которой не разрешить также и деструктор называть

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

деструкторы вообще злое-зло

но это не точно

это про С++ сейчас было?

про haskell

я не знаю C++

*Sarcasm*

почему зло то?