Любой рабочий пример перегрузки оператора в haskell

Я хочу перегрузить любой оператор. Я хочу сделать такую простую функцию, которая, например, думает о перегрузке оператора ==. х == у
возвращает x. Или x == y возвращает x + y. Неважно, что. Можете ли вы показать мне простой пример перегрузки оператора? Я не могу найти какой-либо пример в Интернете, к сожалению.

Например, когда я вызываю Tree a == Tree a return 5 (он всегда возвращается 5. Я выбираю его, он не связан ни с чем) или когда я звоню 3 == 4 return: 7

Я попробовал следующие коды (я нахожу его на haskell.org), но он не может скомпилироваться.

class Eq a where
(==) ::a -> a -> Int

instance Eq Integer where
x == y = 5

instance Eq Float where
x == y = 5

Ни нижний код не работает:

data Дерево a = Node a | Empty

класс Дерево a где (==):: Дерево a → Дерево a → Int

Экземпляр Дерево Целое, где x == y = 1

Я принимаю ошибку:

Ambiguous occurrence `Eq'
It could refer to either `Main.Eq', defined at Operations.hs:4:7
                      or `Prelude.Eq',
                         imported from `Prelude' at Operations.hs:1:1
                         (and originally defined in `GHC.Classes')

Ответ 1

Вы не можете скрывать экземпляры импортированного модуля. См. Например: Явным образом импортировать экземпляры

Похоже, что "перегрузка", которую вы пытаетесь сделать, - это разрешить (==) для других типов, например деревьев. Это легко! Просто создайте новый экземпляр:

data Tree a = Leaf a | Branch [Tree a]

 instance (Eq a) => Eq (Tree a) where
    (Leaf a)   == (Leaf b)   = a == b
    (Branch a) == (Branch b) = a == b
    _          == _          = False

(Вы также можете просто derive экземпляр Eq)

Ответ 2

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

import Prelude hiding ((==))

x == y = x

Ответ 3

Здесь используется оператор +++, который действует как оператор (++), используемый для добавления списков:

(+++) :: [a]->[a]->[a]
x +++ [] = x
[] +++ x = x
x  +++ y = (init x) +++ ((last x) : y)