<: <, <% <, และ =: = หมายถึงอะไรใน Scala 2.8 และเอกสารเหล่านั้นอยู่ที่ไหน

ฉันเห็นได้ในเอกสาร API สำหรับPredefว่าเป็นประเภทย่อยของประเภทฟังก์ชันทั่วไป (จาก) => ถึง แต่นั่นคือทั้งหมดที่กล่าว เอ่ออะไรนะ? อาจมีเอกสารอยู่บ้าง แต่เครื่องมือค้นหาไม่จัดการ "ชื่อ" เช่น "<: <" ดีมากดังนั้นฉันจึงไม่สามารถค้นหาได้

คำถามติดตามผล: เมื่อใดที่ฉันควรใช้สัญลักษณ์ / คลาสขี้ขลาดเหล่านี้และทำไม

เหล่านี้เรียกว่าทั่วไป จำกัด พวกเขาอนุญาตให้คุณจากภายในคลาสที่กำหนดพารามิเตอร์หรือลักษณะเฉพาะเพื่อจำกัดพารามิเตอร์ประเภทใดประเภทหนึ่ง นี่คือตัวอย่าง:

case class Foo[A](a:A) { // 'A' can be substituted with any type
    // getStringLength can only be used if this is a Foo[String]
    def getStringLength(implicit evidence: A =:= String) = a.length
}

อาร์กิวเมนต์นัยevidenceที่จัดจำหน่ายโดยคอมไพเลอร์, IFF คือA Stringคุณอาจจะคิดว่ามันเป็นหลักฐานที่AจะStringโต้แย้ง --the ตัวเองไม่ได้มีความสำคัญเพียงรู้ว่ามันมีอยู่ [แก้ไข: ดีจริง ๆ แล้วมันมีความสำคัญทางเทคนิคเพราะมันหมายถึงการแปลงโดยปริยายจากAเป็นStringซึ่งเป็นสิ่งที่ช่วยให้คุณสามารถโทรa.lengthและไม่มีคอมไพล์ตะโกนใส่คุณ]

ตอนนี้ฉันสามารถใช้มันอย่างนั้น:

scala> Foo("blah").getStringLength
res6: Int = 4

แต่ถ้าฉันลองใช้กับFooสิ่งที่บรรจุสิ่งอื่นที่ไม่ใช่String:

scala> Foo(123).getStringLength
<console>:9: error: could not find implicit value for parameter evidence: =:=[Int,String]

คุณสามารถอ่านข้อผิดพลาดว่า "ไม่สามารถหาหลักฐานว่า Int == String" ... นั่นเป็นไปตามที่ควรจะเป็น! getStringLengthกำลังกำหนดข้อ จำกัด เพิ่มเติมเกี่ยวกับประเภทของAสิ่งที่เกินความFooต้องการโดยทั่วไป คือคุณจะสามารถเรียกใช้บนgetStringLength Foo[String]ข้อ จำกัด นี้มีการบังคับใช้ในเวลารวบรวมซึ่งยอดเยี่ยม!

<:<และ<%<ทำงานในทำนองเดียวกัน แต่มีการเปลี่ยนแปลงเล็กน้อย:

• A =:= B หมายถึง A จะต้องเป็น B อย่างแน่นอน
• A <:< Bหมายถึง A จะต้องเป็นชนิดย่อยของ B (คล้ายกับข้อ จำกัด ประเภทแบบง่าย<: )
• A <%< Bหมายถึง A ต้องสามารถดูได้เป็น B อาจผ่านการแปลงแบบนัย (คล้ายกับข้อ จำกัด ประเภทแบบง่าย<%)

ตัวอย่างนี้โดย @retronym เป็นคำอธิบายที่ดีเกี่ยวกับวิธีการเรียงลำดับของสิ่งที่เคยประสบความสำเร็จและข้อ จำกัด ประเภททั่วไปทำให้ง่ายขึ้นในขณะนี้

ภาคผนวก

ในการตอบคำถามติดตามผลของคุณตัวอย่างที่ฉันให้นั้นเป็นสิ่งที่ถูกจัดทำขึ้นและไม่มีประโยชน์ชัดเจน แต่ลองจินตนาการว่าใช้มันเพื่อนิยามบางอย่างเช่นList.sumIntsเมธอดซึ่งรวมรายการของจำนวนเต็ม คุณไม่ต้องการที่จะอนุญาตให้วิธีนี้จะเรียกในเก่า ๆเพียงList List[Int]อย่างไรก็ตามตัวListสร้างประเภทไม่สามารถถูก จำกัด ได้ คุณยังต้องการที่จะมีรายการของสตริง foos บาร์และ whatnots ดังนั้นโดยการวางข้อ จำกัด ประเภททั่วไปบนsumIntsคุณสามารถมั่นใจได้ว่าเพียงแค่ว่าวิธีมีข้อ จำกัด List[Int]เพิ่มเติมว่ามันสามารถนำมาใช้ใน โดยพื้นฐานแล้วคุณกำลังเขียนรหัสตัวพิมพ์พิเศษสำหรับรายการบางประเภท

ไม่ใช่คำตอบที่สมบูรณ์ (คนอื่นตอบคำถามนี้ไปแล้ว) ฉันแค่ต้องการจดบันทึกสิ่งต่อไปนี้ซึ่งอาจช่วยให้เข้าใจไวยากรณ์ได้ดีขึ้น: วิธีที่คุณใช้ "โอเปอเรเตอร์" เหล่านี้ตามปกติตัวอย่างเช่นในตัวอย่างของ pelotom:

def getStringLength(implicit evidence: A =:= String)

ทำให้การใช้ทางเลือกที่สกาล่าของไวยากรณ์มัดสำหรับผู้ประกอบการประเภท

ดังนั้นจึงA =:= Stringเป็นเช่นเดียวกับ=:=[A, String](และ=:=เป็นเพียงชั้นเรียนหรือลักษณะที่มีชื่อที่ดูดี) โปรดทราบว่าไวยากรณ์นี้ยังใช้งานได้กับคลาส "ปกติ" ตัวอย่างเช่นคุณสามารถเขียน:

val a: Tuple2[Int, String] = (1, "one")

แบบนี้:

val a: Int Tuple2 String = (1, "one")

มันคล้ายกับไวยากรณ์ทั้งสองสำหรับการเรียกใช้เมธอด "Normal" with .และ()ไวยากรณ์ของโอเปอเรเตอร์

อ่านคำตอบอื่น ๆ เพื่อทำความเข้าใจโครงสร้างเหล่านี้ นี่คือเวลาที่คุณควรใช้ คุณใช้มันเมื่อคุณต้องการ จำกัด วิธีการสำหรับประเภทเฉพาะเท่านั้น

นี่คือตัวอย่าง สมมติว่าคุณต้องการนิยามคู่ที่เป็นเนื้อเดียวกันดังนี้:

class Pair[T](val first: T, val second: T)

ตอนนี้คุณต้องการเพิ่มวิธีsmallerเช่นนี้:

def smaller = if (first < second) first else second

ใช้งานได้เฉพาะในกรณีที่Tมีการสั่งซื้อ คุณสามารถ จำกัด คลาสทั้งหมดได้:

class Pair[T <: Ordered[T]](val first: T, val second: T)

แต่นั่นเป็นความอัปยศ - อาจมีประโยชน์สำหรับชั้นเรียนเมื่อTไม่ได้รับคำสั่ง ด้วยข้อ จำกัด ประเภทคุณยังคงสามารถกำหนดsmallerวิธีการ:

def smaller(implicit ev: T <:< Ordered[T]) = if (first < second) first else second

มันก็โอเคที่จะยกตัวอย่างพูด, a Pair[File], ตราบใดที่คุณไม่ได้โทรหา smallerมัน

ในกรณีของOptionผู้ดำเนินการต้องการorNullวิธีแม้ว่ามันจะไม่สมเหตุสมผลOption[Int]ก็ตาม โดยใช้ข้อ จำกัด ประเภททั้งหมดเป็นอย่างดี คุณสามารถใช้orNullบนOption[String]และคุณสามารถสร้างOption[Int]และใช้งานได้ตราบใดที่คุณไม่โทรหาorNullมัน หากคุณลองSome(42).orNullคุณจะได้รับข้อความที่มีเสน่ห์

 error: Cannot prove that Null <:< Int

ขึ้นอยู่กับว่าพวกเขากำลังใช้อยู่ที่ไหน บ่อยที่สุดเมื่อใช้ในขณะที่ประกาศประเภทของพารามิเตอร์โดยนัยพวกเขาเป็นชั้นเรียน พวกเขาสามารถเป็นวัตถุในกรณีที่หายาก ในที่สุดพวกเขาสามารถเป็นผู้ดำเนินการเกี่ยวกับManifestวัตถุ พวกเขาถูกกำหนดไว้scala.Predefในสองกรณีแรกแม้ว่าจะไม่ได้รับการบันทึกไว้เป็นอย่างดี

พวกเขามีวัตถุประสงค์เพื่อให้วิธีการทดสอบความสัมพันธ์ระหว่างชั้นเรียนเช่นเดียวกับ<:และ<%ทำในสถานการณ์เมื่อหลังไม่สามารถใช้

สำหรับคำถามที่ว่า "ฉันควรใช้เมื่อไหร่" คำตอบคือคุณไม่ควรทำเว้นแต่คุณจะรู้ว่าคุณควรทำ :-) แก้ไข : ตกลงตกลงนี่คือตัวอย่างจากห้องสมุด เมื่อวันที่Eitherคุณมี:

/**
  * Joins an <code>Either</code> through <code>Right</code>.
  */
 def joinRight[A1 >: A, B1 >: B, C](implicit ev: B1 <:< Either[A1, C]): Either[A1, C] = this match {
   case Left(a)  => Left(a)
   case Right(b) => b
 }

 /**
  * Joins an <code>Either</code> through <code>Left</code>.
  */
 def joinLeft[A1 >: A, B1 >: B, C](implicit ev: A1 <:< Either[C, B1]): Either[C, B1] = this match {
   case Left(a)  => a
   case Right(b) => Right(b)
 }

เมื่อวันที่Optionคุณมี:

def orNull[A1 >: A](implicit ev: Null <:< A1): A1 = this getOrElse null

คุณจะพบตัวอย่างอื่น ๆ ในคอลเลกชัน