如何在 Haskell 中创建异构列表？ （最初是Java）

如何将以下 Java 实现转换为 Haskell？

这里的主要目的是拥有一个包含作为特定接口的子类型的各种元素的列表。
我尝试制作下面的 Haskell 版本，但未能达到我的目的。 这里的重点是xs有类型[Bar]而不是Foo a => [a]

这是否意味着 Haskell 不能做到这一点，我应该以另一种方式思考吗？

Java

interface Foo {
    void bar ();
}

public class Bar1 implements Foo {
    @Override
    public void bar() {
        System.out.println("I am bar 1 class");
    }   
}

public class Bar2 implements Foo {
    @Override
    public void bar() {
        System.out.println("I am bar 2 class");
    }   
}

public static void main(String[] args) {
    // The major purpose here is having a list 
    // that contains elements which are sub-type of "Foo"
    List<Foo> ys = new ArrayList<Foo>();

    Foo e1 = new Bar1();
    Foo e2 = new Bar2();

    ys.add(e1);
    ys.add(e2);

    for (Foo foo : ys) {
        foo.bar();
    }
}

Haskell

class Foo a where
  bar :: a -> IO ()

data Bar = Bar1 | Bar2

instance Foo Bar where
  bar Bar1 = print "I am Bar1"
  bar Bar2 = print "I am Bar2"

--xs :: Foo a => [a]
xs :: [Bar]
xs = [Bar1, Bar2]

main :: IO ()
main = mapM_ bar xs

简单回答：don't！ Haskell 不是面向对象语言，假装它是面向对象语言并试图将继承模式转换为类型类和 ADT 的混合体并没有多大用处。 https://stackoverflow.com/questions/20184286/object-oriented-programming-in-haskell/20188103#20188103.

Your List<Foo>在 Java 中与Foo a => [a]在 Haskell 中：这样的签名实际上意味着forall a . Foo a => [a]. The a基本上是函数的额外参数，即它可以从外部选择特定的Foo这里使用的是实例。

Quite the opposite in Java: there you don't have any control of what types are in the list at all, only know that they implement the Foo interface. In Haskell, we call this an existential type, and generally avoid it because it's stupid. Ok, you disagree – sorry, you're wrong!
...No, seriously, if you have such an existential list, the only thing you can ever do¹ is execute the bar action. Well, then why not simply put that action in the list right away! IO() actions are values just like anything else (they aren't functions; anyway those can be put in lists just as well). I'd write your program

xs :: [IO ()]
xs = [bar Bar1, bar Bar2]

{-# LANGUAGE ExistentialQuantification #-}

data AFoo = forall a. Foo a => AFoo a

xs :: [AFoo]
xs = [AFoo Bar1, AFoo Bar2]

main = mapM_ (\(AFoo f) -> bar f) xs

因为这已经成为一种咆哮：我确实承认 OO 风格对于某些应用程序来说比 Haskell 的函数式风格更方便。存在确实有其有效的用例（不过，像 chunksOf 50 一样，我更喜欢将它们写为GADTs http://www.haskell.org/haskellwiki/GADTs_for_dummies）。只是，对于很多问题，Haskell 允许提供更简洁、更强大、更通用的解决方案，但在许多方面比您在 OO 编程中使用的“如果您只有一把锤子……”继承更简单，因此在使用存在性之前，您需要应该对 Haskell 的“原生”功能有一个正确的感觉。

¹Yeah, I know you can also do "typesafe dynamic casts" etc. in Java. In Haskell, there's the Typeable class for this kind of stuff. But you might as well use a dynamic language right away if you take such paths.