Scala - Zřetězené porovnávání

Perl 6 / Raku má ne­u­vě­ři­telně bo­ha­tou syn­taxi a jednou z tisíce vy­chy­tá­vek je zře­tě­zené po­rov­ná­vání, kdy se může zapsat pod­mínku ve tvaru 20 <= $x <= 25. Když se na to po­dí­váte, dává to smysl na první pohled, ale vět­šina jazyků výraz ne­vy­hod­notí jako 20 <= $x && $x <= 25, ale jako (20 <= $x) <= 25, což není, co by člověk chtěl.

Nicméně zře­tě­zené po­rov­ná­vání se dá docela pěkně im­ple­men­to­vat ve Scale.

case class CC[T <% Ordered[T]](val v: T, val bool: Boolean = true) {
// view bound T <% Ordered[T] zaručuje, že T má metody <, >, <=, >=

  private def make(x: Boolean) = new CC(v, bool && x)

  def <<:(a: CC[T]) = make(a.v < v) // <: je klíčové slovo - tzv. upper type bound
  def :<<(a: CC[T]) = make(v < a.v)

  def >>:(a: CC[T]) = make(a.v > v) // >: je klíčové slovo - tzv. lower type bound
  def :>>(a: CC[T]) = make(v > a.v)

  def <=:(a: CC[T]) = make(a.v <= v)
  def :<=(a: CC[T]) = make(v <= a.v)

  def >=:(a: CC[T]) = make(a.v >= v)
  def :>=(a: CC[T]) = make(v >= a.v)
}

implicit def v2cc[T <% Ordered[T]](v: T) = new CC(v)
implicit def cc2b[T](v: CC[T]) = v.bool

// test
import scala.language.implicitConversions

val a = 20
val b = 15

println(if (10 <<: a :<< 30) "ok" else "chyba")
println(if (10 <<: a :<< 15) "chyba" else "ok")
println(if (10 <<: a :>> b)  "ok" else "chyba")

Metody kon­čící dvoj­teč­kou se v pozici ope­rá­torů volají v opač­ném pořadí. Metody se bo­hu­žel ne­mů­žou jme­no­vat <: a >:, pro­tože to jsou klí­čová slova. Te­o­re­ticky všechny metody za­čí­na­jící dvoj­teč­kou by mohly mít podobu stan­dard­ních ope­rá­torů po­rov­nání (tedy místo :<< by se po­u­žilo <, místo :>> pak > atd), ale z důvodu kon­zis­tence a jako signál, že se děje něco ne­ka­lého, jsem nechal tvar takový jaký je.

Mi­mo­cho­dem, pří­klad fun­guje díky tomu, že kom­pi­lá­tor im­pli­cit­ními kon­ver­zemi trans­for­muje výraz 10 <<: 15 :<< 20 na cc2b(bv2cc(15).<<:(10).:<<(20)).

Verze pro Scalu 3 je téměř iden­tická (a kromě view bounds bude fun­go­vat i ta před­chozí). Změ­nilo se jen pře­jme­no­vání implicit na given, které nemusí mít jméno a po­u­žití typu Conversion, který je jediný způsob, jak dělat im­pli­citní kon­verze. Ty vyšly z módy jako ma­toucí a po­ten­ci­álně velice ne­bez­pečná vlast­nost jazyka a ve třetí verzi je jejich de­fi­nice ome­zení na typ Conversion a po­u­žití musí před­chá­zet import scala.language.implicitConversions.

case class CC[T: Ordering](v: T, boolVal: Boolean) {
  import Ordering.Implicits.infixOrderingOps

  def <<:(a: CC[T]) = CC(v, boolVal && a.v < v)
  def :<<(a: CC[T]) = CC(v, boolVal && v < a.v)

  def >>:(a: CC[T]) = CC(v, boolVal && a.v > v)
  def :>>(a: CC[T]) = CC(v, boolVal && v > a.v)

  def <=:(a: CC[T]) = CC(v, boolVal && a.v <= v)
  def :<=(a: CC[T]) = CC(v, boolVal && v <= a.v)

  def >=:(a: CC[T]) = CC(v, boolVal && a.v >= v)
  def :>=(a: CC[T]) = CC(v, boolVal && v >= a.v)
}

given [T: Ordering]: Conversion[T, CC[T]] = new CC(_, true)
given [T]: Conversion[CC[T], Boolean] = _.boolVal

import scala.language.implicitConversions

// ...