Scala (programski jezik)

Scala (izgovor: Skala) je programski jezik za opšte softverske aplikacije. Skala ima punu podršku za funkcionalno programiranje i veoma jak sistem statičkih tipova. Ovo omogućava programima napisanim u Skali da budu veoma koncizni i time manjih dimenzija od ostalih programskih jezika opšte namene . Mnoge odluke pri dizajnu Skale bile su inspirisane kritikama nedostataka Jave .

Scala

Paradigma	Multi-paradigma: funkcionalna, objektivno- orijentisana , imperativna, konkurentna
Prvobitni programer(i)	Martin Oderski
Prva verzija	20. januar, 2004; pre 11 godina
Najnovija verzija	2.11.7 / 23. jun, 2015 pre 4 meseca
Disciplina kucanja	dinamična,snažna, zaključna, strukturalna
Platforma	JVM, LLVM, Javaskript
Licenca	3-uslovna BSD licenca
Ekstenzije	.scala
Veb-sajt	www.scala-lang.org
Pod uticajem
Common Lisp, Erlang, Haskell, ML, Prolog, Scheme, Java, Ruby
Uticao na
Elixir, Pixie, Rhine

Predviđeno je da se izvorni kod Skale kompajlira u Java bajt kod, tako da rezultirajući izvršni kod radi na Java virtuelnoj mašini. Java biblioteke mogu da se koriste direktno u Skala kodu i obrnuto (interoperabilnost jezika). Kao i Java, Skala je objektno-orijentisana, i koristi sintaksu koja podseća na C (programski jezik). Za razliku od Jave, Skala ima mnogo karakteristika funkcionalnih programskih jezika kao što su Scheme, Standard ML i Haskel, uključujući kjuring, podrazumevane tipove podataka, nepromenljivosti, lenje evaluacije, i patern mečing. Takođe ima napredni sistem tipova podataka koji podržava algebarski tip podataka, kovarijansu i nekovarijansu, tipove višeg reda (ali ne i tipove višeg ranga), i anonimne tipove. Ostale karakteristike Skale ne postoje u Javi, uključujući preklapanje operatora, fakultativne parametre, nazvane parametre, sirove stringove, i neproverene izuzetke.

Ime Skala je kovanica od "skalabilnosti" i "jezika", što znači da je dizajnirana da raste sa zahtevima svojih korisnika.

Istorija

Nacrt Skale je počeo 2001. godine na Ekol Politeknik Federal de Lozan (EPFL) Martin Oderski, koji se nadovezao na rad na Funelu, programskom jeziku koji kombinuje ideje funkcionalnog programiranja i Petri mreža. Oderski je ranije radio na Dženerik Javi i javcu, San Javi prevodiocu.

Nakon internog puštanja krajem 2003. godine, Skala je javno objavljena početkom 2004. godine na Java platformi, i na . NET platformi juna 2004. godine. Druga verzija (v2.0) ispraćena je marta 2006. godine. Podrška za . NET je zvanično napuštena 2012. godine.

Iako je Skala imala široku podršku za funkcionalno programiranje od početka, Java ostaje čisto objektno-orijentisani jezik do uvođenja lambda izraza sa Javom 8 2014. godine.

Dana 17. januara 2011. godine tim Skale je osvojio donaciju od preko 2,3 miliona € za petogodišnje istraživanje od Evropskog saveta za istraživanje. 12. maja 2011. godine, Oderski i saradnici su pokrenuli Tajpsejf Inc., kompaniju za pružanje komercijalne podrške, obuke i usluga za Skalu. Tajpsejf je dobio investiciju vrednu 3 miliona dolara 2011. godine od Grejlok Partnera.

Platforme i licence

Skala radi na Java platformi (Java virtuelnoj mašini) i kompatibilna je sa postojećim Java programima.  Kako se Android aplikacije uglavnom dostavljaju kao Java bajt kod, Skala je pogodna za njihov razvoj. Skala se može kompilirati u JavaSkript, tako da je moguće napisati Skala programe koji mogu da rade u pretraživaču.

Softver distribucije Skale, uključujući prevodilac i biblioteke, je objavljen pod BSD licencom.

Primeri

Primer "Zdravo, svete"

 object HelloWorld extends App {
   println("Hello, World!")
 }

Za razliku od samostalne Zdravo svete aplikacije za Java, ovde nema klase deklaracije i ništa se proglašava statičnim; unikod kreiran sa objektom ključne reči se koristi.

Sa programom sačuvanim u fajl po imenu ЗдравоСвете.scala, moguće je sastaviti iz komandne linije:

$ scalac ЗдравоСвете.scala

Da bi ga stigao:

$ scala ЗдравоСвете (Mora se koristiti "-cp" ključ kompleta klasnoputnog kao u Javi).

Ovo je analogno procesu prikupljanje i rada Java koda. Zaista, Skala je kompilacija i izvršenje modela identičnom onom iz Jave, što ga čini kompatibilnim sa Java napravom alat, kao što je Ant.

Kraća verzija "Zdravo svete" Skale programa je:

println("Hello, World!")

Skala uključuje interaktivnu školjku i nacrt  podrške. Sačuvano kao fajl pod nazivom ЗдравоСвете2.scala, može da pokrene kao skriptu bez prethodne kompilacije koristeći:

$ scala ЗдравоСвете2.scala

Komande mogu biti unete direktno u Skala interpretator, korišćenjem opcije -e:

$ scala -e 'println("Здраво, свете!")'

Najzad, komanda može biti uneta interaktivno sa REPL:

$ scala
Welcome to Scala version 2.10.3 (OpenJDK 64-Bit Server VM, Java 1.7.0_51).
Type in expressions to have them evaluated.
Type :help for more information.

scala> println("Здраво, свете!")

Zdravo, svete!

scala> 

Osnovni primer

Sledeći primer pokazuje razliku između zapisa u Javi i Skali:

// Java:
int mathFunction(int num) {
    int numSquare = num*num;
    return (int) (Math.cbrt(numSquare) +
      Math.log(numSquare));
}

// Scala: Direct conversion from Java

// no import needed; scala.math
// already imported as `math`
def mathFunction(num: Int): Int = {
  var numSquare: Int = num*num
  return (math.cbrt(numSquare) + math.log(numSquare)).
    asInstanceOf[Int]
}

|

// Scala: More idiomatic
// Uses type inference, omits `return` statement,
// uses `toInt` method, declares numSquare immutable

import math._
def intRoot23(num: Int) = {
  val numSquare = num*num
  (cbrt(numSquare) + log(numSquare)).toInt
}

Neke sintaksne razlike u ovom kodu su:

• Skala ne zahteva zapetu na kraju izjave.
• Tipovi vrednosti su kapitalizovani: Int, Double, Boolean umesto int, double, boolean.
• Parametar i povratak vrste slede, kao i u Paskalu, ili prethode kao u C.
• Metodama mora prethoditi def.
• Lokalnim ili klasama promenljive mora prethoditi val (ukazuje nepromenljivu promenljivu) ili var (ukazuje promenljivu promenljivu).
• Operator return je neophodan u funkciji (iako dozvoljeno);vrednost poslednjeg izvršenog koda ili izraza je normalno vrednost ove funkcije.
• Umesto Java operatora (Type) foo, Skala koristi foo.asInstanceOf[Type], ili specijalne funkcije kao što su toDouble или toInt.
• Umesto u Javi import foo.*;, Skala koristiimport foo._.
• Funkcije ili metoda foo() može se nazvati sad foo; metoda thread.send(signo) može se nazvati sad thread send signo; i metoda foo.toString() može se nazvati foo toString.

Neke druge osnovne sintaksičke razlike:

• Reference reda su napisane kao pozivi funkcija, npr array(i) dok je array[i]. (interno u Skali, oba niza i funkcije konceptualizovane su kao vrste matematičkih mapiranja iz jednog objekta na drugi.)
• Opšte vrste se pišu kao npr List[String] dok u Javi  List<String>.
• Umesto pseudo-tipa void, Skala sadrži aktuelni unikod  Unit (vidi ispod).

Primeri sa klasama

Sledeći primer sadrži definiciju klasa u Javi i Skali.

// Java:
public class Point {
  private final double x, y;

  public Point(final double x, final double y) {
    this.x = x;
    this.y = y;
  }

  public Point(
    final double x, final double y,
    final boolean addToGrid
  ) {
    this(x, y);
  
    if (addToGrid)
      grid.add(this);
  }

  public Point() {
    this(0.0, 0.0);
  }

  public double getX() {
    return x;
  }

  public double getY() {
    return y;
  }

  double distanceToPoint(final Point other) {
    return distanceBetweenPoints(x, y,
      other.x, other.y);
  }

  private static Grid grid = new Grid();

  static double distanceBetweenPoints(
      final double x1, final double y1,
      final double x2, final double y2
  ) {
    return Math.hypot(x1 - x2, y1 - y2);
  }
}

|

// Scala
class Point(
    val x: Double, val y: Double,
    addToGrid: Boolean = false
) {
  import Point._

  if (addToGrid)
    grid.add(this)

  def this() = this(0.0, 0.0)

  def distanceToPoint(other: Point) =
    distanceBetweenPoints(x, y, other.x, other.y)
}

object Point {
  private val grid = new Grid()

  def distanceBetweenPoints(x1: Double, y1: Double,
      x2: Double, y2: Double) = {
    math.hypot(x1 - x2, y1 - y2)
  }
}

Navedeni kod pokazuje neke od konceptualnih razlika između Jave i Skale klase:

• Skala nema statičke promenljive ili metode. Umesto toga, ona ima singleton objekte, koji su u suštini klase sa samo jednim objektom u razredu. Singleton objekti su proglašeni korišćenjem object umesto  class. Uobičajno je da se stave statičke promenljive i metode u singlton objektu sa istim imenom kao i imenom klase, koja je tada poznata kao pratilac objekta. (Osnovna klasa za singleton objekat ima $ u prilogu. Dakle, za class Foo sa pratiocem objekta object Foo, ispod haube ima klasa Foo$ koja sadrži kod pratilac objekta, i jedan objekat ove klase je kreiran, koristeći unikod.)
• Umesto konstruktora parametara, Skala ima parametre klase, koji se nalaze na samim klasama, sličnim parametrima na funkciji. Kada je proglašena sa val ili  var modifikator, polja su takođe definisani sa istim imenom, i automatski se inicijalizuju od parametara klase. (Pod haubom, spoljašnji pristup javnim oblastima uvek prolazi kroz prijemnik (geter) i mutator (seter) metode, koje je automatski kreirao. Prijemnik funkcije ima isto ime kao na terenu, zbog čega je nepotrebno u gornjem primeru do eksplicitno izjasni prijemnik metode.) Paziti da alternativni konstruktori će takođe biti proglašeni, kao u Javi. Kod koji će ići u podrazumevani konstruktor (osim initicializovane promenljive member) ide direktno na nivo klase.
• Uobičajna vidljivost u Skali je public.

Karakteristike (sa osvrtom na Javu)

Skala ima istu kompilaciju modela kao Java i C#, odnosno posebne kompilacije i dinamične klase opterećenja, tako da kod Skale može da pozove Java biblioteke, ili .net biblioteke u implementaciji . NET.

Operativni karakteristike Skale su iste kao Jave. Skala prevodilac generiše bajt kod koji je gotovo identičan onome koji generiše Java prevodilac. U stvari, Skala kod može biti nerazumna za čitanje Java koda, sa izuzetkom nekih konstruktora operacija. Za JVM, Skala kod i Java kod se mogu razlikovati. Jedina razlika je jednostavan ekstra rantajm obrazac, scala-library.jar.

Skala dodaje veliki broj funkcija u poređenju sa Javom, i ima neke fundamentalne razlike u svom osnovnom modelu izraza i vrsta, koje čine teoretski jezik čistijmi i eliminišu veliki broj "korner slučaja" u Javi. Iz perspektive Skale, ovo je praktično važno jer veliki broj dodatnih karakteristika u Skala je takođe dostupan u C#. Primeri uključuju:

Sintaksnu fleksibilnost

Kao što je već pomenuto, Skala ima dosta sintaksnih fleksibilnosti, u poređenju sa Javom. Slede neki primeri:

• Zarepete su nepotrebne; linije automatski počinju ili se završe znakom koji ne može normalno doći u taj položaj, ili ako postoje nezatvorene zagrade ili zagrade.
• Bilo koji postupak se može koristiti kao operator popravke, npr "%d apples".format(num) i  "%d apples" format num su ekvivalentni. Zapravo, aritmetičke operacije poput  + i << se tretiraju kao bilo koje druge metode, jer imena funkcija mogu da se sastoje od sekvence proizvoljnih simbola (sa nekoliko izuzetaka napravljenih za stvari kao što su parens, zagrade i proteze koje se moraju posebno združiti); samo posebnim tretmanom takvi simboli naziva metoda prođu brige rukovanja prioriteta.
• Metode apply i update imaju sintaksno kratke forme. foo()—gde foo je vrednost (singleton objekat ili instanca klase)—je kratak za foo.apply(), i foo() = 42 kratak je za foo.update(42). Slično, foo(42) je kratko za foo.apply(42), i foo(4) = 2 je kratko za foo.update(4, 2). Ovo se koristi za klase prikupljanja i prostire se na mnogim drugim slučajevima, kao što su STM ćelije.
• Skala pravi razliku između ne-parens (def foo = 42) i praznog parens (def foo() = 42) metoda. Kada se poziva prazna-parens metoda, zagrade mogu biti izostavljene, što je korisno prilikom pozivanja Java biblioteka koje ne znaju tu razliku, na primer, koristeći foo.toString umesto  foo.toString(). Po konvenciji, metod treba definisati sa praznim-parensom kada on obavlja  posledice.
• Metod imena završava se dvema tačaka (:) očekivanjem argumenta na levoj strani i prijemnika na desnoj strani. Na primer, 4 :: 2 :: Nil je isto kao Nil.::(2).::(4), prvi oblik odgovara vizuelno rezultatu (lista sa prvog elementa 4 i drugog elementa 2).
• Klasa tela promenljivih se može transparentno sprovoditi posebnim geter i seter metodama. Za trait FooLike { var bar: Int }, implementacija može biti object Foo extends FooLike { private var x = 0; def bar = x; def bar_=(value: Int) { x = value }} } }. Poziv sajt će i dalje moći da koristi koncizan foo.bar = 42.
• Korišćenje velikih zagrada umesto zagrada je dozvoljeno u pozivu metoda. Ovo omogućava čiste implementacije biblioteka novih kontrolnih struktura. Na primer, breakable { ... if (...) break() ... } izgleda isto ako breakable je ključna reč jezika definisana, ali na metoda uzimanja misli se na argument. Metode koje uzimaju istinu ili funkcije i često ih stavljaju listu drugog parametra, dozvoljavajući da se mešaju zagrade i zagrade sintakse: Vector.fill(4) { math.random } je isto kao i Vector.fill(4)(math.random). Protezu kovrdžavih varijanti omogućava izraz spana viših linija.
• Za izraze (objašnjeno dole) može da primi bilo kakvu vrstu koja definiše metode kao što su map, flatMap i filter.

Sami po sebi, oni mogu izgledati kao sporni izbori, ali kolektivno služe kao svrha dozvoljavanja domena specifičnih jezika definisanih u Skali bez potrebe da se produži prevodilac. Na primer, Erlangova specijalna sintaksa za slanje, odnosno. actor ! message može biti (i jeste) sprovođenje u Skali biblioteke bez potrebe jezičkih dodataka.

Objedinjeni tipovi sistema

Java pravi oštru razliku između primitivnog tipa (npr int i boolean) i referentnih vrsta (bilo klasa). Samo referentne vrste su deo šeme nasleđivanja, koja proizilazi iz java.lang.Object. U Skala, međutim, sve vrste su nasleđene od klase na najvišem nivou Any, čija su deca neposredno AnyVal (vrednosni tipovi, poput Int i Boolean) i AnyRef (referentni tipovi, kao u Javi). To znači da Java razlika između primitivnih tipova i kutija vrste (npr. int protiv  Integer) nije prisutna u Skali; kutija i nekutija je potpuno transparentna za korisnika. Skala 2.10 dozvoljava nove vrste vrednosti koje su definisane od strane korisnika.

Za-izrazi

Umesto Java petlje "forič" preko iteratora, Skala ima mnogo snažniji koncept for-izraza. Ovo je slično listi shvatanja u jezicima kao što su Haskel, ili kombinacijom liste shvatanja i generatora izraza u Pajtonu. Za-izraze, koristeći pri tome yield ključna reč omogućava novu kolekciju koja se generiše iterativno preko postojećeg, i vraća novu kolekciju istog tipa. Oni su prevedeni od strane prevodioca u nizu map, flatMap i filter poziva. Gde yield nije korišćen, kod približnih petlji, prevođenjem na foreach.

Prosti primer je:

val s = for (x <- 1 to 25 if x*x > 50) yield 2*x

val s = for (x <- 1 to 25 if x*x > 50) yield 2*x

Rezultat je sledeći vektor:

Vector(16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50)

(Paziti da izraz 1 to 25 nije specijalna sintaksa. Metoda to je prilično definisano u standardu biblioteke Skala kao postupak ekstenzije na cele brojeva, upotrebom tehnike poznate kao implicitne konverzije koji omogućava nove metode dodavanjem postojećih tipova.)

Složenija primer iteratinga preko mape:

// Given a map specifying Twitter users mentioned in a set of tweets,
// and number of times each user was mentioned, look up the users
// in a map of known politicians, and return a new map giving only the
// Democratic politicians (as objects, rather than strings).

val dem_mentions = for {
    (mention, times) <- mentions
    account          <- accounts.get(mention)
    if account.party == "Democratic"
  } yield (account, times)

Izraz (mention, times) <- mentions je primer patern meting (vidi dole). Iterating preko mape vraća skup ključnih vrednosti torki, i obrazac-podudaranja lako omogućava da torke budu u odvojenim varijablama za ključ i vrednost. Slično tome, rezultat shvatanja i vraćanja ključa-vrednosti zapisa, koji je automatski ugrađen nazad u mapi, jer izvor objekta (iz promenljive mentions) je mapa. Paziti ako je mentions umesto održanog lista, komplet, niz ili drugi zbir torki, potpuno isti kod iznad bi dao novu kolekciju istog tipa.

Funkcionalne tendencije

Iako podržava sve objektno-orijentisane raspoložive mogućnosti u Javi (i, u stvari, povećavajući ih na razne načine), Scala takođe pruža veliki broj mogućnosti koje su na obično nalaze samo u funkcionalnim programskim jezicima. Zajedno, ovi osobine omogućavaju Skala programi koji se upisuju u gotovo potpuno funkcionalne stila, a takođe omogućiti funkcionalne i objektno orijentisani stilova da se mešaju.

Primeri su:

• Nema razlike između izjava i izraza
• Tip zaključak
• Anonimne funcije sa snimanjem sematike (tj. zatvarači)
• Nepromenljive varijable i objekti
• Lenja evaluacija
• Razdvojeni nastavci (od 2.8)
• Funkcije visokog reda
• Nested funkcije
• Kjuring
• Patern mečing
• Algebra tipova podataka (kroz "slučaj klasa")
• Torke

Sve je u izrazu

Za razliku od C ili Java, ili slična jezicima kao što su Lisp, Skala ne pravi razliku između izjava i izraza . Sve izjave su u stvari izrazi koji ocenjuju neke vrednosti. Funkcije koje bi se izjasnile kao povratak  void u C ili Javi, izrazi su poput while da logički ne vrati vrednost, u Skali se smatra vrati tip Unit, što je unikod, sa samo jednim objektom tog tipa. Funkcije i operatori koje nikada ne vrati (npr throw operater ili funkcija koja uvek izlazi ne-lokalno koristeći izuzetak) , logično ima povratni tip  Nothing, posebna vrsta ne sadrži nikakve predmete;to jes, dno tipa, odnosno svaku podklasu mogućeg tipa. (Ovo zauzvrat čini tip Nothing kompatibilan sa svim tipovima , omogućavajući tip zaključak da funkcioniše ispravno . ) 

Slično,  if-then-else "izjava" je zapravo izraz, koji proizvodi vrednost, odnosno rezultat procene jednog od dva kraka. To znači da takav blok koda se može umetnuti gde god se želi izraz, izbegavajući potrebu ternarnog operatera u Skali : 

// Java:
int hexDigit = x >= 10 ? x + 'A' - 10 : x + '0';

|

// Scala:
val hexDigit = if (x >= 10) x + 'A' - 10 else x + '0'

Iz sličnih razloga, return izjave nisu potrebne u Skali, a u stvari su obeshrabrene. Kao i u Lisp-u, poslednji izraz u bloku koda je vrednost tog bloka koda, a ako je blok koda telo funkcije, ona će biti vraćena funkcijom. 

def printValue(x: String): Unit = {
  println("I ate a %s".format(x))
}

ili ekvivalentno (sa tipom zaključak, i izostavljanje nepotrebne zagrade) :

def printValue(x: String) = println("I ate a %s" format x)

Tip zaključak

Zbog tipa zaključka, vrste promenljivih, vrednosti funkcija povratka, i mnogi drugi izrazi se obično mogu izostaviti, jer kompajler može zaključiti. Primeri su  val x = "foo" (za nepromenljive, konstantne promenljive ili nepromenljive predmete) ili  var x = 1.5 (za promenljive čija vrednost se kasnije može menjati).

def formatApples(x: Int) = "I ate %d apples".format(x)

ili (sa povratnim tipom za rekurzivnu funkciju)

def factorial(x: Int): Int =
  if (x == 0)
    1
  else
    x*factorial(x - 1)

Anonimne funcije

U Skali, funkcije su objekti, a pogodna sintaksa postoji za određivanje anonimnih funkcija. Primer je izraz  x => x < 2, koji određuje funkciju sa jednim parametrom, koji poredi svoj argument da vidi da li je manje od 2. To je ekvivalentno Lisp obliku  (lambda (x) (< x 2)). Paziti da ni tip  x niti povratni ti izričit, a može generalno zaključiti po tipu izvođenja, ali se može eksplicitno navesti, npr kao  (x: Int) => x < 2 ili (x: Int) => (x < 2): Boolean.

Čak kraći oblik anonimne funkcije koristi čuvare mesta promenljive: na primer, sledeće : 

list map { x => sqrt(x) }

može biti napisana i

list map { sqrt(_) }

ili

list map sqrt

Postojanost

Skala sprovodi razliku između nepromenljivih varijabli, čija vrednost ne može biti promenjena nakon dodele, i promenljivih varijabli, koje se mogu menjati . Slična je razlika između nepromenljivih i promenljivih objekata. Razlika mora postojati kada se proglasi promenljiva: nepromenljive promenljive su deklarisane  val dok promenljive varijable koriste var. Slično tome, svi objekti za sakupljanje (vrste kontejnera) u Skali, npr. povezane liste, nizovi, setovi i heš tabele, dostupni su promenljivim i nepromenljivim varijantama, sa nepromenljivom varijantom smatra se više osnovna i podrazumevana implementacija. Nepromenljive varijante su "uporni" tipovi podataka prave novi objekat koji obuhvata stari objekat i dodaje novi člana (S); ovo je sličan način povezane liste izgrađene u Lisp-u, gde su elementi prependedeni stvaranjem nove "protiv" ćelije sa pokazivačem novog elementa ("glava ") i stare liste ("rep"). Ovo omogućava veoma laku konkurenciju - nema potrebne brave kakoo nema ni zajedničkih objekata ikada modifikovani. Nepromenljive strukture su takođe izgrađene efikasno, u smislu da modifikovanom slučajeva reuses većina starih podataka stepena i neiskorišćenih delova / unreferenced se prikupljaju od GC .

Lenje (nestroge) evaluacije

Evaluacija je stroga ("nestrpljivi"). Drugim rečima, Skala ocenjuje izraze čim su dostupni, nego po potrebi. Međutim, možete proglasi promenljivu nestrogom ( "lenjom" ) sa  lazy ključnom rečju, što znači da kod proizvedi vrednost promenljive i neće biti vrednovana do prvog puta kada se pomene promenljiva. Nestroga skladištenja raznih vrsta takođe postoje (kao što su vrsta  Stream, nestroga povezana lista), i svaka kolekcija postaje nestroga view metodom. Nestroge kolekcije pružaju dobar semantički spreg stvari kao što su server podataka, gde je procena koda za generisanje kasnije elemenata liste (koja zauzvrat izaziva zahtev servera, možda se nalazi negde drugde na internetu) samo se dešava kada stvari potrebe elemente.

Repna rekurzija

Funkcionalni programski jezici obično pružaju optimizaciju rep poziva kako bi se omogućilo široko korišćenje rekurzije bez stek overflou problema. Ograničenja u Java bajt kodovima komplikuju optimizaciju rep poziva na JVM. U principu, funkcija koja sebe poziva rep pozivom može biti optimizovana, ali međusobno rekurzivne funkcije ne mogu. Trampoline su predložene kao alternativno rešenje . Podrška trampoline je pokazana od Skala biblioteke sa objektom  scala.util.control.TailCalls od Skala 2.8.0 (obnovljena 14. jula 2010. godine).

Slučaj klase i obrazac podudaranja

Skala ima ugrađenu podršku za obrazac podudaranja, koji se može posmatrati kao sofisticiranija, proširena verzije izjave svič, gde se mogu poklopiti proizvoljne vrste podataka (a ne samo jednostavne vrste, kao što su celih brojeva, logički i stringovi), uključujući i proizvoljna ugnežđenja. Posebna vrsta klase poznata kao slučaj klase je obezbeđena, čime uključuje automatsku podršku za obrazac podudaranja i može se koristiti za modeliranje algebarskih tipova podataka koji se koriste u mnogim funkcionalnim programskim jezicima.(Iz perspektive Skale, slučaj klasa je jednostavno normalna klasa za koje prevodilac automatski dodaje određena ponašanja koja bi mogla biti obezbeđena manuelno npr definicije metoda koje pružaju duboka poređenja i heširanje, i destrukturiranje je predmet klase na svojim konstruktorima parametara tokom obrasca podudaranja). 

Primer definicije kviksort algoritma pomoću obrasca podudaranja glasi : 

def qsort(list: List[Int]): List[Int] = list match {
  case Nil => Nil
  case pivot :: tail =>
    val (smaller, rest) = tail.partition(_ < pivot)
    qsort(smaller) ::: pivot :: qsort(rest)
}

Ideja je da podelimo u listi elemenata manje od stožera i elemente ne manje, rekursivnim sortiranjem svakog dela, i nalepimo rezultate zajedno sa stožerom između. Ovo koristi ista strategija podeli pa vladaj, mergsorta i drugih algoritama za brzo sortiranje.

Operator match se koristi da uradi podudaranja uzoraka na objektu koji se nalazi u list. Svaki case izraz je pokušao opet da vidi da li će se podudarati, a prvi udar određuje rezultat. U ovom slučaju, Nil odgovara samo doslovno objekat Nil, ali pivot :: tail odgovara nepraznoj listi, i istovremeno opadajućoj listu prema datom obrascu. U tom slučaju, povezan kod će imati pristup lokalnoj promenljivoj po imenu pivot državši glavu na listi, i druge varijable tail držaći rep na listi. Imajte na umu da su ove varijable samo za čitanje, i da su semantički veoma slične promenljivim utvrđenim nizovima koristeći let operator u Lisp-u i Šemi.

Obrazac podudaranje takođe se dešava u lokalnim deklaracijama promenljivih. U tom slučaju, povratak vrednosti poziva se tail.partition je torka - u ovom slučaju, dve liste. (Torke se razlikuju od drugih vrsta ambalaža, npr lista, u koji su uvek fiksne veličine i elementi mogu biti različitih tipova. - Iako ovde su oba isti) uzorak podudaranja je najlakši način da nalaženje dva dela torke.

Forma _ < pivot je deklaracija anonimne funkcije sa čuvarem mesta promenljive; vidi deo o anonimnim funkcijama.

Lista operatora :: (što dodaje element na početku liste, slično cons u Lisp-u i Šemi) i ::: (koji dodaje dve liste zajedno, slično je append u Lisp-u i Šemi), oboje nestaju. Uprkos nastupima, ne postoji ništa "ugrađeno" u vezi bilo kojih od ovih operatera. Kao što je pre specifikovano, svaki niz simbola može poslužiti kao ime funkcije, a metod se primenjuje na objekat koji može biti napisan "infiks" stilom bez perioda ili zagrada. Linija iznad kako je napisano:

qsort(smaller) ::: pivot :: qsort(rest)

može biti zapisana i :

qsort(rest).::(pivot).:::(qsort(smaller))

u više standardnih metoda poziva zapis.(Metode koje se završavaju sa dvotačkom u pravu asocijative i vezuju se za objekat sa desne strane.)

Parcijalne funkcije

U obrascu razbijanja gore navedenog primera, telo match operatora je parcijalna funkcija, koja se sastoji od niza case izraza, sa prvim odgovarajućim preovladavajućim nizom, slično telu izjave. Parcijalne funkcije su takođe koriste u delu rukovanja sa izuzecima  try izjava:

try {
  ...

} catch {
  case nfe:NumberFormatException => { println(nfe); List(0) }
  case _ => Nil
}

Konačno, parcijalna funkcija se može koristiti samo od sebe, a rezultat nazvavši ekvivalentan je radu match . Na primer, prethodni kod za brzo sortiranje može se zapisati sledećim:

val qsort: List[Int] => List[Int] = {
  case Nil => Nil
  case pivot :: tail =>
    val (smaller, rest) = tail.partition(_ < pivot)
    qsort(smaller) ::: pivot :: qsort(rest)
}

Samo za čitanje promenljivih je proglašen tip čija je funkcija lista celih brojeva na listi celih brojeva, i vezuju se parcijalnom funkcijom. (Imajte na umu da jedan parametar parcijalne funkcije se nikada nije izjavio.) Međutim, još uvek možemo nazvati ovu promenljivu baš kao da je u pitanju normalna funkcija:

scala> qsort(List(6,2,5,9))
res32: List[Int] = List(2, 5, 6, 9)

Objektivno-orijentisani izrazi

Skala je čisto objektno-orijentisani jezik u smislu da je svaka Objekat. Tipovi podataka i ponašanja objekata su opisani po vrstama i osobinama. Apstrakcije klasa se produžavaju podklasama i fleksibilnim mehanizmom izmešane kompozicije zasnovane da bi se izbegli problemi višestrukog nasleđivanja.

Osobine zamene Skale je Java interfejs. Interfejs verzija Jave do 8 su veoma ograničeni, mogli su samo da sadrže apstraktne deklaracije funkcija. To je dovelo do kritika da pružanje olakšaju metode interfejsa neprijatno (iste metode moraju biti iste u svakom sprovođenju), a proširenje je objavljen interfejs unazad kompatibilan način je nemoguć. Osobine su slični miksin klasama u tome što imaju skoro svu moć redovne apstraktne klase, u nedostatku samo parametre klase (Skala je ekvivalentno graditelj Java parametara), jer osobine su uvek pomešane sa klasama. Operator super se ponaša posebno u osobinama, omogućavajući osobinama da se lancima korišćenjem kompozicija pored nasledstva. Sledeći primer je jednostavan prozorni sistem:

abstract class Window {
  // abstract
  def draw()
}

class SimpleWindow extends Window {
  def draw() {
    println("in SimpleWindow")
    // draw a basic window
  }
}

trait WindowDecoration extends Window { }

trait HorizontalScrollbarDecoration extends WindowDecoration {
  // "abstract override" is needed here in order for "super()" to work because the parent
  // function is abstract. If it were concrete, regular "override" would be enough.
  abstract override def draw() {
    println("in HorizontalScrollbarDecoration")
    super.draw()
    // now draw a horizontal scrollbar
  }
}

trait VerticalScrollbarDecoration extends WindowDecoration {
  abstract override def draw() {
    println("in VerticalScrollbarDecoration")
    super.draw()
    // now draw a vertical scrollbar
  }
}

trait TitleDecoration extends WindowDecoration {
  abstract override def draw() {
    println("in TitleDecoration")
    super.draw()
    // now draw the title bar
  }
}

Promenljive se mogu deklarisati na sledeći način:

val mywin = new SimpleWindow with VerticalScrollbarDecoration with HorizontalScrollbarDecoration with TitleDecoration

Rezultat pozivanja  mywin.draw() je

in TitleDecoration
in HorizontalScrollbarDecoration
in VerticalScrollbarDecoration
in SimpleWindow

Drugim rečima, poziv draw se prvi izvršava u kodu  TitleDecoration (poslednje osobine se pomešaju), zatim (preko super() poziva) s navojem nazad kroz druge mešovite osobine i na kraju do koda  Window sam, iako nijedna osobina nije nasledila ništa. Ovo je slično obrascu dekoratora, ali je više koncizno i manje sklon greškama, jer ne zahteva eksplicitni matični prozor , eksplicitno prosleđivanje funkcije čija realizacija se ne menja. U drugim jezicima, sličan efekat se može postići kompiliranjem sa dugim linearnim lancem nasleđivanja implementacije , ali na štetu u odnosu da je Skala jedan linearni lanac nasledstvo će biti proglašeno za svaku moguću kombinaciju miks-ins . 

Izražajni tip sistema

Skala je opremljena ekspresivnog statičkim tipom sistema koji nameće bezbedno i koherentno korišćenje apstrakcija. Konkretno, tip sistema podržava : 

• Klase i apstraktni tipovi kao članovi objekta
• Strukturalne tipove
• Zavisne vrste
• Složene tipove
• Izričito samootkucane referenca 
• Generičko programiranje 
• Polimorfne metode
• Gornji i donji tip granice
• Varijacija
• Anotacija
• Preglede

Scala može da zaključi vrste od upotrebe. To radi većina statičkih izjave tipa opcija. Statički tipovi ne moraju biti izričito izjavljeni, osim ako prevodilac ukazuje grešku na potrebu. U praksi, neke statičke izjave tipa su uključeni zbog jasnoće koda . 

Tip obogaćivanja

Zajednički tehnika u Skali, poznat kao "obogati svoju biblioteku" ; ova formulacija se sada gubi zbog svoje konotacije), omogućava da se koriste nove metode kao da su dodati u postojećih tipovima. Ovo je slično C # konceptu savetodavnih metoda, ali moćnije, jer tehnika se ne ograničava na dodavanju postupaka. U Skali, ova tehnika podrazumeva proglašenje implicitne konverzije iz tipa "prima" na novu vrstu (obično klase), koji obavija originalnu vrstu i obezbeđuje dodatnu metodu. Ako se metod ne može naći za datu vrstu, prevodilac automatski traži bilo koju implicitnu konverziju vrsta koje pružaju metod u pitanju . 

Ova tehnika omogućava nove metode da se dodaju u postojeće klase koristeći dodatak biblioteci samo ako kod koji uvozi dodatak biblioteci dobija novu funkcionalnost, a za sve ostalo kod je nepromenljiv . 

Sledeći primer pokazuje obogaćivanje tipa

Int sa metodama isEven i isOdd:

object MyExtensions {
  implicit class IntPredicates(i: Int) {
    def isEven = i % 2 == 0
    def isOdd  = !isEven
  }
}

import MyExtensions._ // bring implicit enrichment into scope
4.isEven // -> true

Ubacivanje članova MyExtensions donosi implicitno pretvaranje mogućnosti produženja klase

IntPredicates u okviru .

Konkurencija

Standardna biblioteka Skale uključuje podršku za aktor modela, pored standardnih Java konkurencija API. Bezbedan tip pruža platformu  koju uključuje Akka, poseban izvor okvir koji omogućava aktor zasnovan na konkurenciji. Akka akteri mogu biti distribuirani ili u kombinaciji sa softverskom transakcionim memorijom ("transaktori"). Alternativna CSP implementacija ima za kanal na bazi poruke preko koje komuniciraju Skala objekti, ili jednostavno preko JCSP.

Aktor kao tema primera za poštansko sanduče . Može biti stvorena  system.actorOf, uključujući receive metodu primljanja poruka i korišćenjem ! (znak uzvika ) metod da se pošalje poruka . Sledeći primer pokazuje EkoServer koji može da prima poruke i zatim i i štampa.

val echoServer = actor(new Act {
  become {
    case msg => println("echo " + msg)
  }
})
echoServer ! "hi"

Skala je takođe podržana paralelnim programima u formi paralelnog skladištenja  integrisanog u standarnoj biblioteci od verzije 2.9.0. Sledeći primer pokazuje korišćenje paralelnih skladištenja performansa.

val urls = List("http://scala-lang.org", "https://github.com/scala/scala")

def fromURL(url: String) = scala.io.Source.fromURL(url)
  .getLines().mkString("\n")

val t = System.currentTimeMillis()
urls.par.map(fromURL(_))
println("time: " + (System.currentTimeMillis - t) + "ms")

Pored aktora podrške i paralelizma, Skala takođe podržava asinhrono programiranje sa budućnošću i obećanjima, softvere transakcijske memorije, i događaje potoka

.

Klaster računarstvo

Dva značajna izvora klaster računarstva su zasnovana na Skali: Apač Spark i Apač Ignit (prilagođeni komercijalnom GridGejn proizvodu) . Osim toga, Apač Kafka je objavio pretplatnu poruku reda popularnosti sa Sparkom i drugim strim procesorima tehnologija, piše u Skali. 

Testiranje

Postoji nekoliko načina testiranja koda u Skali:

• SkalaTest podržava više stilova testiranja i može se integrisati sa okvirima za testiranje baziranim na Javi
• SkalaČek, biblioteka slična Haskel KvikČeku
• specs2, biblioteka za pisanje izvršnih softverskih aplikacija pomoću specifikacija
• SkalaMok podržava testiranje funkcija visokog reda i Kari funkcija
• JUnit ili TestING, dva popularna okvira za testiranje pisana u Javi

Verzije

Verzija	Izdata	Karakteristike	Stanje	Notes
2.0	12-03-2006	_	_	_
2.1.8	23-08-2006	_	_	_
2.3.0	23-11-2006	_	_	_
2.4.0	09-03-2007	_	_	_
2.5.0	02-05-2007	_	_	_
2.6.0	27-07-2007	_	_	_
2.7.0	07-02-2008	_	_	_
2.8.0	14-07-2010	Zajednička revizija, uniforma, i sveobuhvatni okvir za prikupljanje vrsta .	_	_
2.9.0	12-05-2011	_	_	_
2.10	04-01-2013	Vrednost klasa Implicitne klase Interpolirani string Budućnost i obećanja Dinamik i eplDinamik Zavisnost tipova metode: * def identitetom (x: EniRef): x.tajp = x // vraćeni tip kaže da je vraćen  Novi Bajt kod emiter baziran na ASM: Može da označi JDK 1.5, 1.6 and 1.7 / Emits 1.6 bajt kod / star 1.5 bekend je osuđen novi obrazac podudaraa: prepisan od nule da proizvede više robustan kod (ne više eksponencijalni blov-ap!) / generisanje koda i analize su sada nezavisni (ovaj drugi se može isključiti sa -Iksno-petmat-analizom) Skaladok poboljšanja Implicits (implicits zastava) Dijagrami (-dijagrams zastava, zahteva grepviz) Grupe (-grupe) Modularnizovane jezičke karakteristike Paralelne kolekcije sada konfigurisane sa navojem bazena Akka aktori sada deo distribucije \\ skala.aktors su zastareli i implementacija Akka je sada uključena u distribuciju. Poboljšanje performansa: Brži inlajner / opseg # Zbir je sada o (1) Ažuriranje ForkJoin biblioteke Popravke u nepromenljivima TreeSet / TreeMap Poboljšanja parcijalnih funkcija Dodavanje ??? i NotImplementedEror Dodavanje IsTraversejbleOnse +IsTraversejbleLajk klase tipa za proširenje metoda Deprikatije i čišćenje Praćenje tačke i oktalne bukvalne sintakea negodovanja Vraćena skala.dbc Eksperimentalne karakteristike Skala Reflekcije Makroi	_	_
2.10.2	06-06-2013	_	_	_
2.10.3	01-10-2013	_	_	_
2.10.4	18-03-2014	_	_	_
2.10.5	05-03-2015	_	_	_
2.11.0	21-04-2014	_	_	_
2.11.1	20-05-2014	_	_	_
2.11.2	22-06-2014	_	_	_
2.11.4	31-10-2014	_	_	_
2.11.5	08-01-2015	_	_	_
2.11.6	05-03-2015	_	_	_
2.11.7	23-06-2015	_	Trenutno	_

Poređenje sa drugim JVM jezicima

Skala je često u poređenju sa Gruvi i Clojure, dva druga programska jezika koji koriste JVM. Značajne razlike između tih jezika nalaze se u sistemu tipa, u meri u kojoj svaki jezik podržava objektno-orijentisano i funkcionalno programiranje, a u sličnosti njihovih sintaksi u sintaksama Jave.

Skala statički tip, a kako Groovi i Clojure su dinamički tipovi. To čini tip sistem složenijim i teškim za razumevanje, ali omogućava gotovo da sve greške tipa bude uhvaćene u kompiliranje i može se dovesti do znatno bržeg izvršenja. Nasuprot tome, dinamično kucanje zahteva više testiranja kako bi se osigurala ispravnost programa i generalno sporije kako bi se omogućila veća fleksibilnost programiranja i jednostavnost. Što se tiče brzine razlike, trenutne verzije Gruvi i Clojure dozvoljavaju opcione tipove napomena da pomognu programima kako bi izbegli iznad glave dinamičnog kucanja u slučajevima u kojima tipovi su praktično statički. Ovo iznad je dodatno smanjeno kada se koriste najnovije verzije JVM, koja je pojačan sa "dinamičnim izazivanjima". Uputstvo za metode koje su definisane sa dinamičkim otkucanim argumentima. Ovi avansi smanjuju jaz između brzine statičkog i dinamičkog kucanja, iako je statički otkucan jezika, kao Skala, i dalje omiljeni izbor kada je efikasnost izvršenja veoma važna.

Što se tiče programskih paradigmi, Skala nasleđuje objektno-orijentisani model Jave i proširuje ga na razne načine. Gruvi, istovremeno snažno objektno- orijentisan je više usmeren na smanjenje evidentiranja. U Clojure, objektno-orijentisano programiranje je dimpejsed sa funkcionalnim programiranje što je glavna snaga jezika. Skala ima mnoge funkcionalne programske sadržaje, uključujući i mogućnosti nalaska u naprednim funkcionalnih jezika kao što su Haskel, i pokušava da bude agnostik između dve paradigme, puštajući programeru da izabere između dve paradigme ili, češće, neke njihove kombinacije.

Što se tiče sintakse sličnosti sa Javom, Skala nasleđuje mnogo Jave sintakse, kao što je to slučaj sa Gruvi. Clojure sa druge strane sledi Lisp sintaksu, koja se razlikuje i u izgledu i filozofiji. Međutim, učenje Skale se smatra teško zbog njegovih brojnih naprednih funkcija. To nije slučaj sa Gruvi, uprkos činjenici da je takođe bogat funkcijama jezika, uglavnom zato što je dizajniran da bude pre svega skriptni jezik.

Prihvatanje

Rangiranje jezika

Skala je proglašena za najpopularniji JVM pisaći jezik 2012. godine na JavaUan konferencije.

Od 2013. godine, svi derivati bazirani na JVM (Skala / Gruvi / Clojure) su značajno manje popularni od originalnog Java jezika koji se obično rangira kao prvi ili drugi, a koji se takođe istovremeno razvija.

TIOBE Skala od 2006…2015

Od decembra 2013. godine,indeks TIOBE programskog jezika popularnosti pokazuje Skalu na 31. mestu sa 0,342% programera (mereno Internet pretraživačima i sličnim publikacijama brojanja), dok je ispod gornje granice od 50 godina ranije. Skala je sada ispred funkcionalnih jezika Haskel (50.) i Erlang (> 50), kao i JVM konkurenti Gruvi (47.) i Clojure (> 50).

Druga mera, RedMonk programski jezik rang liste, od juna 2013. godine postavlja Skalu 12., zasnovana na 15. poziciji u smislu broja GitHub projekata i 16. u pogledu broja pitanja označenih na Stak Overflou. (Grubi je bio na 18. mestu; Clojure na 22,.) Evo, Skala je jasno iza prve klase grupe od 11 jezika (uključujući Java, C, Pajton, PHP, Rubi, itd), ali vodećih u drugoj prikazanoj grupi.

ToutVorks tehnologija radar, što je mišljenje zasnovano na polu-godišnjem izveštaju o grupi viših tehnologa, preporučuje usvajanje Skale u svojim jezicima i okviri kategoriju.

Prema Indid.com Džob Trends, potražnja Skale naglo raste od 2010. godine, ispred Clojure ali iza Gruvi.

Kompanije

U aprilu 2009. godine, Tviter je objavo da je uključen veliki delovi njegovog bekhend Rubi Skale i nameru da pretvoriti ostatak.

Glit koristi Skalu i Plej Frejmvork.

Forskver koristi Skalu i Lift..

SprinGou koristi Skalu i Akka.

Korosera koristi Skalu i Plej Frejmvork.

Gardijan (novine) najavljuju u aprilu 2011. godine da je prelazak sa Java da Scala,

Njujork tajms otkriva  2014. godine da je interni sistem za upravljanje sadržaja Crnobradi izgrađen korišćenjem Skale, Akke i Peja.

Hafington post novine su počele da zapošljavaju Skalu kao deo svog sistema isporuke sadržaja Atena 2013. godine.

Švajcarska banka UBS uzima Skalu kao glavni produkcioni sistem.

BitGold platforma je u potpunosti izgrađena na Skali i Plej Frejmvorku.

LinkedIn koristi Skalatra mikrofrejmvork za napajanje svoj signal API.

Mitap koristi defilter alat za realno vrme API.

Remember d Milk koristi anfiltred alat, Skalu i Akku javno za API i ažuriranja realnog vremena.

Verizon traži da "sledeće generacije rade" pomoću Skale.

Zamerka

U novembru 2011. godine, Jamer je napustio Skalu zbog strme krive učenja novih članova tima i nekompatibilnosti prethodnih sa sledećim verzijama Skala prevodioca. Drugi kritikuju Skalu zbog nečitljivosti vezanih za implicitne parametre, i zbog toga što nije moguće izbeći Skaline više arkanske karakteristike kada se povuče biblioteka koja ih koristi, te da sve u svemu, "Težina Skale prevazilazi njenu vrednost."

Literatura

• Suereth, Joshua D. (2011). Scala in Depth. Manning Publications. str. 225. ISBN 978-1-935182-70-2. 
• Meredith, Gregory (2011). Monadic Design Patterns for the Web (PDF) (1st izd.). str. 300. 
• Raychaudhuri, Nilanjan (2011). Scala in Action (1st izd.). Manning. str. 525. ISBN 978-1-935182-75-7. 
• Wampler, Dean; Payne, Alex (15. 9. 2009). Programming Scala: Scalability = Functional Programming + Objects (1st izd.). O'Reilly Media. str. 448. ISBN 978-0-596-15595-7. 
• Odersky, Martin; Spoon, Lex; Venners, Bill (13. 12. 2010). Programming in Scala: A Comprehensive Step-by-step Guide (2nd izd.). Artima Inc. str. 883/852. ISBN 978-0-9815316-4-9. 
• Pollak, David (25. 5. 2009). Beginning Scala (1st izd.). Apress. str. 776. ISBN 978-1-4302-1989-7. Arhivirano iz originala 5. 12. 2010. g. Pristupljeno 15. 11. 2015. 
• Perrett, Tim (2011). Lift in Action (1st izd.). Manning. str. 450. ISBN 978-1-935182-80-1. 
• Loverdos, Christos; Syropoulos, Apostolos (2010). Steps in Scala: An Introduction to Object-Functional Programming (1st izd.). Cambridge University Press. str. xviii + 485. ISBN 978-0-521-74758-5. 
• Subramaniam, Venkat (28. 7. 2009). Programming Scala: Tackle Multi-Core Complexity on the Java Virtual Machine (1st izd.). Pragmatic Bookshelf. str. 250. ISBN 978-1-934356-31-9. Arhivirano iz originala 19. 12. 2010. g. Pristupljeno 15. 11. 2015. 
• Horstmann, Cay (2012). Scala for the Impatient (1st izd.). Addison-Wesley Professional. str. 360. ISBN 978-0-321-77409-5. 

Spoljašnje veze

• Zvanični veb-sajt
• Scala communities around the globe