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 naprogramoval.