标签: parametric-polymorphism

我正在研究Haskell并遇到了多态值.这些是具有不同类型的值,具体取决于上下文.例如,Nothing有类型Maybe a或[]有类型[a].[]所有你想要的列表也是如此,你可以在任何预期的列表中使用它.

我很难在Java中找到类似的东西,除了"十亿美元的错误" null,这基本上是任何类型的.可能是与无界通配符相似的泛型,但再次,我想不出一个例子.

Java中有类似的东西吗？

我有一个数据类型和伴随函数，看起来非常像某种遍历。这是一个简化的示例：

data Foo x = MkFoo (Bar x) (Bar x)

almostTraverse :: Applicative f => (Bar a -> f (Bar b)) -> Foo a -> f (Foo b)
almostTraverse f (MkFoo x y) = MkFoo <$> f x <*> f y

假定这Bar是某种不透明类型，并且不一定是函子。是否有某种类型化的泛化almostTraverse？它不是otraversefrom的MonoTraversable，因为应用程序内部的结果类型不必与输入类型完全相同，也不traverse是Traversable二者之一，因为传入的函数Bar尽管不在type参数中，但也需要知道。

这两个F#类型签名之间有什么区别(如果有的话)？

UseTheStream<'a when 'a :> Stream> : 'a -> unit

和

UseTheStream : (stream : Stream) -> unit

在这种情况下,它们的意思是一样的吗？

msdn说出以下关于(:>)类型约束的内容

type-parameter :> type --   The provided type must be equal to or derived from the type      specified, or, if the type is an interface, the provided type must implement the interface.

这表明两个签名正在说同样的话.从功能上来说,它们有何不同？

我正在尝试在C＃中创建参数多态性函数：

我想T成为类型变量。但是我T发现关于类的错误找不到。

有谁知道如何解决这一问题？

谢谢。

    public List<T> getX(SPListItemCollection itemCollection, List<T> itemList, Report RO, WebpartSettings WPS)
    {
        foreach (T item in itemCollection)
        {
            if (have_permissions_for_item(WPS.EDIT_MODE, item, RO))
            {
                itemList.Add(item);
            }
        }
        return itemList;
    }

我有这两个功能:

load :: Asset a => Reference -> IO (Maybe  a)
send :: Asset a => a -> IO ()

Asset类看起来像这样:

class (Typeable a,ToJSON a, FromJSON a) => Asset a where
  ref :: a -> Reference
  ...

第一个从磁盘读取资产,第二个将JSON表示传输到WebSocket.孤立地,它们工作正常,但是当我将它们组合起来时,编译器无法推断出具体类型a应该是什么.(Could not deduce (Asset a0) arising from a use of 'load')

这是有道理的,我没有给一个具体类型和两个load和send多态.不知何故,编译器必须决定使用哪个版本send(以及扩展名为什么版本toJSON).

我可以在运行时确定具体类型a是什么.这些信息实际上是在磁盘上的数据和Reference类型中编码的,但我不确定在编译时是否正在运行类型检查器.

有没有办法在运行时传递正确的类型仍然保持类型检查器快乐？

附加信息

参考文献的定义

data Reference = Ref {
    assetType:: String
  , assetIndex :: Int …

我正在学习Haskell，我刚在书中看到了这个奇怪的数据结构，看起来像这样：data ListaOrd a = a :?: (ListaOrd a) | Nulo deriving Show。据说这应该代表一个有序列表，但是我认为我并不真正理解它。我的问题是，该代码中“：？：”符号的含义是什么？

我在这里处于一种奇怪的情况,即eclipse告诉我Long是"不是有界参数的有效替代品<T extends Comparable<? super T>>".关于可能是什么原因的任何建议？我在下面粘贴相关代码

抽象对:

public abstract class Pair<T extends Comparable<? super T>, R> implements Comparable<Pair<T, R>>{

    private T tt;
    private R rr;

    public Pair(T t, R r){
        tt = t;
        rr = r;
    }

    @Override
    public String toString(){
        return tt+ ": " +rr.toString();
    }
}

具体对:

import utilities.Pair;

public class LogBookRecord<Long, String> extends Pair<Long, String>{

    LogBookRecord(Comparable t, Object r) {
        super(t, r);
        // TODO Auto-generated constructor stub
    }
}

我尝试将抽象类标题更改为:

public abstract class Pair<T extends Comparable<T>, …

我实际上正在寻找一个带有签名的函数,'a -> string它将给定的多态类型转换为字符串.我已经想过类似的东西

let func elem = match elem with
| int -> string_of_int elem ...

希望有人可以帮助我,谢谢!

如何发送通用T？

我尝试将泛型发送T到另一个线程，但我得到：

error[E0308]: mismatched types
  --> src/main.rs:23:22
   |
23 |             t1.merge(Element(vec![3]));
   |                      ^^^^^^^^^^^^^^^^ expected associated type, found struct `Element`
   |
   = note: expected associated type `<T as Join>::Item`
                       found struct `Element`
   = help: consider constraining the associated type `<T as Join>::Item` to `Element`

完整代码：

trait Join {
    type Item;
    fn merge(&mut self, other: Self::Item);
}

#[derive(Debug, Default)]
struct Element(Vec<u8>);

impl Join for Element {
    type Item = Element;
    fn merge(&mut self, mut other: Self::Item) {
        self.0.append(&mut …

在 codewars 的解决方案之一中，我遇到了以下表达式：

join bimap

其中join :: Monad m => m (m a) -> m a, 和 bimap :: Bifunctor p => (a -> b) -> (c -> d) -> p a c -> p b d. 生成的表达式的类型为：Bifunctor p => (c -> d) -> p c c -> p d d。

我可以猜测 的类型bimap可以写成 形式 (->) (a->b) ((->) (c->d) p a c -> p b d)，但我不知道如何p a c转向p c c …