("Java" ตามที่ใช้ที่นี่ถูกกำหนดเป็นมาตรฐาน Java SE 7 ; "Haskell" ตามที่ใช้ที่นี่ถูกกำหนดเป็นHaskell 2010 มาตรฐาน )
สิ่งที่ชนิดของระบบ Java มี แต่ Haskell ไม่ได้:
- polymorphism ชนิดย่อยเล็กน้อย
- ข้อมูลประเภทรันไทม์บางส่วน
สิ่งที่ระบบประเภทของ Haskell มี แต่ Java นั้นไม่มี:
- ad-hoc polymorphism ที่ จำกัด
- ก่อให้เกิดความหลากหลายย่อย "ตามข้อ จำกัด "
- ตัวแปรความแปรปรวนของตัวแปรที่สูงกว่า
- การพิมพ์หลัก
แก้ไข:
ตัวอย่างของแต่ละจุดที่กล่าวข้างต้น:
เป็นเอกลักษณ์ของ Java (เมื่อเทียบกับ Haskell)
polymorphism ชนิดย่อยที่กำหนด
/* 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 */
ข้อมูลชนิดรันไทม์บางส่วน
/* 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'
เป็นเอกลักษณ์ของ Haskell (เมื่อเทียบกับ Java)
polymorphism แบบเฉพาะกิจที่ถูกผูกไว้
-- 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")
"ข้อ จำกัด ที่หลากหลาย" หลากหลายประเภท (ขึ้นอยู่กับความหลากหลายโฆษณาเฉพาะกิจ)
-- 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
ตัวแปรความแปรปรวนของตัวแปรที่สูงกว่า
-- 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
อาจารย์ใหญ่พิมพ์
อันนี้ยากที่จะให้ตัวอย่างโดยตรงของ แต่มันหมายความว่าทุกการแสดงออกมีประเภททั่วไปสูงสุดหนึ่ง (เรียกว่าประเภทหลัก ) ซึ่งถือว่าเป็นประเภทที่ยอมรับของการแสดงออกนั้น ในแง่ของ polymorphism ชนิดย่อย "ตามข้อ จำกัด " (ดูด้านบน) ชนิดหลักของนิพจน์คือชนิดย่อยเฉพาะของชนิดที่เป็นไปได้ทุกประเภทที่นิพจน์นั้นสามารถใช้เป็น การปรากฏตัวของการพิมพ์หลักใน (ไม่ขยาย) Haskell คือสิ่งที่ช่วยให้การอนุมานแบบสมบูรณ์ (นั่นคือการอนุมานประเภทที่ประสบความสำเร็จสำหรับทุกการแสดงออกโดยไม่ต้องใช้คำอธิบายประกอบประเภทใด ๆ ) ส่วนขยายที่แบ่งการพิมพ์หลัก (ซึ่งมีจำนวนมาก) ยังทำลายความสมบูรณ์ของการอนุมานประเภท