Go třídy ve Scale 📷

Go je relativně nový jazyk z dílny Googlu, který obsahuje několik zajímavých vlastností. Jednou z nich je typový systém. Jednak neobsahuje hierarchii tříd (navzdory faktu, že jde o plně objektový jazyk) a druhak je implicitní, tzn. typy implementují rozhraní implicitně, když mají shodné metody; není tedy nutné explicitně uvádět něco na způsob class X implements I. Což má zajímavé důsledky: třídy z cizích knihoven můžou implementovat vaše ad-hoc rozhraní, není nutné navrhovat hierarchii objektů předem, ale až za pochodu, mimochodem to řeší tuto výtku k typům a modularitě obecně a navíc to vypadá stejně jako strukturální typy ze Scaly.

Takže následující Go interface

type reader interface {
  Read(b []byte) (ret int, err os.Error)
  String() string
}

se dá ve Scala simulovat následovně

type Reader = {
  def Read(b: Array[Byte]): (Int, Int)
  def String: String
}

Kód vypadá zatraceně podobně, což?

A nějaká naše třída DummyReader implementuje Reader, aniž bychom to nějak explicitně zapisovali.

class DummyReader {
  def Read(b: Array[Byte]) = (0, 0)
  def String = "nothing!"
}

Použití nejsou žádné kouzla a čáry:

def test(r: Reader) = {
  val (ret, err) = r.Read("test string".getBytes)
  r.String
}

test(new DummyReader) // tadá, všechno funguje.

Strukturální typy jsou zajímavou vlastností Scaly, pomocí které se dá simulovat spoustu vlastností z jiných jazyků a nabízejí zajímavý potenciál, ale přesto jsem je nikde neviděl serióně použité.

PS: V Go jsem taky něco málo .(a když říkám něco málo, nemyslím tím eufemismus pro docela dost, ale skutečně velice málo) naprogramoval.