Go třídy ve Scale

Go je re­la­tivně nový jazyk z dílny Googlu, který ob­sa­huje ně­ko­lik za­jí­ma­vých vlast­ností. Jednou z nich je typový systém. Jednak ne­ob­sa­huje hi­e­rar­chii tříd (na­vzdory faktu, že jde o plně ob­jek­tový jazyk) a druhak je im­pli­citní, tzn. typy im­ple­men­tují roz­hraní im­pli­citně, když mají shodné metody; není tedy nutné ex­pli­citně uvádět něco na způsob class X implements I. Což má za­jí­mavé dů­sledky: třídy z cizích kniho­ven můžou im­ple­men­to­vat vaše ad-hoc roz­hraní, není nutné na­vr­ho­vat hi­e­rar­chii ob­jektů předem, ale až za po­chodu, mi­mo­cho­dem to řeší tuto výtku k typům a mo­du­la­ritě obecně a navíc to vypadá stejně jako struk­tu­rální typy ze Scaly.

Takže ná­sle­du­jící Go in­ter­face

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

se dá ve Scala si­mu­lo­vat ná­sle­dovně

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

Kód vypadá za­tra­ceně po­dobně, což?

A nějaká naše třída DummyReader im­ple­men­tuje Reader, aniž bychom to nějak ex­pli­citně za­pi­so­vali.

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

Po­u­ž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.

Struk­tu­rální typy jsou za­jí­ma­vou vlast­ností Scaly, pomocí které se dá si­mu­lo­vat spoustu vlast­ností z jiných jazyků a na­bí­zejí za­jí­mavý po­ten­ciál, ale přesto jsem je nikde ne­vi­děl se­ri­óně po­u­žité.

PS: V Go jsem taky něco málo na­pro­gra­mo­val.