标签: adhoc-polymorphism

Haskell语言在参考透明度方面提供的确切承诺/保证是什么？至少Haskell报告没有提到这个概念.

考虑表达式

(7^7^7`mod`5`mod`2)

我想知道这个表达式是否为1.为了我的安全,我会做两次这样做:

( (7^7^7`mod`5`mod`2)==1, [False,True]!!(7^7^7`mod`5`mod`2) )

现在给出(True,False)了GHCi 7.4.1.

显然,这个表达现在是参考不透明的.如何判断程序是否受此类行为影响？我可以全部淹没程序,::但这并不能使它具有可读性.我之间是否还有其他类的Haskell程序？这是一个完全注释和未注释的之间？

(除了我在SO上找到的唯一有点相关的问题之外,还有其他一些问题)

我想知道是否有一般方法在ad-hoc多态函数和参数多态函数之间进行转换.换句话说,给定一个ad-hoc多态函数,如何实现其参数对应？反过来呢？

取sort,例如,它很容易写sort :: Ord a => [a] -> [a]在以下方面sortBy:

sort :: Ord a => [a] -> [a]
sort = sortBy compare

但另一种方式似乎很棘手,到目前为止,我能做的最好的事情是有点"面向对象":

import qualified Data.List as L

data OrdVal a = OV (a -> a -> Ordering) a

instance Eq (OrdVal a) where
    (OV cmp a) == (OV _ b) = a `cmp` b == EQ

instance Ord (OrdVal a) where
    (OV cmp a) `compare` (OV _ b) = a `cmp` b

sortBy :: …

我有一个可插入的运行时类型检查器,它支持参数但没有ad-hoc多态,因为没有编译步骤,一旦类型检查器被停用,类型信息就会被删除.

现在我最近提出了使用显式类型来实现类型类的想法,这样我就可以获得它们的一些优点,而无需将基础机制完全合并到类型检查器中:

data Functor f = Functor {fmap :: forall a b. (a -> b) -> f a -> f b}

mapList = Functor map
fmap (mapList) (+1) [1,2,3]

似乎类型类可以使用rank-2类型进行模拟,至少在类型级别,因为当然,仍然没有静态调度.

我的假设是正确的,因为我是Haskell的新手,我的显式算子类型是否比直接使用更有优势map？

这个问题最初是在我研究动态 JS 类型验证器时出现的，它依赖于字典传递样式作为一种相当简单的类型类机制，但我认为它也适用于 Haskell 或其他具有类型类机制的语言。

起初我认为在具有字典传递样式的设置中允许每个类型有多个类型类实例不会有太大问题，因为我可以完全控制类型类解析。但实际问题似乎是维护类型安全而不是类型类解析，因为我将使用类型验证器进行演示。由于代码是类型注释的，因此在某种程度上与语言无关。

// please assume `Number` to be a non-polymorphic `Int` type

Sum.Monoid                          // Monoid<Number>
Prod.Monoid                         // Monoid<Number>
Function.Monoid                     // Monoid<b> -> Monoid<(a -> b)>
Function.Monoid(Prod.Monoid)        // Monoid<(a -> Number)>
Function.Monoid(Prod.Monoid).append // (a -> Number) -> (a -> Number) -> a -> Number

当您应用这些类型时，类型安全会受到影响，因为可以在没有验证器抱怨的情况下编写以下精心设计的表达式：

Function.Monoid(Prod.Monoid)
  .append(inc) (inc) (Sum.Monoid.empty); // yields 1 ((0 + 1) * (0 + 1)) instead of 4 ((1 + 1) * (1 + 1))

在 Haskell 中，每个实例都有自己独特的类型来防止这种无意义的表达。但是必须从一种类型包装器转换为另一种类型包装器可能很乏味。

是否有可行的、类型安全的替代方案，或者这就是 Haskell 的设计者选择不同类型每个类实例的原因吗？

我在理解不同类型的多态性时遇到了问题,特别是在OCaml方面.我知道多态性允许OCaml中的多个类型表示为'a,但我不明白不同类型的多态是什么.
如果有人可以用相对较低级别的语言给我一个解释,那就太棒了!ad hoc,参数,包含/子类型

在 Haskell 编程语言中，根据https://en.wikibooks.org/wiki/Haskell/Category_theory#Translated_categorical_concepts_into_Haskell

\n

59.2.2 将分类概念翻译成 Haskell

\n\n

\n

1. 我们从事该类别的工作Hask我们在该类别及其子类别

\n

2. 对象是类型。

\n

3. 态射是函数。

\n

4. 接受一种类型并返回另一种类型的东西是 type\n 构造函数。

\n

5. 接受一个函数并返回另一个函数的东西是高阶函数。

\n

6. 类型类及其提供的多态性提供了一种很好的方式来捕获这样一个事实：在范畴论中，事物通常同时在多个对象上定义。

\n

\n

类型类表示范畴论中的什么概念？作为一个子类别Hask作为?

我正在学习一些多态性。

rust地址的wiki页面trait是一种实现ad hoc多态性的方法，而ad hoc多态性的页面说的function overloading是ad hoc多态性的一个例子。

根据我目前的理解水平，如果提供不同类型的参数将调用不同的实现，则函数是临时多态的。但trait和function overloading看起来如此不同：trait对类型参数添加约束，任何类型实现都trait可以接受，而函数重载则对具体类型进行重载，任何未重载的类型都是不可接受的。

我可以说trait并function overloading实现相反方向的临时多态性吗？是trait通过专业化还是overloading通过普遍化？

PS：在c++中，模板特化还可以根据传入的类型参数提供不同的实现，这也是ad hoc多态性的一个例子吗？

我试图弄清类型类的目的，如果不使用类型类，还有什么呢？

类型类是定义多态函数的一种方法吗？

类型类是定义多态函数的唯一方法吗？例如：

class Eq a where
    (==), (/=) :: a -> a -> Bool
    x /= y  =  not (x == y)

instance Eq Bool where 
    False == False  =  True 
    True  == True   =  True 
    _     == _      =  False

我可以定义==和/=对Bool（以及任何其他类型），而无需使用类型的类Eq？

在有其他方法的地方，何时应该使用类型类或其他方法来定义多态函数？

我看了一下scalaz教程.

从这个链接,我理解以下代码:

scala> def sum[A](xs: List[A])(implicit m: Monoid[A]): A = xs.foldLeft(m.mzero)(m.mappend)
sum: [A](xs: List[A])(implicit m: Monoid[A])A

scala> implicit val intMonoid = IntMonoid
intMonoid: IntMonoid.type = IntMonoid$@3387dfac

scala> sum(List(1, 2, 3, 4))
res9: Int = 10

但我不明白以下代码:

scala> def sum[A: Monoid](xs: List[A]): A = {
         val m = implicitly[Monoid[A]]
         xs.foldLeft(m.mzero)(m.mappend)
       }
sum: [A](xs: List[A])(implicit evidence$1: Monoid[A])A

scala> sum(List(1, 2, 3, 4))
res10: Int = 10

如果我们考虑List(1, 2, 3, 4),A是一个Int.

那么怎样才能拥有A …