在haskell中的任何工作运算符重载例子

问题描述

我想重载任何操作员。我想做一个这样简单的函数，例如考虑重载==运算符.Overload ==，使得
x == y

返回x。
或x == y返回x + y。没关系。你能告诉我任何简单的操作符重载例子吗？不幸的是，我在web上找不到任何示例。

例如，当我调用Tree a == Tree时，
返回5（它总是返回5。选择它，它与任何东西无关）
或当我打电话3 == 4
return：7

我尝试了下面的代码（我发现它来自haskell.org），但它无法编译。

  class方程式a其中
（==） :: a  - > a  - > Int 
 
实例Eq整数其中
x == y = 5 
 
实例Eq Float其中
x == y = 5 
  
 
 $ b 
以下代码都不起作用：
 
 
数据树a =节点a |空 
 
类树a其中
（==）::树a  - >树a  - > Int 
 
 
 
实例树整数其中
x == y = 1 
 
 
 
我拿错误：
 
 
 不明确的出现'Eq'
它可以指在Operations.hs中定义的'Main.Eq'：4：7 
或'Prelude.Eq' ，从Operations.hs：1：1 
（最初在`GHC.Classes'中定义）中的`Prelude'导入的
 
  
 
 
解决方案
您无法隐藏导入模块中的实例。例如，请参阅： 
 
 
 
它看起来像你正在尝试做的重载是允许（==）用于其他类型的树，比如树。这很容易！只需简单地创建一个新实例即可：
 数据Tree a = Leaf a |分支[树a] 
 
实例（等式a）=> Eq（Tree a）其中
（Leaf a）==（Leaf b）= a == b 
（Branch a）==（Branch b）= a == b 
 _ = = _ = False 
  
 
 
 派生  Eq 实例）
 
I want to overload any operator . i want to do such a simple function that for instance think about overloading of == operator .Overload == such thatx==y
returns x . Or x==y return x+y. It doesn't matter what . Can you show me any simple operator overloading example? I cannot find any example on the web unfortunately.
For example;when i call Tree a == Tree areturn 5   (it always return 5. I select it ,it is not related to any thing)or when i call 3==4return : 7 
I tried the below codes(i find it from haskell.org) but it cannot compile.
class Eq a where
(==) ::a -> a -> Int

instance Eq Integer where
x == y = 5

instance Eq Float where
x == y = 5
Neither the below code works:
data Tree a = Node a | Empty
class Tree a where    (==) :: Tree a -> Tree a -> Int
instance Tree Integer wherex == y = 1
I take the error :
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')
 解决方案 
You can't hide instances from an imported module. See for example: Explicitly import instances
It looks like the "overloading" you're trying to do is to allow (==) for other types, like trees. This is easy! Just simply create a new instance:
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
(You could also just derive the Eq instance)
                        
这篇关于在haskell中的任何工作运算符重载例子的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！