标签: parametric-polymorphism

我写了一个类似的函数,Data.Enumerator.List.map它Iteratee与Enumerator一个不同Stream类型的函数兼容.

import Data.Enumerator

test :: Monad m => (ao -> ai) -> Iteratee ai m b -> Iteratee ao m b
test f iter = go $$ iter
   where go (Continue k) = continue $
            \stream -> go $$ k (fmap f stream)
         go (Yield res _) = yield res EOF

如果我省略了类型签名go,这将工作得很好.但是,我想包括它,但我无法确定正确的签名应该是什么.这是我认为它应该是:

go :: Monad m => Step ai m b -> Iteratee ao m b

但这不起作用.
我需要一些关于找到正确类型签名的建议go.

我在抽象的java类中有以下代码:

protected abstract <E extends HasText & IsWidget> E createNewDisplayWidget();

编译好.但是,如果我在任何地方调用它,编译器会抱怨:

Bound mismatch: The generic method createNewDisplayWidget() of type DemoClass is not applicable for the arguments (). The inferred type HasText is not a valid substitute for the bounded parameter <E extends HasText & IsWidget>

有没有办法要求抽象方法返回应该实现多个接口的东西？

注意:不,我无法创建一个实现我喜欢的两个特殊界面.GWT有像Label这样的小部件已经实现了所谓的接口,我想使用这个小部件.

编辑:我从这里想到了这个想法(第22页):

http://java.sun.com/j2se/1.5/pdf/generics-tutorial.pdf

我将如何转换:

trait Foo[A <: Foo[A]]

一个类型的成员？

也就是说,我想要的东西如下:

trait Foo {
  type A <: Foo {type A = ???}
}

但我遇到了困难,因为名称A已经在类型细化中被采用.这个问题类似(并衍生自):通过类型成员而不是类型参数进行F限制量化？

我想弄清楚它是如何NextMethod()工作的.我在S3类系统中找到的最详细的解释是在Chambers&Hastie(edts.)的S中的统计模型(1993,Chapman&Hall)中,但是我发现有关NextMethod调用的部分有点模糊.以下是我试图理解的相关段落(第268-269页).

现在转向由于调用而调用的方法 NextMethod(),这些方法就好像它们是通过特殊调用从前一个方法调用的.对继承方法的调用中的参数在数量,顺序和实际参数名称上与在调用当前方法时的参数相同(因此,在对泛型的调用中).但是,参数的表达式是当前方法的相应形式参数的名称.例如,假设表达式print(ratings)已调用该方法print.ordered().当这个方法调用时 NextMethod(),这相当于对print.factor()表单的调用print.factor(x),这里x是x框架中的 print.ordered().如果多个参数与形式参数" ..." 匹配,那么这些参数在对继承方法y特殊名称" ..1"," ..2"等的调用中表示.评估者识别这些名称并对其进行适当处理(参见第476页的示例).

这个相当微妙的定义的存在是为了确保S中函数调用的语义尽可能干净地使用方法(比较Becker,Chambers和Wilks的The New S Language,第354页).特别是:

• 参数从当前方法传递到继承方法,NextMethod()并调用它们当前的当前值.
• 懒惰的评估继续有效; 未经评估的论点仍未得到评估.
• 继承的方法中缺少缺少的参数.
• 通过 " ..."形式参数传递的参数以正确的参数名称到达.
• 框架中与调用中的实际参数不对应的对象将不会传递给继承的方法."

就参数而言,继承过程基本上是透明的.

我觉得困惑的两点是:

1. 什么是"当前方法",什么是"以前的方法"？
2. "调用继承方法的参数","参数的表达式"和"当前方法的相应形式参数的名称"之间有什么区别？

一般来说,如果有人可以请以一种清醒的方式重述上述段落中的描述,我会很感激.

根据参数多态性的维基百科页面:

类型多态的一些实现在表面上类似于参数多态,同时还引入了特殊方面.一个例子是C++模板专业化.

问题:为什么C++只表示实现与paramaterized多态相似的表面形式？特别是,模板不是完全参数多态的一个例子吗？

参数多态函数

考虑以下功能:

f :: a -> Int
f x = (1 :: Int)

我们可能会说类型f是a -> Int,f因此属于"更高级"类型.

以下哪一项是最准确的思考方式f？

1. 其实也有一个单一 f型的a -> Int.但是,可以使用,作为f :: Int -> Int作为f :: Double -> Int,等等.

2. 从字面上讲,类型f不是a -> Int.实际上,这只是一种简短的说法,即有一类函数f的类型是具体的(即,有一个f :: Int -> Int,一个f :: Double -> Double等等;此外,这些函数中的每一个都是彼此不同的).

更高的金属类型

同样,我们可以考虑以下类型声明:

data Maybe a = Just a | Nothing

并且问两种观点中的哪一种更正确:

1. 没有 …

来自Javascript我明白Haskell的列表类型强制实施同类列表.现在让我感到惊讶的是,以下不同的功能类型满足此要求:

f :: (a -> a) -> a -> a 
f g x = g x

g :: (a -> b) -> a -> b 
g h x = h x

let xs = [f, g] -- type checks

即使g比f以下更广泛适用:

f(\x -> [x]) "foo" -- type error
g(\x -> [x]) "foo" -- type checks

不(a -> a)应该比不加善待(a -> b).在我看来,好像后者是前者的子类型.但是Haskell中没有子类型关系,对吧？那么为什么这样呢？

我正在研究一种用于数据库操作的Haskell-meets-SQL语言,以及一个常见的类型类库,只要有意义,就可以使用Hackage.

因为数据库查询优化器的一个重要目标是消除不必要的排序,所以保留实际上需要排序的静态表示非常重要.这让我们为折叠定义了一个类型类.

Haskell Data.Foldable有:(忽略与我正在制定的点无关的默认定义)

class Foldable t where
  -- | Combine the elements of a structure using a monoid.
  fold :: Monoid m => t m -> m

  -- | Map each element of the structure to a monoid,
  -- and combine the results.
  foldMap :: Monoid m => (a -> m) -> t a -> m

  -- | Right-associative fold of a structure.
  foldr :: (a -> b -> b) -> b -> t a -> b

  -- …

多态"常量",5 :: Num a => a不是真正的常量,而是字典参数的功能.因此,如果你定义

primes :: Num n => [n]
primes = ...

^{当然不好的例子,这里没有充分的理由让它具有多态性...我真正感兴趣的是如果你尝试全局记忆一个非平凡的多态函数,例如memo-tries.}
那么这个序列将不会在来自不同站点的呼叫之间共享,这在性能方面并不好.(这不是Haskell标准用可怕的单态限制祝福我们的主要原因吗？)

我能看到如何强制共享的唯一方法是为约束类的每个实例设置一个单形"标记".例如

erastothenes :: Num n => [n]
erastothenes = ...

class (Num n) => HasPrimes n where
  -- | @'primes' ? 'erastothenes'@
  primes :: [n]

integerPrimes :: [Integer]
integerPrimes = erastothenes

instance HasPrimes Integer where
  primes = integerPrimes

......在优雅方面不是很好.

有没有更好的方法来实现这样的备忘录？

我可以在无类型的Racket中编写一个简单的函数,curry-all它接受一个函数列表,所有这些函数都接受第一个参数的相同类型的值,并生成一个函数列表,其第一个参数是curried.

(define (curry-all fs arg)
  (map (? (f) (curry f arg)) fs))

_{有关上述函数的运行示例,请参阅pasterack上的此代码段.}

这是一个有效的函数,但我不确定是否甚至可以输入Typed Racket给出其多态类型构造.curry它本身的类型已经相当复杂,显然其类型curry-all必然更复杂.

我做了一个相对简单的尝试来输入这个函数,虽然我很清楚它不会像我喜欢的那样起作用:

(: curry-all
   (All [a c b ...]
        (Listof (-> a b ... b c)) a
     -> (Listof (-> b ... b c))))
(define (curry-all fs arg)
  (map (? ([f : (-> a b ... b c)])
         (curry f arg))
       fs))

显然,如果所有函数都具有相同的类型(这并非毫无价值!),则可以正常工作,但如果它们具有不同的arities,即使它们的第一个参数的类型是共享的,它也会失败.

有没有办法指定这个函数的类型,以便它可以在更一般的情况下工作？