Mir ist klar, dass einige Dinge in einer Sprache einfacher / schwieriger sind als in der anderen, aber ich interessiere mich nur für typbezogene Funktionen, die in der einen möglich und in der anderen unmöglich / irrelevant sind. Um es genauer zu machen, lassen Sie uns die Haskell-Typ-Erweiterungen ignorieren, da es so viele gibt, die alle möglichen verrückten / coolen Sachen machen.

("Java", wie hier verwendet, ist als Standard Java SE 7 definiert . "Haskell", wie hier verwendet, ist als Standard Haskell 2010 definiert .)

Dinge, die Javas Typsystem hat, aber Haskells nicht:

• nomineller Subtyp Polymorphismus
• teilweise Laufzeit Typinformationen

Dinge, die das Typensystem von Haskell hat, aber das von Java nicht:

• begrenzter Ad-hoc-Polymorphismus
  • führt zu "Constraint-basiertem" Subtyp-Polymorphismus
• höherwertiger parametrischer Polymorphismus
• Haupttypisierung

BEARBEITEN:

Beispiele für jeden der oben aufgeführten Punkte:

Einzigartig für Java (im Vergleich zu Haskell)

Nomineller Subtyp Polymorphismus

/* declare explicit subtypes (limited multiple inheritance is allowed) */
abstract class MyList extends AbstractList<String> implements RandomAccess {

    /* specify a type's additional initialization requirements */
    public MyList(elem1: String) {
        super() /* explicit call to a supertype's implementation */
        this.add(elem1) /* might be overridden in a subtype of this type */
    }

}

/* use a type as one of its supertypes (implicit upcasting) */
List<String> l = new ArrayList<>() /* some inference is available for generics */

Informationen zum Typ der Teillaufzeit

/* find the outermost actual type of a value at runtime */
Class<?> c = l.getClass // will be 'java.util.ArrayList'

/* query the relationship between runtime and compile-time types */
Boolean b = l instanceOf MyList // will be 'false'

Einzigartig für Haskell (im Vergleich zu Java)

Eingeschränkter Ad-hoc-Polymorphismus

-- declare a parametrized bound
class A t where
  -- provide a function via this bound
  tInt :: t Int
  -- require other bounds within the functions provided by this bound
  mtInt :: Monad m => m (t Int)
  mtInt = return tInt -- define bound-provided functions via other bound-provided functions

-- fullfill a bound
instance A Maybe where
  tInt = Just 5
  mtInt = return Nothing -- override defaults

-- require exactly the bounds you need (ideally)
tString :: (Functor t, A t) => t String
tString = fmap show tInt -- use bounds that are implied by a concrete type (e.g., "Show Int")

Polymorphismus des Subtyps "Constraint-based" (basierend auf begrenztem Ad-hoc-Polymorphismus)

-- declare that a bound implies other bounds (introduce a subbound)
class (A t, Applicative t) => B t where -- bounds don't have to provide functions

-- use multiple bounds (intersection types in the context, union types in the full type)
mtString :: (Monad m, B t) => m (t String)
mtString = return mtInt -- use a bound that is implied by another bound (implicit upcasting)

optString :: Maybe String
optString = join mtString -- full types are contravariant in their contexts

Höherwertiger parametrischer Polymorphismus

-- parametrize types over type variables that are themselves parametrized
data OneOrTwoTs t x = OneVariableT (t x) | TwoFixedTs (t Int) (t String)

-- bounds can be higher-kinded, too
class MonadStrip s where
  -- use arbitrarily nested higher-kinded type variables
  strip :: (Monad m, MonadTrans t) => s t m a -> t m a -> m a

Haupttypisierung

Es ist schwierig, ein direktes Beispiel dafür zu geben, aber es bedeutet, dass jeder Ausdruck genau einen maximal allgemeinen Typ (seinen Haupttyp genannt ) hat, der als kanonischer Typ dieses Ausdrucks betrachtet wird. In Bezug auf den Polymorphismus des Subtyps "Constraint-based" (siehe oben) ist der Haupttyp eines Ausdrucks der eindeutige Subtyp jedes möglichen Typs, als den dieser Ausdruck verwendet werden kann. Das Vorhandensein von Principal Typing in (nicht erweitertem) Haskell ermöglicht eine vollständige Typinferenz (dh eine erfolgreiche Typinferenz für jeden Ausdruck, ohne dass Typanmerkungen erforderlich sind). Erweiterungen, die die Haupttypisierung unterbrechen (von denen es viele gibt), unterbrechen auch die Vollständigkeit der Typinferenz.

Javas Typensystem weist keinen höherwertigen Polymorphismus auf. Haskells Typensystem hat es.

Mit anderen Worten: In Java können Typkonstruktoren über Typen abstrahieren, nicht jedoch über Typkonstruktoren, wohingegen in Haskell Typkonstruktoren über Typkonstruktoren und Typen abstrahieren können.

Auf Englisch: In Java kann ein generischer Typ keinen anderen generischen Typ aufnehmen und parametrisieren.

public void <Foo> nonsense(Foo<Integer> i, Foo<String> j)

In Haskell ist das ganz einfach

higherKinded :: Functor f => f Int -> f String
higherKinded = fmap show

Ergänzend zu den anderen Antworten verfügt das Typensystem von Haskell über keine Untertypisierung , während objektorientierte Sprachen wie Java eingegeben werden.

In der Theorie der Programmiersprache ist Subtypisierung (auch Subtyp-Polymorphismus oder Inklusions-Polymorphismus ) eine Form des Typ-Polymorphismus, bei der ein Subtyp ein Datentyp ist, der mit einem anderen Datentyp (dem Supertyp ) durch einen Begriff der Substituierbarkeit verwandt ist , dh, dass Programmelemente, typischerweise Subroutinen oder Funktionen, die geschrieben wurden, um Elemente des Supertyps zu bearbeiten, können auch Elemente des Subtyps bearbeiten. Wenn S ein Subtyp von T ist, wird die Subtyp-Beziehung oft mit S <: T geschrieben, um zu bedeuten, dass jeder Term vom Typ S in einem Kontext, in dem S sicher verwendet werden kann, verwendet werden kannein Begriff vom Typ T wird erwartet. Die genaue Semantik der Subtypisierung hängt entscheidend von den Einzelheiten dessen ab, was "sicher in einem Kontext wo verwendet" in einer gegebenen Programmiersprache bedeutet. Das Typsystem einer Programmiersprache definiert im Wesentlichen eine eigene Subtypisierungsrelation, die durchaus trivial sein kann.

Aufgrund der Untertypisierungsbeziehung kann ein Begriff zu mehr als einem Typ gehören. Subtypisierung ist daher eine Form des Typpolymorphismus. In der objektorientierten Programmierung bezieht sich der Begriff "Polymorphismus" üblicherweise nur auf diesen Subtyp Polymorphismus , während die Techniken des parametrischen Polymorphismus als generische Programmierung betrachtet würden ...

Eine Sache, die bisher niemand erwähnt hat, ist die Typinferenz: Ein Haskell-Compiler kann normalerweise auf die Art der Ausdrücke schließen, aber Sie müssen dem Java-Compiler Ihre Typen im Detail mitteilen. Streng genommen ist dies ein Merkmal des Compilers, aber das Design des Sprach- und Typsystems bestimmt, ob eine Typinferenz möglich ist. Insbesondere interagiert die Typinferenz schlecht mit Javas Subtyp-Polymorphismus und Ad-hoc-Überladung. Im Gegensatz dazu bemühen sich die Designer von Haskell, keine Features einzuführen, die sich auf die Typinferenz auswirken.

Eine andere Sache, die die Leute bisher noch nicht erwähnt haben, sind algebraische Datentypen. Das heißt, die Fähigkeit, Typen aus Summen ('oder') und Produkten ('und') anderer Typen zu konstruieren. Java-Klassen eignen sich gut für Produkte (Feld a und Feld b). Aber sie rechnen nicht wirklich (zB Feld a ODER Feld b). Scala muss dies als mehrere Fallklassen kodieren, was nicht ganz dasselbe ist. Und während es für Scala funktioniert, ist es ein bisschen schwierig zu sagen, dass Java es hat.

Haskell kann auch Funktionstypen mit dem Funktionskonstruktor -> erstellen. Während Javas Methoden Typensignaturen haben, können Sie diese nicht kombinieren.

Das Typensystem von Java ermöglicht eine Art Modularität , die Haskell nicht hat. Es wird eine Weile dauern, bis es ein OSGi für Haskell gibt.