# Scala (llenguatge de programació)

Scala és un llenguatge de programació modern multi-paradigma dissenyat per a expressar patrons de programació generals d'una manera concisa, elegant i segura respecte als tipus. Integra característiques d'orientació a objectes i de llenguatges funcionals.

## Scala és orientat a objectes

Scala és un llenguatge pur O.O. (orientat a objectes) en el sentit que cada valor és un objecte. Els tipus i comportaments dels objectes són descrits mitjançant classes i 'trets'. L'abstracció classe s'estén mitjançant subclasses i també amb un mecanisme flexible basat en classes 'mixins' (barrejables: similars als interfaces de Java però amb definició de tipus, variables i implementació de mètodes) anomenades trets com a substitució neta de l'herència múltiple.

## Scala és funcional

Scala també és un llenguatge funcional en el sentit que cada funció és un valor. Scala proveeix una sintaxi fàcil per a la definició de funcions anònimes, suporta funcions d'ordre superior, permet la imbricació de funcions i suporta el currying. Les classes per cas (ang.: case classes) i el suport que inclou de reconeixement de patrons, serveix per a modelar tipus algebraics, emprats en molts llenguatges de programació funcional.
A més a més, la noció de reconeixement de patrons estén de manera natural el procés de dades XML amb l'ajuda de seqüències de patrons ignorant el que hi ha a la dreta (ang.:right-ignoring). En aquest context, les comprehensions de seqüències (iteració sobre Generadors-Filtres-Mapeig) són útils per a formular consultes. Aquestes característiques fan de Scala l'ideal per a desenvolupar aplicacions com a serveis web.

## Scala té tipus estàtics

Scala està equipat amb un sistema de tipus expressiu que assegura estàticament que les abstraccions s'utilitzin de manera coherent i segura. En particular el sistema de tipus suporta:
* classes genèriques,
* anotacions de variació,
* acotacions de tipus per dalt i per baix,
* classes internes i tipus abstractes com a membres de l'objecte,
* tipus compostos,
* auto referències tipificades explícitament,
* vistes, i
* mètodes polimòrfics.
Un mecanisme d'inferència de tipus permet que l'usuari no hagi d'anotar els tipus de manera redundant. En combinació, aquestes característiques proporcionen una base potent per a la reutilització segura de les abstraccions de programació i també per a l'extensió de programari amb tipus de dades segurs.

## Scala és extensible

El disseny de Scala reconeix el fet que, a la pràctica, el desenvolupament d'aplicacions d'un domini específic requereix extensions de llenguatge igualment específiques. Scala proporciona una combinació única de mecanismes de llenguatge que fan fàcil afegir noves construccions al llenguatge, amb suavitat, en forma de biblioteques:
* qualsevol mètode pot ser emprat com a operador infix o postfix, i
* els tancaments es construeixen automàticament depenent del tipus esperat.
Un ús conjunt d'ambdues característiques facilita la definició de noves instruccions sense estendre la sintaxi i sense emprar tècniques de meta-programació com ara macros.

## Scala interopera amb Java i .NET

Scala està dissenyat per a interoperar bé amb entorns populars de programació com Java 2 (JRE) i el marc .NET (CLR). En particular, la interacció amb llenguatges orientats a objectes de gran acceptació com Java i C# és força suau. Scala té el mateix model de compilació (compilació separada, càrrega dinàmica de classes) que Java i C#, permetent accedir a milers de biblioteques d'alta qualitat.

## Exemple: Hola món

Per començar:
    Al Linux el podeu instal·lar pels paquets de la distribució. Altrament el compilador es pot descarregar d'aquí o com endollable en un entorn integrat de desenvolupament aquí
El programa Hola món en Scala:
alternativa derivant l'objecte Application (obsolet des de 2.9, ang:deprecated, eliminat a 2.11) es recomana fer servir el mòdul App
El mòdul App afegeix a Application la propietat args que permet accedir als arguments.
* Compilació i execució a consola de comandes:

### Gestor de projectes SBT

Aquesta manera de treballar directament amb el compilador ha quedat una mica antiquada. Si ho fem a través del gestor de projectes SBT, aquest ens descarregarà automàticament la versió del compilador i de les dependències del projecte, esmentades al fitxer de projecte.
Caldrà però seguir l'esquema de directoris especificat per l'SBT.
Al Linux el trobarem al gestor de paquets o bé el podem descarregar d'origen si volem la darrera versió.

### A l'avaluador d'expressions (bucle Read-Eval-Print)

Amb el gestor de projectes SBT podem engegar l'avaluador REPL amb la comanda següent:
* Avaluació d'un mòdul Application (conté mètode main) (obsolet, ang:deprecated)
* Avaluació d'un mòdul App (versió moderna de Application, incorpora membre args).

## Característiques

Degut a ésser un llenguatge dissenyat inicialment per a la màquina virtual JVM, hereta del Java les característiques del lèxic i els tipus bàsics i les seves operacions així com una sintaxi molt similar.
Els punt-i-coma a final de línia es poden ometre (des de la versió 2).
Vegeu l'especificació del llenguatge.

### tipus especials

Vegeu Tipus unificats (amb gràfic) a la ref.

#### Unit

    Tipus d'un sol valor que és: // no-op : no fer res (element neutre per l'esquerra de les operacions)
Resultat buit en efectes col·laterals (actualitzacions, impressions). Equival al tipus de retorn buit (void) de Java i C

#### Any

    generalització d'un tipus qualsevol

#### AnyVal

    generalització dels tipus primaris (els suportats per la CPU) que es passen per valor.

#### AnyRef

    generalització dels tipus que es passen per referència. Correspon a Java.lang.Object

#### ScalaObject

    base per als objectes de Scala (obsolet, retirat a partir de v2.10)

#### Null

    es considera subtipus de qualsevol tipus que es passi per referència (classe o bé object), així el seu valor null pot pertànyer a tots ells.

#### Nothing

    Tipus deshabitat (de valor impossible). És subtipus de tots els tipus. Té diversos usos:
* És el tipus de retorn de les rutines que mai no retornen res, és a dir, que sempre acaben llançant excepcions.
* El tipus List[Nothing] és subtipus de totes les llistes (covariants en el tipus de l'elem.) però no pot tenir elements, així el seu únic valor és Nil que és una extensió del tipus List[Nothing]. Això fa de Nil subtipus de List[T] per qualsevol T.

#### Symbol

    literals: identificadors precedits per l'apòstrof.

#### Opcionals

    El tipus Option[T] amb les variants Some[T] i None facilita l'ús de paràmetres i resultats opcionals
Es pot convertir un valor possiblement nul de Java amb el generador Option(valorNullificable)

#### Llista

    El tipus List[T]

#### Anàlisi per casos dels valors d'una expressió

Per encaix primer valors, després variables amb restricció de tipus (de més a menys específic)
dona

### Igualtat estructural vs. referencial

En la comparació d'objectes, l'operador de Scala (==) no correspon en Java al (==) sinó al mètode equals.
| | Scala | Java | Comentaris |
| igualtat de les referències | eq, ne (classe AnyRef) | (==), (!=) | |
| igualtat estructural | (==), (!=) (classe Any) | .equals | excepte per al tipus Array[T] |
| igualtat dels elements | .sameElements(that: GenIterable[A]) (classe GenIterable) | | permet comparar elems. de diferents estructures |
A Scala la igualtat d'objectes que es passen per referència AnyRef equival a

### polimorfismes
#### polimorfisme paramètric

Les funcions es poden parametritzar per Tipus
exemple:

#### polimorfisme ad-hoc

Afegeix requeriments de context al paràmetre de tipus. A l'exemple amb [A: Numeric] indica que cal que existeixi una instància del genèric Numeric[T] per al tipus A (Numeric[A]), visible en l'àmbit d'ús.
* scala.math.Numeric és la signatura d'un anell unitari ordenat (Numeric especialitza (extends) Ordering).
* scala.math.Integral és la signatura d'un anell unitari euclidià ordenat íntegre (Integral especialitza (extends) Numeric).
* scala.math.Fractional és la signatura d'un cos ordenat (Fractional especialitza (extends) Numeric).

##### quan hi ha una sola instància, equival a la crida amb paràmetre implícit (vegeu #Implícits)
##### quan hi ha més d'una instància d'un genèric (ex. diversos monoides), cal fer servir la crida amb implícit explicitant la instància desitjada
### Relacions de Subtipus

* A <: B indica A subtipus de B
* A >: B indica B subtipus de A
En el següent exemple Tipus ha d'ésser subtipus de TCotaSuperior.
en el següent exemple Tipus ha d'ésser superclasse de TCotaInferior.

#### Subtipatge de funcions i de classes, Covariança, Contravariança

Vegeu ref.
* Una funció f: (A' => B') és subtipus d'una altra funció g: (A => B) (f pot ser emprada en el lloc de g) si el resultat és de tipus més especialitzat (B' <: B) i admet arguments de tipus més general (A' >: A).
Es diu que la funció f subtipus de g és covariant en el resultat (la relació varia en el mateix sentit) i contravariant en el paràmetre de valor. El tipus funció definit a Predef és
Perquè una classe C sigui subtipus d'una altra D, és a dir poder fer servir C com a tipus del paràmetre actual en una crida amb paràmetre formal de tipus D, C ha de contenir subtipus de tots els mètodes de D, a banda d'altres requeriments.
Això ens facilita la deducció de la relació de subtipatge de les col·leccions respecte de la que hi hagi entre els tipus dels elements.
* La covariança d'una classe d'una col·lecció respecte del tipus de l'element es dona si:
Sempre que A <: B llavors C[A] <: C[B]
Així sabem que les llistes, són covariants respecte al tipus de l'element, i mantenen la relació de subtipatge entre llistes d'elements de tipus diferents, si hi és entre els tipus dels elements.
* La contravariança d'una classe es dona si:
Sempre que A <: B llavors C[A] >: C[B]
Perquè una classe C[T] sigui covariant en un tipus T, C[+T], aquest tipus només pot aparèixer en posicions covariants (resultats) dels mètodes i no en les contravariants (arguments). Al revés per a les classes contravariants en T: C[-T]. Però sembla que és una condició necessària però no suficient. Vegeu el Principi de substitució de Liskov
Per utilitzar un tipus covariant en posicions d'argument (contravariant) en un mètode i continuar mantenint la covariança del mètode i, per tant, de la classe, cal fer servir el truc del límit inferior. Cal assegurar que l'argument ha d'admetre tipus més generals que T, fent servir per a l'argument un tipus existencial: aquells tipus U tals que U >: T.

### Tipus producte
#### Classes (tipus producte amb nom), i Objectes singulars

A Scala se separen les parts dinàmica i estàtica de les classes del Java en class i object, objecte singular (únic) que conté els membres estàtics.
Extensibilitat. Els object tenen un tractament unificat amb les classes respecte a l'extensibilitat com si fossin classes d'una sola instància, que els permet implementar interfícies i estendre-les amb altres object i traits com a l'exemple amb l'objecte App.
Grafia. Els identificadors dels mòduls object comencen per majúscula segons el llibre d'estil.
La inicialització dels object i també de les classes, es produeix seqüencialment processant definicions i instruccions executables, com a l'ML Estàndard i l'OCaml.
En importar una classe de Java, l'identificador designa la classe equivalent en Scala amb els mètodes dinàmics (de la instància), així com l'Object que conté els mètodes, variables i constants estàtics.

##### override

    els mètodes que es redefineixen han de dur el qualificatiu override per distingir-los dels que es volen nous, per evitar que si algú afegeix un mètode amb el mateix nom i signatura a alguna de les superclasses o trets que s'hereten, el comportament esdevingui diferent del que se n'espera.

##### val/var (al paràmetre de la classe)

    l'ús de declaradors val/var converteix el paràmetre en un camp membre de la classe, evita redefinir-lo com a camp amb el mateix nom, i haver d'assignar-li el valor del paràmetre dins el constructor.

#### Extractors

Un extractor és un objecte singular que implementa la funció unapply que permet extreure'n el valor en encaixar patrons en les opcions de les clàusules match.

#### tipus "suma" amb classes encaixables

Les classes encaixables (ang:case class) permeten definir com a subtipus les variants d'un tipus suma (unió discriminada) permetent l'anàlisi per casos.
Les classes encaixables són classes per a les quals es defineix, automàticament, un objecte extractor (secció precedent), facilitant l'ús del nom de la classe i els seus paràmetres com a patró en un selector per encaix de patrons match/case.
Equivalència en ML Estàndard:
Equivalència en Haskell:

##### exhaustivitat als encaixos (atribut sealed)

L'atribut sealed (segellat) a la classe abstracta de la qual es deriven les variants encaixables (case classes), permet circumscriure'n la definició de variants al fitxer on està definida, formant un conjunt tancat, facilitant que el compilador pugui avisar per manca d'exhaustivitat als encaixos.
Exemple de compilació amagant el cas Fulla:

### Seqüències numèriques

* Range // classe de seqüències de Int
* Per generalitzar-ho per a enters de qualsevol precisió {Long, Int, Short, Byte}
   NumericRange[T: Integral] // classe de seqüències de tipus que implementen Integral[T] (anell unitari íntegre ordenat euclidià: operacions dels enters)
Les següents expressions retornen un iterador, que es pot fer servir com a generador en una clàusula for, o bé aplicar toList per obtenir-ne una llista.

### Llistes
#### Llistes per comprensió

La clàusula for admet una primera part amb generadors i filtres (clàusula if), i una segona part que pot ésser o bé un bloc d'efectes col·laterals sobre els elements del generador, o bé una clàusula yield (trad.:produeix) que mapeja l'expressió o bloc als elements del primer generador retornant la col·lecció resultant.

##### Encadenament monàdic

Les llistes per comprensió introdueixen l'encadenament monàdic: encadenament d'una acció amb una funció d'efectes col·laterals sobre el resultat precedent, el tipus final és el de l'acció primera amb resultat determinat per la funció (avaluada en segon lloc). L'acció també és assimilable a l'avaluació d'una col·lecció amb el tipus de l'element com a tipus del resultat.
La clàusula for incorpora una seqüència de generadors, guardes (clàusula if), expressions basades en resultats precedents (clàusula let) i cos, que es tradueix en l'ús de les primitives flatMap, filter i finalment map per al cos, retornant sempre una col·lecció del tipus del primer generador, amb elements del tipus del resultat del cos.
Per als tipus amb "efecte fallada" (element absorbent per a flatMap), com ara Option[T], Try[T], List[T], ..., l'encadenament de generadors, filtres i expressions evita la necessitat de consultar la correcció del resultat a cada pas, perquè l'encadenament progressa només per als elements no absorbents per l'esquerra respecte a l'encadenament (aquí l'op. flatMap).
Vegeu presentació "Introduction to Monads in Scala".

### Variables i mètodes

El tipus de les declaracions es pot ometre si es dedueix de la seva inicialització de manera inequívoca, altrament el compilador avisarà.
La diferència entre una definició amb val i un mètode (definit amb def) és que l'assignació amb val es calcula una única vegada, mentre que amb def es recalcula a cada invocació.

### Operadors

Els operadors són mètodes definits amb símbols.
La precedència la determina el primer caràcter del símbol. (Vegeu apartat 'Infix operators' al manual de ref. del llenguatge).

#### associativitat per la dreta explícita

L'associativitat la determina el darrer caràcter del símbol, que si és ':' llavors és associatiu per la dreta, altrament associatiu per l'esquerra. Vegeu ScalaReference.pdf (paràgraf 6.12.3 Infix Operations).
L'associativitat per la dreta, en agrupar per la dreta, requereix que l'operador en notació infix s'avaluï com a mètode del tipus de l'operand de la dreta:
L'associativitat per la dreta pels ':' finals, afecta a més dels operadors, als constructors definits amb símbols, com ara (::) el "Cons" de les llistes i també (#::) el "Cons" dels Stream.

### Trets (ang:traits): el sistema d'extensió de classes i d'objectes singulars

La paraula anglesa trait es pot traduir per tret o característica (vegeu diccionaris d'anglès).
Un tret encapsula una característica incorporable a una classe d'objectes o bé a un object singular.
Són assimilables als interface del Java, però amb el potencial d'una classe abstracta.
Els trets poden contenir estructura (camps), comportament (mètodes) i tipus associats, tant abstractes com concrets (amb implementació), però no són instanciables per si mateixos, ni podien tenir paràmetres de valor. Això canviarà pròximament permetent els paràmetres als trets.

#### herència múltiple

L'herència múltiple es basa en la incorporació de trets.
dona el resultat:

#### Restricció del tipus propi (ang:self-types)

La restricció al tipus propi en un tret (especificant un identificador, com ara self, abans de =>) permet relacionar un tret amb una instància concreta d'un tipus abstracte. És possible utilitzar this per aquest afer, però en cas de referir-s'hi en una classe interna (niuada) l'identificador this quedaria tapat. this es referiria a l'objecte corresponent a la classe interna i no a l'externa.
Del document "Scala Component Abstractions" de M.Odersky.
Solució amb self-types

### Anàlisi per casos del subtipatge per especialització

Refinament de tipus (ang: Downcasting) al d'una classe derivada, amb caracterització mitjançant asInstanceOf prèvia comprovació amb isInstanceOf.

### Parametrització de tipus amb cota superior

Admetre tipus més especialitzats que un tipus determinat.

### funcions amb llista d'arguments variable

El símbol '*' després del tipus del darrer argument, indica que el paràmetre actual corresponent pot aparèixer zero o més vegades, i que cal prendre aquest argument com una seqüència.

### funcions anònimes com a expressió

exemple:
En l'exemple següent el compilador dedueix els tipus dels paràmetres de la funció sobre la qual s'aplica.
dona l'esperat

#### Aplicació parcial d'operadors i mètodes

L'aplicació parcial d'operadors s'expressa substituint un o més operands pel comodí '_' en una expressió. Ex. (3 + _) : (Int => Int)
* També es pot referir a mètodes: (_.toString) : (Any => String)

#### Aplicació parcial d'una funció

Per obtenir el valor de funció dels mètodes def d'un object (que són mètodes estàtics) i poder passar-lo com a paràmetre a una funció d'ordre superior, cal substituir els paràmetres no aplicats amb un únic comodí '_'.
Scala no té polimorfisme d'ordre superior (ang:impredicative polymorphism), per tant les funcions que es passen com a paràmetre no poden ser polimòrfiques (cal donar valor als seus paràmetres de tipus).

#### Composició i currificació de funcions

La interfície Function1 de funcions d'un argument aporta mètodes per la composició de funcions.
La interfície Function2 de funcions de dos arguments aporta mètodes per obtenir versions currificades (.curried) i la inversa (.tupled).
Function3 a Function19 també definides.

#### funcions d'ordre superior

Amb funcions als paràmetres o al resultat.

### Definició per patrons d'una funció - El tret PartialFunction

Vegeu "Pattern-matching anonymous functions".
Equival a la definició per encaixos dels llenguatges funcionals (ex.: Haskell) amb un sol paràmetre i un resultat.
Una definició per seqüència de patrons, si no són exhaustius, és una funció definida parcialment.
Les funcions amb definició per patrons implementen el tret PartialFunction[A /*entrada*/, B /*resultat*/], amb mètodes molt interessants.
La funció pf.isDefinedAt(x:A) retorna si el paràmetre encaixa en alguna de les clàusules case (filtres compresos) !!
El mètode lift com a pf.lift embolcalla el resultat en un Option oferint una versió total de la funció parcial.
El mètode applyOrElse permet especificar una funció per defecte per als casos no definits.
El mètode orElse admet la composició amb una altra funció parcial, que s'avalua per als casos no definits de la primera.
* A les col·leccions:
collect mapeja amb una funció parcial obtenint la col·lecció de les imatges d'aquells elements per als quals la funció està definida:

### Excepcions
#### Excepcions en la Gestió de recursos

La clàusula try {..} catch (err:Throwable) {..} finally {..} possiblita la gestió d'excepcions i alliberament de recursos.
L'objecte Exception aporta diverses possibilitats addicionals.

##### gestió automàtica

La recent construcció a Java 7 try-with-resources que encapsula el recurs i el seu alliberament ha fet repensar una clàusula semblant a Scala. Per a l'anomenat "Loan pattern" o patró del préstec (perquè el recurs s'ha de tornar), es proposa la següent construcció (Closeable és una interfície de Java)
La biblioteca scala-arm proporciona una implementació a través de la implementació monàdica de les clàusules for, que evita el niuament de construccions en cas d'adquisició de múltiples recursos.

#### Anàlisi per casos de l'èxit o fracàs de l'avaluació. La classe Try

El generador Try(expr) avalua una expressió que pot llançar excepcions, permetent analitzar per casos l'èxit o fracàs de l'avaluació, oferint com a resultat dues variants d'encaix (case classes) de la classe Try[T] que són Success(resultat:T) i Failure(excepció:Throwable).
A més implementa la classe de tipus Mònada amb (Failure(e:Throwable)) com a element absorbent de l'encadenament, de manera que en una clàusula for (avaluació monàdica) la fallada fa que no s'avaluïn les clàusules subsegüents del for evitant la necessitat de comprovació de l'èxit a cada pas.
A l'exemple el tipus del for és com sempre el del primer generador, en aquest cas un tipus Try.

#### Disseny per Contracte

Precondicions, postcondicions i invariants

##### Assercions

Vegeu Assercions i Opció de compilació -enableassertions

###### assert(predicat [,missatge])

    especifica un predicat que cal provar i dispara l'excepció java.lang.AssertionError: assertion failed: missatge

###### assume(axioma [,missatge])

    especifica un axioma (asserció que les eines de comprovació estàtica de tipus no han de deduir de proposicions precedents). En temps d'execució actua com un assert disparant l'excepció java.lang.AssertionError: assumption failed: missatge

###### error(missatge)

    per al cas d'estats inconsistents o bé de funció no definida per un cas dels paràmetres
    indica implementació pendent, dispara UnsupportedOperationException("not implemented").

##### Precondició

La clàusula require ha estat declarada obsoleta i retirada a la v2.8.
Es recomana fer servir la definició per patrons per especificar les precondicions.

##### Postcondició
###### {acció} ensuring (_ => condició [,missatge])

    asserció com a funció sobre el resultat d'un bloc de codi.

#### Anàlisi per casos de l'avaluació de funcions parcials

És interessant evitar les funcions que disparen error degut a paràmetres il·legals o estats inconsistents, i obtenir-ne versions amb resultat opcional (Option[T]) que obliga a analitzar el resultat a la rutina que fa la crida.
Vegeu també #Definició per patrons d'una funció - El tret PartialFunction
Igualment les funcions que disparen excepcions poden ser avaluades amb Try(expressió) oferint resultat de tipus Try[T] que retorna o bé el resultat, amb la variant Success[T](v:T), o bé l'excepció amb Failure(e:Throwable), evitant que aquesta es propagui més amunt.

### XML al codi

Admet notació de llenguatge de marques XML com a literal, amb interpolació d'expressions entre claus "". Vegeu
El paquet de tractament de XML scala.xml, que anteriorment formava part de la biblioteca base de Scala, ha estat separat en un paquet Jar independent que es pot obtenir amb el codi font al GitHub d'aquí.

### Implícits

Scala té diversos mecanismes relacionats amb el tipus que busquen automàticament entre les instàncies visibles en l'àmbit,
   * o bé la conversió implícita de tipus,
   * o bé, en cas d'un genèric de tipus (classe de tipus), la implementació corresponent al tipus emprat (tipus del paràmetre actual).

#### Vistes de tipus (conversions implícites)

Si el tipus del paràmetre actual no correspon amb el del paràmetre formal, però existeix una funció de conversió implícita entre ambdós tipus:

#### Restricció de Convertibilitat (View bound)

És una alternativa menys estricta que un requeriment de subtipatge.
type A <% T // indica que cal que existeixi una conversió implícita de A a T. Vegeu Scala Views

#### Instàncies implícites de classes de tipus

El mecanisme dels implicit objects permet obtenir la instància (implementació) d'una classe de tipus (classe abstracta genèrica parametritzada per un tipus) per al tipus del paràmetre actual.
A l'exemple el paràmetre (implicit m: Monoid[A]), m obtindrà el valor de la instància específica del genèric Monoid[A] per al tipus del paràmetre actual emprat en la crida a la funció def sumaLlista[A](xs: List[A])(implicit m: Monoid[A]).

##### Restricció de context (Context bound) i obtenció d'instàncies amb implicitly

Introdueix el requeriment d'instanciació de classes de tipus (genèrics) en el paràmetre de tipus.
La restricció de context [A: Monoid] indica que cal que hi hagi una instància de Monoid per al tipus A, visible en l'àmbit d'ús.
Codificació alternativa de sumaLlista. La instància de Monoid s'obté amb implicitly.

##### Restricció de context respecte a Paràmetre implicit - Ordered i Ordering

Ordered[A] i Ordering[A] ofereixen una funcionalitat similar
* El tret Ordered[A] equival a la interfície "Ordenat" i implementa la ordenació bàsica del tipus i només se'n defineix una de sola. Es pot especificar com a requeriment de context
* El tret Ordering[A] (Ordenació) equival a una classe de tipus instanciable en implicit objects per tipus, i en podem tenir diverses instàncies per al mateix tipus, amb relacions d'ordre diferents (ascendent, descendent, basada en un component, ...). Per explicitar la que vulguem, s'ha de fer servir com a paràmetre implícit.

##### Injecció de mètodes

La conversió implícita d'un tipus a una classe o tret, té l'efecte d'augmentar els mètodes per al tipus que es converteix.
* Augment ràpid (en escriure'l però més lent d'execució).

### Convenció per indicar efectes col·laterals en els mètodes sense paràmetres

* Per convenció, els mètodes sense paràmetres podran ometre els parèntesis, a la definició i en l'ús, per indicar que no inclouen efectes col·laterals.

### Avaluació tardana (ang: lazy)
#### valors lazy val (retarda l'avaluació fins que fa falta en una expressió)

    amb el qualificador lazy, l'expressió només s'avalua quan fa falta alguna variable del patró, i, a més a més, per l'ús de val memoritza el valor (aprofita el resultat en crides posteriors)

#### paràmetres per-nom (param: => tipus) (Call by name)

    afegint => abans del tipus, aquests paràmetres s'avaluen substituint el nom del paràmetre en el codi per l'expressió del paràmetre actual.
execució a l'intèrpret:

#### Vistes

    Avaluació no-estricta de les col·leccions.

#### Traversable.view

    genera una "vista d'avaluació diferida" d'una col·lecció, resultant un tipus TraversableView. Les transformacions que s'hi apliquin (map, filter, etc.), en comptes de generar una nova estructura, quedaran pendents d'aplicació generant una nova vista, fins que s'hi apliqui el mètode force.

#### Traversable.toIterator

    permet recórrer una estructura una sola vegada (l'iterador muda de valor a cada 'next'). Els elements s'obtenen per necessitat, evitant la generació d'estructures intermèdies en les transformacions successives de l'estil de map, filter, fold.

#### Traversable.toStream

    permet obtenir-ne els elements de manera tardana (per necessitat). Els streams es poden recórrer tants cops com calgui a partir d'una referència, per què hi ha memoïtzació (memorització en una taula dels resultats evitant el recàlcul).

#### evitant la necessitat de desforestació

En l'aplicació funcional successiva, ex.: estructura.filtre(predicat).map(funcióDeTransformació).reducció(op_binària), les classes Iterator i Stream, en recuperar els elements de manera tardana, eviten la problemàtica de la desforestació (malversació d'espai per la creació d'estructures intermèdies temporals quan l'avaluació és estricta) i la necessitat d'escriure rutines multifunció filtreMapReducció(predicat, funcióDeTransformació, op_binària) d'un sol bucle per solucionar-ho.

#### Intervals numèrics

La classe Range permet definir iteradors (avaluació tardana) sobre seqüències numèriques de tipus Int.
La classe NumericRange[T] generalitza la classe Range a sencers de diferents precisions (Han d'implementar Integral[T] (anell unitari íntegre ordenat euclidià: ops. dels enters).

### La API de Scala

Scala té una llarga biblioteca per facilitar la feina amb varietat de col·leccions immutables i mudables així com tractament de XML i altres que trobareu aquí.
L'especificació oficial del llenguatge és aquí.
Els elements predefinits són a l'object Predef

#### Cercadors de l'API

La API de Scala www.scala-lang.org/api/current/ permet cercar per nom de paquet, o signatures d'àmbit global.
* Hi ha un cercador d'índex de biblioteques a la mateixa web anomenat "Scaladex": index.scala-lang.org
* La web Scalex.org Arxivat 2020-11-11 a Wayback Machine. permetia, fins fa poc, cercar els identificadors exportats per un paquet, de manera similar a Hayoo o bé Hoogle per al llenguatge Haskell. Tanmateix se'n pot descarregar el codi del Github.
* Des del Setembre/2015 hi ha un nou cercador anomenat "Scaps" a scala-search.org Arxivat 2016-06-10 a Wayback Machine..

#### Biblioteques

Alguns paquets que abans estaven inclosos a la biblioteca bàsica, com ara scala.xml, ara s'han de referenciar separadament des del GitHub de Scala.
La llista de biblioteques de tercers és a Scala wiki - Tools and Libraries.

### Scala Actors -- Concurrència amb el model d'Actors

Vegeu ref.

### STM (Transaccions de memòria per programari)

Vegeu ref.

### Col·leccions

Vegeu ref.
Gràfic de les col·leccions immutables.
Gràfic de les col·leccions mudables.

#### paral·lelisme

    Scala també disposa de col·leccions per al paral·lelisme, per aprofitar la potència dels processadors multicor amb algorismes que utilitzen l'estratègia "dividir i vèncer". El mètode par ofereix implementacions amb paral·lelisme de la majoria de col·leccions que implementen el tret ParIterable amb l'ajut d'un particionador (Splitter) que ofereix un iterador sobre les subcol·leccions disjuntes resultants de la partició.

#### concurrència

    Existeix una versió de diccionaris TrieMap (basats en arbres de prefix i taula de dispersió (ang:hash-array)) per a l'accés concurrent (simultani des de diversos fils d'execució) i lliure de baldes (ang:lock-free).

#### operacions comunes dels mòduls estàtics (object) que acompanyen les col·leccions

Vegeu "Creating collections".

#### operacions comunes de les classes de les col·leccions

* Seqüències (entre d'altres):
* IndexedSeq: seqüències d'accés aleatori: ArrayBuffer, Vector, ...
* LinearSeq: seqüències d'accés lineal (d'un amb un)
   * avaluació estricta: List, Queue
   * avaluació tardana: Iterator, Stream
   * avaluació diferida: TraversableView (difereix l'avaluació dels mètodes aplicats, fins que s'aplica .force o se'n demana la conversió a una col·lecció concreta)
* Altres signatures: Traversable, Iterable, Set, Map

#### Interfície TraversableOnce

Vegeu ref.
* interfície per les operacions de Reducció d'una col·lecció a un valor (gramaticalment: A* ⇒ A)
   * plegats sobre domini que implementi Numèric, math.Numeric és la signatura d'un Anell unitari ordenat
   * plegats de col·leccions d'elements ordenats, o via projecció a imatge ordenable.

#### Interfície Traversable

Interfície TraversableLike per al recorregut (visita dels elements) d'una col·lecció; defineix foreach i conté la major part dels mètodes de Traversable, afegeix a TraversableOnce, a banda d'altres trets, els mètodes següents
* Consulta
* Combina
* Visita i/o transforma
* Partició
* Reducció

#### El tret CanBuildFrom

El tret CanBuildFrom[-ColOrigen, -Elem, +ColDestí] descriu una interfície genèrica per la generació de col·leccions des d'altres col·leccions amb implementacions optimitzades per a tipus específics quines instàncies (objectes implícits) han d'estar visibles.
És d'interés quan, com a sortida d'un mètode d'una col·lecció, es vol crear una col·lecció diferent. Per això només caldrà especificar, amb una restricció del tipus resultant, la col·lecció de destinació.

#### Interficie Iterable

IterableLike, caracteritzada per definir un iterador que faciliti visitar els elements, i que conté la major part dels mètodes d'Iterable afegeix a TraversableLike entre d'altres els següents:
* partició:
* combinació:

#### mètodes de consulta específics

* seqüències com a Multiconjunt
* seqüències, accés indexat [0..
* seqüències, consulta de subseqüències
* seqüències, ordenació

#### operadors d'actualització

Els operadors binaris en notació infix i associatius per la dreta (aquells quin símbol acaba en ':') s'avaluen sintàcticament com a mètodes de l'operand de la dreta. (exemple: x1 +: (x2 +: xs); la col·lecció va a la dreta quan l'operador acaba en ':')
Cas d'operacions amb dues versions funcional i imperativa, s'utilitza el mode verbal infinitiu per la versió imperativa i el mode verbal participi per la versió funcional. Per exemple a les seqüències d'accés aleatori (IndexedSeq[A]) update és la versió imperativa i updated la versió funcional.

##### a les seqüències

per a les seqüències dels tipus immutable.Seq[+A] i mutable.Seq[A].

###### funcionals purs a les seqüències

* Operadors i mètodes funcionals purs (sense efectes col·laterals) de les seqüències (immutables o mudables)
       retornen nova seqüència

###### mutadors a les seqüències

* Operadors mutadors de les seqüències mudables (ListBuffer[A] i MutableList[A])

###### als Buffer

Buffer: estructura mudable de magatzematge temporal incrementable que permet eliminacions.
Per al tipus mutable.Buffer[A].
* Mètodes mutadors als Buffers, addicionals als esmentats prèviament per a les seqüències

###### a les seqüències d'accés aleatori, anomenades indexades

per a seqüències d'accés aleatori dels tipus immutable.IndexedSeq[+A] i mutable.IndexedSeq[A]
* Mètodes funcionals a les seq. indexades IndexedSeq (mudables o immutables)
updated (mode verbal participi) és la versió funcional del mutador update (verb en mode imperatiu), descrites tot seguit:
* Mètodes mutadors a les seq. indexades mudables mutable.IndexedSeq

##### a les cues

per a les cues dels tipus immutable.Queue[+A] i mutable.Queue[A].

###### funcionals purs a les cues

* Operadors i mètodes funcionals purs (sense efectes col·laterals) de les cues (immutables o mudables)
       retornen nova cua.
* Operadors i mètodes funcionals purs (sense efectes col·laterals) només de les cues immutables.

###### mutadors a les cues

* Operadors mutadors de les cues mudables (mutable.Queue[A])

###### cues amb prioritat

Cues amb prioritat definida per un ordre implícit o bé explícit. mutable.PriorityQueue[A]
Els elements s'encuen davant d'aquells que són menors en l'ordre.
Integral[T] especifica un anell íntegre que implementa la divisió euclidiana, habitualment enters de qualsevol precisió.
* Operadors mutadors de les mudables "cues amb prioritat" (mutable.PriorityQueue[A])
També es pot definir l'element com a parell (prioritat, valor) definint l'ordre per comparació del primer de la tupla. Vegeu exemple.

##### als conjunts

per a conjunts del tipus immutable.Set[A] i mutable.Set[A].

###### funcionals purs als conjunts

* Operadors funcionals purs (sense efectes col·laterals) dels conjunts (Set) (immutables o mudables)
       retornen nou conjunt

###### mutadors als conjunts

* Operadors mutadors dels conjunts mudables

##### als diccionaris

per a diccionaris (taules associatives) amb tipus immutable.Map[A, +B] i mutable.Map[A, B].
       associació és una denominació de la correspondència (clau, valor)

###### funcionals purs als diccionaris

* Operadors funcionals purs (sense efectes col·laterals) dels diccionaris (Map) (immutables o mudables)
       retornen nou diccionari

###### mutadors als diccionaris

* Operadors mutadors dels diccionaris mudables

### Cadenes de text, Plantilles i Expressions regulars
#### String com a seqüència

El tipus String és augmentat implícitament a StringOps permetent aplicar-hi la interfície IndexedSeqLike (tractant String com una seq. d'accés aleatori). A més a més, incorpora els mètodes següents:

#### String especial per a multi-línia, i expressions regulars

També anomenat "document tot seguit" (ang:heredoc), amb cometes triples. La barra '\' invertida no s'hi interpreta com a caràcter d'escapament, permetent escriure-hi expressions regulars que no les han de doblar.

#### Plantilles

Plantilles amb interpolació, identificades per un prefix de plantilla.

#### Expressions regulars

* El tipus Regex.
A l'avaluador d'expressions:

## Biblioteques rellevants
### scala-arm

    control d'excepcions en la gestió de recursos amb alliberament automàtic en acabar. Evita, en cas d'adquisició de múltiples recursos, la implantació de construccions try-finally una dins l'altra.

### scalaz

    biblioteca que incorpora TADs del llenguatge Haskell (Monoides, Functors, Functors aplicatius, Mònades, Fletxes, ...)

### slick

    aporta col·leccions específiques per a l'accés a BDD relacionals generant SQL a partir de mètodes funcionals.

## Entorns de desenvolupament

* La manera més vistosa és descarregar l'entorn web de desenvolupament Activator de lightbend.com (abans TypeSafe.com).
* Per treballar a consola de comandes, cal descarregar el gestor de projectes SBT que per cada projecte descarregarà si no la té, la versió de Scala especificada pel fitxer de projecte (build.sbt). És convenient seguir l'estructura de directoris especificada per l'SBT.
* Una altra manera de treballar amb Scala és descarregant d'aquí l'endollable per a Eclipse (o altres entorns de desenvolupament Java) que ja incorpora el compilador i les biblioteques de les quals, clicant, se'n pot examinar el codi font.

### Scala a Eclipse

A Eclipse un cop incorporat l'endollable al menú Help->Install new software podrem crear un "Projecte Scala" que incorporarà automàticament les biblioteques de Scala al projecte si ho fem amb el menú de context de la barra lateral esquerre a l'opció "New -> Project -> Scala Wizards -> Scala Project" del menú de context de la barra lateral de projectes.
Scala segueix la mateixa estructura de mòduls (package) que el Java. Tanmateix podem posar diversos objects, classes i traits al mateix fitxer de codi font.
És habitual crear primer sobre el directori src, abreviació de source (codi font), un Package amb nom on crear els fonts, si volem facilitar l'estructuració modular o la inter-operabilitat amb paquets d'altres projectes.
Després podrem triar, al menú de context del package, els assistents (ang:wizards) de generació d'esquelets Scala Application, Scala Object, Scala Class o Scala Trait
Execució: per cada projecte cal crear una configuració d'engegada que podrem desar, especificant projecte, nom de l'objecte que conté el mètode main i possibles paràmetres de l'aplicació. Clicant el menú de context del projecte, opcions "RunAs -> Run configurations -> especificar la configuració o seleccionar-la -> botó Run"

## Exemples
### Lector amb analitzador gramatical

Basat en la classe JavaTokenParsers per aprofitar la decodificació de literals String.
La classe interna Parser adequa els operadors ((~>) seqüència, (|) alternativa, postfix (*) zero o més repeticions, postfix (+) una o més, postfix (?) zero o una) als combinadors de gramàtica regular específics de la classe, i també els que permeten l'extracció (^^) o bé l'especificació de resultat (^^^).

### Cues amb prioritat sobre parells (prioritat, valor)

Cal especificar explícitament l'ordenació sobre el primer del parell.

## Referències

* ↑ Scala - descàrregues(anglès)
* 1 2 Endollables Scala a diversos entorns de desenv. (anglès)
* 1 2 trait Application Arxivat 2014-09-25 a Wayback Machine. obsolet a 2.9, ang:deprecated, eliminat a 2.11
* ↑ trait App
* 1 2 Scala - Opcions d'execució(anglès)
* 1 2 scala-sbt.org(anglès)
* ↑ SBT - .sbt build definition(anglès)
* ↑ SBT - Esquema de directoris(anglès)
* ↑ Scala Language Specification(anglès)
* ↑ Tipus unificats(anglès)
* ↑ ScalaObject ha quedat obsolet (ang:deprecated) Arxivat 2014-10-05 a Wayback Machine.(anglès)
* 1 2 scala.Nothing Arxivat 2014-05-31 a Wayback Machine.(anglès)
* ↑ API - Symbol(anglès)
* 1 2 Equality of objects
* ↑ scala.AnyRef(anglès)
* ↑ scala.Any(anglès)
* ↑ scala.collection.GenIterable(anglès)
* ↑ AnyRef.==(anglès)
* ↑ scala.math.Numeric(anglès)
* ↑ scala.math.Integral(anglès)
* ↑ scala.math.Fractional(anglès)
* ↑ Cota superior en els tipus(anglès)
* ↑ Cota inferior en els tipus(anglès)
* 1 2 Scala docum. - Variances(anglès)
* 1 2 3 Scala tour - Lower type bounds(anglès)
* ↑ Objectes extractors(anglès)
* ↑ Introduction to Monads in Scala(anglès)
* ↑ Dotty (versió futurista de Scala) vegeu "Trait parameters"(anglès)
* ↑ Explicitly Typed Self References(anglès)
* ↑ "Scala Component Abstractions" (anglès) Vegeu apartat 2.3 Selftype Annotations
* ↑ scala.Function1(anglès)
* ↑ scala.Function2(anglès)
* ↑ "Pattern Matching Anonymous Functions"(anglès)
* ↑ El tret PartialFunction(anglès)
* ↑ scala.util.control.Exception(anglès)
* ↑ Java try-with-resources(anglès)
* ↑ Loan pattern(anglès)
* ↑ java.io.Closeable(anglès)
* 1 2 Scala-ARM(anglès)
* ↑ Assercions Arxivat 2011-12-05 a Wayback Machine.(anglès)
* ↑ Adding ??? to Predef?(anglès)
* ↑ Is requires keyword is obsolete in Scala 2.8 (or removed)?
* ↑ Scala Tour - XML(anglès)
* ↑ A tour of Scala: Views
* ↑ Pimp my library(anglès)
* ↑ The "quick pimp" pattern Arxivat 2014-11-20 a Wayback Machine.(anglès)
* ↑ Mètodes amb aritat 0
* ↑ Views(anglès)
* ↑ TraversableViewLike, que conté el mètode force.(anglès)
* ↑ scala.collection.Iterator(anglès)
* ↑ scala.collection.immutable.Stream(anglès)
* ↑ La API de Scala (anglès)
* ↑ Manuals del llenguatge(anglès)
* ↑ Objecte Predef(anglès) tipus i funcions predefinits.
* ↑ Hayoo Arxivat 2010-03-22 a Wayback Machine.(anglès)
* ↑ Hoogle(anglès)
* ↑ Scalex - Hoogle-like documentation search engine for scala library(anglès)
* ↑ A new API search engine for Scala: scala-search.org(anglès)
* ↑ Scala Akka(anglès)
* ↑ ScalaSTM(anglès)
* ↑ Scala - Akka STM(anglès)
* ↑ Col·leccions, vista general(anglès)
* ↑ Scala parallel collections(anglès)
* ↑ El tret ParIterable(anglès)
* ↑ parallel.Splitter(anglès)
* ↑ Scala concurrent package(anglès)
* ↑ paquet scala.collection - apartat "Creating collections"(anglès)
* ↑ scala.collection.SeqLike(anglès)
* ↑ scala.collection.TraversableView(anglès)
* ↑ scala.collection.TraversableOnce Arxivat 2017-02-08 a Wayback Machine.(anglès)
* ↑ Scala.math.Numeric
* ↑ la interfície math.Ordering
* ↑ scala.collection.TraversableLike
* ↑ scala.collection.generic.CanBuildFrom(anglès)
* ↑ scala.collection.IterableLike
* ↑ scala.collection.mutable.Buffer(anglès)
* ↑ el tret Integral[T]
* ↑ scala.collection.Set Arxivat 2014-05-31 a Wayback Machine.(anglès)
* ↑ scala.collection.Map(anglès)
* ↑ API collection.immutable.StringOps Arxivat 2018-02-12 a Wayback Machine.(anglès)
* ↑ API collection.IndexedSeqLike Arxivat 2018-01-02 a Wayback Machine.(anglès)
* ↑ String interpolation(anglès)
* ↑ scala.util.matching.Regex(anglès)
* ↑ Scalaz(anglès)
* ↑ Learning Scalaz(anglès)
* ↑ Biblioteca slick de Typesafe(anglès)
* ↑ Activator de TypeSafe(anglès)
* ↑ Eclipse (Entorn de desenvolupament)(anglès)
* ↑ API de la classe JavaTokenParsers(anglès)
* ↑ API de la classe interna Parsers.Parser(anglès)

## Enllaços externs

* Lloc web d'Scala (anglès)