Scala (llenguatge de programació)

Scala

Tipus	llenguatge de programació orientat a objectes, llenguatge de programació funcional, llenguatge de programació multiparadigma, JVM language (en) i llenguatge de programació
Data de creació	20 gener 2004
Disseny	Martin Odersky
Desenvolupador	Martin Odersky i Escola Politècnica Federal de Lausana
Paradigma de programació	computació concurrent, programació funcional, llenguatge imperatiu i programació orientada a objectes
Darrera versió estable	3.5.0 ()
Llenguatge de programació	Scala
Influenciat per	ML, Java, Erlang, Haskell, Smalltalk, ML Estàndard, OCaml, Common Lisp, Llenguatge de programació Eiffel, Oz, Pizza i Scheme
Extensió dels fitxers	scala i sc
Codi font	Codi font
Llicència	llicència BSD i Llicència Apache, versió 2.0
Etiqueta d'Stack Exchange	Etiqueta
Pàgina web	scala-lang.org

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

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

Per començar:

Al Linux el podeu instal·lar pels paquets de la distribució. Altrament el compilador es pot descarregar d'aquí^[1] o com endollable en un entorn integrat de desenvolupament aquí^[2]

El programa Hola món en Scala:

 // fitxer src/test/hola-mon.scala
 package test

 object Principal {
 def main(args: Array[String]) = Console.println("Hola món!")
 }

alternativa derivant l'objecte Application^[3] (obsolet des de 2.9, ang:deprecated, eliminat a 2.11) es recomana fer servir el mòdul App

 // fitxer src/test/hola-mon.scala
 package test

 object Principal extends Application { // Application defineix main
 // la inicialització del mòdul executa les expressions del cos.
 Console.println("Hola món!") 
 }

El mòdul App afegeix a Application la propietat args que permet accedir als arguments.^[4]

 // fitxer src/test/hola-mon.scala
 package test

 object Principal extends App { 

 Console.println ("Hola món!, els arguments són:" ++ args.mkString (", "))

 }

• Compilació i execució a consola de comandes:^[5]

mkdir classes # subdirectori per al codi objecte

# compilació (-cp és classpath, -d és directori per a la sortida) 
scalac -cp classes -d classes src/test/hola-mon.scala

# execució
scala -cp classes test.Principal # execució pel nom de l'objecte que conté el mètode ''main''

Hola món!

Aquesta manera de treballar directament amb el compilador ha quedat una mica antiquada. Si ho fem a través del gestor de projectes SBT,^[6] aquest ens descarregarà automàticament la versió del compilador i de les dependències del projecte, esmentades al fitxer de projecte.^[7]

Caldrà però seguir l'esquema de directoris especificat per l'SBT.^[8]

Al Linux el trobarem al gestor de paquets o bé el podem descarregar d'origen^[6] si volem la darrera versió.

scala

scala> println("Hola món")
Hola món

scala>

Amb el gestor de projectes SBT podem engegar l'avaluador REPL amb la comanda següent:

// fitxer de projecte build.sbt
lazy val root = (project in file(".")).
 settings(
 name := "hola_món",
 version := "1.0",
 scalaVersion := "2.11.7"
 )

sbt consoleQuick # engega REPL (Read-Eval-Print Loop) sense carregar les classes del directori de treball i subdirectoris
sbt console # engega REPL carregant les classes del directori de treball i subdirectoris

scala>

• Avaluació d'un mòdul Application (conté mètode main) (obsolet, ang:deprecated)^[3]

scala> :reset // reinicialitza l\'avaluador
scala> object Main extends Application { // per accedir als arguments cal redefinir el mètode ''main''
 | println("Hola món")
 | } 
scala> Main // avaluació del mòdul Application, executa les instruccions de l'objecte Main

• Avaluació d'un mòdul App (versió moderna de Application, incorpora membre args).

scala> :reset // reinicialitza l\'avaluador
scala> object Main extends App { // arguments visibles com a ''args'', membre de la classe
 | for (arg <- args) {
 | println(arg)
 |}}
scala> Main.main(Array("a","b","c")) // avaluació del mòdul App, executa les instruccions de l'objecte Main

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.^[9]

Vegeu Tipus unificats (amb gràfic) a la ref.^[10]

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)^[11]

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:^[12]

• É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.^[12]

Symbol

literals: identificadors precedits per l'apòstrof.^[13]

scala> val saluda = 'hola
saluda: Symbol = 'hola

scala> saluda match { // salt de carro després de '{' o bé '(' activa el 
 // mode multi-línia amb apuntador '|'
 | case 'hola => println("Benvingut!") 
 | case 'adéu => println("A reveure!") } // '}' al mateix nivell, tanca el mode multi-línia
Benvingut!

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)

scala> Option(5 :java.lang.Integer)
res1: Option[Integer] = Some(5)

scala> Option(null :java.lang.Integer)
res2: Option[Integer] = None

Llista

El tipus List[T]

// llista homogènia
scala> List(1,7,5)
res10: List[Int] = List(1, 7, 5)

// Conversió implícita de tipus (si hi ha una conversió implícita visible)
scala> List(1, 'a', 3.5)
res11: List[Double] = List(1.0, 97.0, 3.5)

// llista especificant un tipus base (més general)
scala> List[Any](1, 'a', 3.5)
res13: List[Any] = List(1, a, 3.5)

// llista buida de tipus sense especificar
scala> List()
res14: List[Nothing] = List()

// Nil especialitza la llista buida
scala> Nil
res16: scala.collection.immutable.Nil.type = List()

scala> Nil : List[Int]
res17: List[Int] = List()

Tuples (Tuple2 a Tuple22)

scala> val a = Tuple3(1, 'a', 3.5)
a: (Int, Char, Double) = (1,a,3.5)

scala> a._1
res0: Int = 1

scala> a._2
res1: Char = a

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

package test ;

object Main extends App {

 val llista: List[Any] = List(true, 'c', "abc"
 , 8:Byte, 270:Short, 300 /* Int */, 200000000000L /* Long */
 , 2.5F /* Float */, 3.12345678 /* Double */
 ) ;
 for (elem <- llista) {
 elem match {
 case 2 | 3 => print("dos o tres") ;
 case w: AnyVal => w match { // tipus primitius que es passen per valor
 case v :Char => printf("%c u\\%04x", v, v.toInt); // caràcter i hexadecimal
 case v :Byte => printf("és un byte: %d", v) ;
 case v :Short => printf("és un short: %d", v) ;
 case v :Int => printf("és un int: %d 0%o x%08x", v, v, v); // decimal, octal i hexad.
 case v :Long => printf("%d", v) ;
 case v :Float => printf("%.2f", v) ;
 case v :Double => printf("%.8f", v) ;
 case v => print(v)
 }
 case w: AnyRef => w match { // tipus que es passen per referència
 case v :String => printf("%s", v) ;
 case v => print(v.toString) ;
 } 
 }
 }
 println("") 
 }
}

dona

true
c u\0063
abc
és un byte: 8
és un short: 270
és un int: 300 0454 x0000012c
200000000000
2,50
3,12345678

En la comparació d'objectes, l'operador de Scala (==) no correspon en Java al (==) sinó al mètode equals. ^[14]

A Scala la igualtat d'objectes que es passen per referència AnyRef^[18] equival a

x == y <=> if (x eq null) (y eq null) else x.equals(y)

trait Animal {
 val nom: String
 val crit: String
}
class Gat extends Animal {
 val nom = "Gat"
 val crit = "miola"
}
class Gos extends Animal {
 val nom = "Gos"
 val crit = "borda"
}

function crida(animal: Animal) {
 println (s"El ${animal.nom} ${animal.crit}")
}

Les funcions es poden parametritzar per Tipus

 def nom_funció[VariableDeTipus](param1: VariableDeTipus, ..) = ...

exemple:

object Main extends App {
 def imprimeix[T](dada: T) = 
 dada match {
 case v: String => println(v) ;
 case v => println (v.toString) ;
 }
 imprimeix[Int](5) ;
 imprimeix[String]("abc") ;
 imprimeix(2); // si no s'explicita el tipus, es dedueix dels paràmetres actuals.
 imprimeix("def") ;
}

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.

import scala.math.Numeric._

function producte[A: Numeric](x: A, y: A):A = {
 val instància = implicitly[Numeric[A]] // instància de Numeric per al tipus del paràmetre emprat a la crida
 instància.times(x, y)
}

• scala.math.Numeric és la signatura d'un anell unitari ordenat (Numeric especialitza (extends) Ordering).^[19]
• scala.math.Integral és la signatura d'un anell unitari euclidià ordenat íntegre (Integral especialitza (extends) Numeric).^[20]
• scala.math.Fractional és la signatura d'un cos ordenat (Fractional especialitza (extends) Numeric).^[21]

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

abstract class SemiGrup[A] {
 def assoc(x: A, y: A): A
 }

abstract class Monoid[A] extends SemiGrup[A] {
 def neutre: A
 }

object Monoides {

 // Monoides per a la suma i el producte

 implicit object IntMonoidSuma extends Monoid[Int] {
 def assoc(x: Int, y: Int): Int = x + y
 def neutre: Int = 0
 }

 implicit object IntMonoidProducte extends Monoid[Int] {
 def assoc(x: Int, y: Int): Int = x * y
 def neutre: Int = 1
 }
}

object Test extends App {
 import Monoides._ // per fer servir les instàncies implícites, han d'estar visibles
 import scala.collection.Iterable

 def plegaLlista[A](xs: Iterable[A])(implicit m: Monoid[A]): A = xs.fold (m.neutre) (m.assoc)

 println(plegaLlista(List(1, 2, 3)) (IntMonoidSuma))
 println(plegaLlista(List(1, 2, 3)) (IntMonoidProducte))
}

type LaMevaFun[A,B,C] = B => A => Pair[B, C]

• 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.^[22]

 type Tipus <: TCotaSuperior // 'Tipus' ha d'ésser subtipus (més especialitzat) de 'TCotaSuperior'

en el següent exemple Tipus ha d'ésser superclasse de TCotaInferior.^[23]

 type Tipus >: TCotaInferior // 'Tipus' ha d'ésser supertipus (més general) de 'TCotaInferior'

Vegeu ref.^[24][25]

• 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

// el prefix + en un paràmetre de tipus indica covariança
// el prefix - en un paràmetre de tipus indica contravariança

// del mòdul Predef que conté els elements predefinits del llenguatge
type Function[-A, +B] = (A) ⇒ B

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).^[24][25] 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.^[25] 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.

class ListNode[+T](h: T, t: ListNode[T]) {
 def head: T = h 
 def tail: ListNode[T] = t

 // per poder utilitzar el tipus T en l'argument i mantenir la covariança de la classe respecte a T
 // l'argument (posició contravariant) ha d'admetre qualsevol supertipus U >: T
 def prepend[U >: T](elem: U): ListNode[U] = 
 ListNode(elem, this) 
}

Definides les classes Tuple2, Tuple3, .., Tuple22.

object Main extends App {

 val parell = new Tuple2(10, "abc") ; // new amb el nom de la classe

 val Tuple2(primer, segon) = parell; // encaix de la tupla

 println(parell._1) ; // primer
 println(parell._2) ; // segon, ...
}

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.

// ''App'' és l'object d'engegada que conté el mètode ''main''

object ProvaFiltratge extends App {

 def filtrar(xs: List[Int], llindar: Int) = {

 def processa(ys: List[Int]): List[Int] = // funció a l'interior d'una altra funció
 if (ys.isEmpty) ys
 else if (ys.head >= llindar) ys.head :: processa(ys.tail)
 else processa(ys.tail)

 processa(xs)
 }
 println(filtrar(List(1, 9, 2, 8, 3, 7, 4), 5))
}

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.

import java.lang.{Color}
val vermell = new Color(0xFF, 0, 0); // constructor de la ''classe''
val componentRoigDelBlanc = Color.getRed(Color.WHITE); // membres estàtics de l{{'}}''Object''

els object (mòduls amb els membres estàtics) de les col·leccions incorporen generadors

object List {
 def apply[T] (elements: T*) // genera una llista amb els elements proporcionats com a paràmetres
 // ''apply'' és el nom de funció per omissió (es pot ometre)
 // així List (1, 2, 3) equival a List.apply(1, 2, 3)

 def empty[T] () // generador de col·lecció buida
}

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.

 class Classe(val p1: Tipus, p2: Tipus2 = vPerDefecte, ...) // amb val, p1 passa a ser membre de la classe

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.^[26]

 // el següent codi genera un objecte extractor
 object Doble {
 // generador
 def apply (x: Int): Int = x * 2 

 // inversa per als encaixos de patrons, retorna en un Option l'èxit o fracàs de l'encaix
 def unapply (z: Int): Option[Int] = if (z % 2 == 0) Some (z/2) else None 
 }

 object ProvaDoble extends App {
 val x = Doble (21) // aplica 'apply' (nom de funció per omissió a les expressions)
 x match { case Doble (n) => Console.println(n) } // aplica 'unapply' (nom de funció per omissió als patrons)
 }

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.

abstract class Arbre[T]
// ''val'' al paràmetre el declara membre de la classe, estalvia redeclaracions
case class Fulla[T](val dada: T) extends Arbre[T]
case class Branca[T](val dada: T, val esquerra: Arbre[T], val dreta: Arbre[T]) extends Arbre[T]

object Main extends App { 

 def imprimeixArbre[T](arbre: Arbre[T]):Unit = 
 arbre match {
 case Fulla(d) => println ("fulla: " ++ d.toString)
 case Branca(d, esq, dreta) => { imprimeixArbre(esq) ;
 println("branca: " ++ d.toString) ;
 imprimeixArbre(dreta) ;
 }
 }

 // els constructors de case classes no necessiten ''new'', de fet no són constructors sinó generadors membres de l'objecte extractor
 // l'expressió {Fulla(1)} equival a {Fulla.apply(1)} // ''apply'' és el nom de funció per omissió.

 val arbre1 = Fulla[Int](1); 
 // si s'omet el paràmetre de tipus ''[T]'', es pren el tipus del paràmetre actual.
 val arbre2 = Branca(2, arbre1, arbre1) ;
 imprimeixArbre(arbre2) ;
}

Equivalència en ML Estàndard:

datatype 't Arbre = Fulla of 't | Branca of ('t * 't Arbre * 't Arbre)

Equivalència en Haskell:

data Arbre t = Fulla t | Branca t (Arbre t) (Arbre t)

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:

sealed abstract class Arbre[T] // 'sealed': classe segellada, per al control d'exhaustivitat als encaixos
case class Fulla[T](val dada: T) extends Arbre[T]
case class Branca[T](val dada: T, val esquerra: Arbre[T], val dreta: Arbre[T]) extends Arbre[T]

object Main extends App { 

 def imprimeixArbre[T](arbre: Arbre[T]):Unit = 
 arbre match {
 // case Fulla(d) => println ("fulla: " ++ d.toString) // comentat expressament per veure l'avís del compilador
 case Branca(d, esq, dreta) => { imprimeixArbre(esq) ;
 println("branca: " ++ d.toString) ;
 imprimeixArbre(dreta) ;
 }
...

sbt compile
[info] Compiling 1 Scala source to ...
[warn] /home/gabi64/lleng/scala/sealed/Main.scala:9: match may not be exhaustive.
[warn] It would fail on the following input: Fulla(_)
[warn] arbre match {
[warn] ^
[warn] one warning found
[success] Total time: 10 s, completed 07/06/2016 15:35:50

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

(1 until 5) // interval obert (exclou límit superior)
(1 to 5) // interval tancat (inclusiu)
(1 to 5 by 2) // interval amb increment

object Main extends App {
 val llista = (1 to 3).toList ; // List(1,2,3)
 def descriuLlista[T](llista: List[T]) = 
 llista match {
	 case Nil => println ("llista buida") ;

	 case ll @ (_ :: _) => // as-pattern (variable @ patró): unifica variable i terme encaixat
 println ("llista no buida: " + ll.toString) ;
 }
 descriuLlista(llista)
}

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.

 // retorna els dobles dels parells de l'interval
 // en una col·lecció del tipus del primer generador

 val iterador = for (i <- Iterator.range(des_de, topall_exclòs) 
 if i % 2 == 0
 ) yield 2 * i // el tipus resultant és Iterator[Int]
 println (iterador.toList)

 // equivalent amb rangs: (des_de to topall_inclòs)
 val iterador = (1 to 12).iterator.filter(_ % 2 == 0).map(_ * 2) 
 println (iterador.toList)

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.

scala> val opt3 = Some(3)
scala> val opt4 = Some(4)

scala> for { x <- opt3; 
 y <- opt4 } yield (x+y)
res4: Option[Int] = Some(7)

// desplegament monàdic equivalent

scala> opt3 flatMap { x => opt4 map { y => x + y}}
res5: Option[Int] = Some(7)

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

-- ús de l'encadenament monàdic per al tipus Try[T] (variants Success[T] i Failure[Throwable])
-- Try encapsula, a l'exemple, l'avaluació de l'operació de lectura, retornant Failure(err) en cas d'excepció
-- Failure(..) és l'element absorbent per l'esquerra de ''flatMap'' per al tipus Try, fent que l'encadenament no progressi.

val result = for (dividend <- Try(Console.readLine("entreu dividend: ") ;
 divisor <- Try(Console.readLine("entreu divisor: ")
 ) yield dividend / divisor
result match {
 case Success(v) => println ("correcte: " + v.toString)
 case Failure(err) => println ("pifiada: " + err.getMessage)
 }

Vegeu presentació "Introduction to Monads in Scala".^[27]

El tipus de les declaracions es pot ometre si es dedueix de la seva inicialització de manera inequívoca, altrament el compilador avisarà.

val identificador :Tipus = expressió // amb val: assigna el valor de l'expressió com a constant
var identificador :Tipus = expressió // amb var: variable mudable
def identificador :Tipus = expressió // amb def: es recalcula a cada invocació

// Les inicialitzacions de variables amb el comodí '_' 
// assignen l'element zero del tipus si és subtipus de 'AnyVal' (pas per valor) 
// o bé 'null' si és subtipus de 'AnyRef' (pas per referència)

scala> var v : Boolean = _
v: Boolean = false

scala> var v : Int = _
v: Int = 0

scala> var v : String = _
v: String = null

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

Els operadors són mètodes definits amb símbols.

class Q {
 def ##(that:Q) = this != that
 }

La precedència la determina el primer caràcter del símbol. (Vegeu apartat 'Infix operators' al manual de ref. del llenguatge).

(all letters)
|
^
&
< >
= !
:
+ -
* / %
(all other special characters)

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:

// si 'x1' i 'x2' són elements i 'xs' és una col·lecció
x1 +: x2 +: xs ≡ x1 +: (x2 +: xs) // (+:) ha de ser mètode del tipus de l'operand de la dreta: la col·lecció

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.

// (++:) concatenació amb associativitat per la dreta (pels ':' final)
// (++:) és membre del tret "Traversable", que haurà d'implementar l'operand de la dreta

// StringBuilder és una ''String'' mudable que implementa ''Growable'' (que pot créixer).
// seq.mkString converteix una seqüència en una String

val strBldr = "abc" ++: "def" ++: new StringBuilder("ghi")

val novaStr = strBldr.mkString

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.^[28]

import java.awt.{Color} ;

trait Acoloriment {
	var color:Color; 
	def pinta(nouColor: Color): Unit = { color = nouColor}
	def imprimeixColor: Unit = { print("color: "); println(color) } 
}

trait Cloneable extends java.lang.Cloneable {
 override def clone(): Cloneable = { super.clone(); this }
}

trait Resetable {
 def reset: Unit
}

def cloneAndReset(obj: Cloneable with Resetable): Cloneable = {
 val cloned = obj.clone()
 obj.reset
 cloned
}

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

import java.awt.{Color} ;

class Punt(xInicial:Int) {
	var x: Double = xInicial.toDouble ;
	def desplaça(dx: Double): Unit = { x = x + dx}
	def imprimeixPosició: Unit = { print("posició: "); println(x) } 
}

// els trets (ang: trait) són com una classe abstracta
trait Acoloriment {
	var color: Color; 
	def pinta(nouColor: Color): Unit = { color = nouColor}
	def imprimeixColor: Unit = { print("color: "); println(color) } 
}

// incorpora el tret Acoloriment donant valor als membres abstractes
class PuntAcolorit(xInicial:Int, colorInicial: Color) extends Punt(xInicial) with Acoloriment {

	var color = colorInicial ;

	def desplaçaIPinta(dx: Double, nouColor: Color) = { 

	 super[Punt].desplaça(dx) ;
	 super[Acoloriment].pinta(nouColor) ;
	}
}

object Main extends App {
	
 val punt = new PuntAcolorit(0, Color.WHITE) { // extensió en instanciar
 // només aquesta instància incorpora l'extensió
	 
	 def desplaçaRàpid(dx: Double) = { 
	 	 x = x + 10.0 * dx
	 }
 }
 punt.desplaçaIPinta(2, Color.BLUE) ;
 punt.desplaçaRàpid(3.5)
 punt.imprimeixPosició ;
 punt.imprimeixColor ;
}

dona el resultat:

posició: 37.0
color: java.awt.Color[r=0,g=0,b=255]

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.^[29] É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.^[30]

abstract class Graf {
 type Node <: NodeBase; // volem que els nodes implementin NodeBase

 class Arc(val origen: Node, val destí: Node) {}

 class NodeBase {
 def connectaAmb(n: Node): Arc =
 new Arc(this, n); // il·legal !! 'this' no és de tipus Node
 }
}

Solució amb self-types

abstract class Graf {
 type Node <: NodeBase; // volem que els nodes implementin NodeBase

 class Arc(val origen: Node, val destí: Node) {}

 abstract class NodeBase {
 self: Node => // requeriment que el tipus propi sigui subtipus de Node en obtenir-ne una classe concreta
 def connectaAmb(n: Node): Arc =
 new Arc(self, n); // ara si que passa la compilació
 }
}

// classe concreta de Graf que incorpora la classe concreta Node
class GrafEtiquetat extends Graf {
 class Node(etiq: String) extends NodeBase {
 def getEtiqueta: String = etiq;
 }
}

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

def fun(param: Tipus) = if (param.isInstanceOf[Subtipus]) { 
 val subtipParam = param.asInstanceOf[Subtipus]; 
 ... }
 else ...

object Main extends App {

 object DiaSetm extends Enumeration {
 type DiaSetm = Value
 val Dl, Dt, Dc, Dj, Dv, Ds, Dg = Value
 }
 import DiaSetm._

 def ésDiaFeiner(d: DiaSetm) = ! (d == Ds || d == Dg)

 println (DiaSetm.values filter (ésDiaFeiner) mkString (", "))
 }

$ sbt run
Java HotSpot(TM) 64-Bit Server VM warning: ignoring option MaxPermSize=256M; support was removed in 8.0
[info] Set current project to enums (in build file:/home/gabi64/lleng/scala/enums/)
[info] Compiling 1 Scala source to /home/gabi64/lleng/scala/enums/target/scala-2.10/classes...
[info] Running Main 
Dl, Dt, Dc, Dj, Dv
[success]

Admetre tipus més especialitzats que un tipus determinat.

trait Similar {
 def isSimilar(x: Any): Boolean
}

case class MyInt(x: Int) extends Similar {
 def isSimilar(m: Any): Boolean =
 m.isInstanceOf[MyInt] &&
 m.asInstanceOf[MyInt].x == x
}

object UpperBoundTest extends App {

 def findSimilar[T <: Similar](e: T, xs: List[T]): Boolean =
 if (xs.isEmpty) false
 else if (e.isSimilar(xs.head)) true
 else findSimilar[T](e, xs.tail)

 val list: List[MyInt] = List(MyInt(1), MyInt(2), MyInt(3))

 println(findSimilar[MyInt](MyInt(4), list))
 println(findSimilar[MyInt](MyInt(2), list))
}

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.

def imprimeix(args: String*) = {
 for(arg <- args){
 println(arg);
 }
}
imprimeix("abc", "def", "ghi")

exemple:

(x: Int, y:Int) => x + y // el tipus del resultat és deduït per inferència en aquest cas

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

object Main extends App {
 val llista = List(1,2,3,4); // pels literals infereix tipus List[Int]

 // aplica la funció a un acumulador i cada valor de la llista
 // els tipus dels paràmetres els dedueix de l'aplicació parcial (funció ometent paràmetres) precedent.
 // tipus de llista.foldleft(0) : (Int * Int) => Int

 val result = llista.foldLeft(0) { (x,y) => x+y }; 

 Console.print("resultat: ") ;
 Console.println(result);
}

dona l'esperat

resultat: 10

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)

scala> :type List[Any](1, 2.5, "abc") .map (_.toString)
List[String]

scala> def floatMes3: (Float => Float) = (_ + 3) // cal la restricció de tipus
floatMes3: Float => Float

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

// Definint ''flip'' (intercanviar l'ordre d'arguments) per fer-lo servir més tard
scala> def flip[T1, T2, R](f : T1 => T2 => R) (x: T2) (y: T1) : R = f (y) (x)
flip: [T1, T2, R](f: T1 => (T2 => R))(x: T2)(y: T1)R

scala> def cons[A] (x: A) (xs: List[A]) = x :: xs
cons: [A](x: A)(xs: List[A])List[A]

scala> :type cons[Int] (5) _ // tipus aplicant només un paràmetre
List[Int] => List[Int]

scala> :type cons[Int] _ // tipus aplicant zero paràmetres
Int => (List[Int] => List[Int]) 

scala> flip (cons[Int] _) (List(2,3)) (1) // passant 'cons' a 'flip' (funció d'ordre superior)
res0: List[Int] = List(1, 2, 3)

La interfície Function1 de funcions d'un argument aporta mètodes per la composició de funcions.^[31]

La interfície Function2 de funcions de dos arguments aporta mètodes per obtenir versions currificades (.curried) i la inversa (.tupled).^[32]

Function3 a Function19 també definides.

package test

object Main extends App {

 // composició de les funcions d'un arg.

 def doble(x: Int) = x * 2
 def suma3(x: Int) = x + 3

 // f compose g == f. g
 // f andThen g == g. f

 // cal especificar '_' per obtenir l'aplicació parcial
 def doblaiSuma3 = (doble _).andThen(suma3 _) // composició d'esquerra a dreta
 def doblaiSuma3 = (suma3 _).compose(doble _) // composició amb estil matemàtic, resultat idèntic a l'anterior

 val prova = doblaiSuma3(5)

 // currificació i aplicabilitat als arg. en tupla

 def cons[A] (x: A, xs: List[A]) = x :: xs

 def f[T] = (cons[T] _) // cal especificar '_' per obtenir l'aplicació parcial

 val x1 = f (1, List(2,3)) 

 // currificació (amb 'curried'' la funció s'aplica als param. separats
 val x2 = f[Int].curried (1) (List(2,3)) // cal explicitar el paràmetre actual de tipus 
}

Amb funcions als paràmetres o al resultat.

// en aquest cas, funció que pren una funció d'argument i en retorna una altra

def sum(f: Int => Int): (Int, Int) => Int = {

 def sumF(a: Int, b: Int): Int = // suma f(x), x <- [a..b]
 if (a > b) 0 else f(a) + sumF(a + 1, b)

 &sumF
}

def sumaDobles = &sum(x => 2 * x)
def sumaQuadrats = &sum(x => x * x)

Vegeu "Pattern-matching anonymous functions".^[33]

def or : (Boolean, Boolean) => Boolean = 
 { case (true, _) => true; 
 case (false, x) => x
 }

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*/],^[34] amb mètodes molt interessants.

val pf: PartialFunction[A, B] = { case patró1 if condició => ...; 
 case patró2 => ... ;
 ... }

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.

pf.applyOrElse(x, funcPerDefecte) ≡ if(pf isDefinedAt x) pf(x) else funcPerDefecte(x)

El mètode orElse admet la composició amb una altra funció parcial, que s'avalua per als casos no definits de la primera.

scala> val dobleDeParell: PartialFunction[Int, Int] = {
 | case x if x % 2 == 0 => 2 * x
 | }
dobleDeParell: PartialFunction[Int,Int] = <function1>

scala> dobleDeParell.isDefinedAt(3)
res0: Boolean = false

scala> dobleDeParell.isDefinedAt(2)
res1: Boolean = true

scala> dobleDeParell.lift(3)
res2: Option[Int] = None

• 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:

// interfície GenTraversable
def collect[B](pf: PartialFunction[A, B]): Repr[B]

// interfície GenTraversableOnce
def collectFirst[B](pf: PartialFunction[A, B]): Option[B] // obté, si existeix, la primera de les imatges de mapejar amb una funció parcial

La clàusula try {..} catch (err:Throwable) {..} finally {..} possiblita la gestió d'excepcions i alliberament de recursos.

L'objecte Exception^[35] aporta diverses possibilitats addicionals.

La recent construcció a Java 7 try-with-resources^[36] 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),^[37] es proposa la següent construcció (Closeable^[38] és una interfície de Java)

def using[A, R <: Closeable](r : R)(f : R => A) : A = {
 var result : A = _
 try {
 result = f(r)
 } finally {
 try {r.close()} 
 catch {case e: IOException => ()}
 }
 result
 }

La biblioteca scala-arm^[39] 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.

import resource._

// dos recursos, còpia de input a output, amb alliberament automàtic

for(input <- managed(new java.io.FileInputStream("test.txt"); 
 output <- managed(new java.io.FileOutputStream("test2.txt")) {

 val buffer = new Array[Byte](512)
 def read(): Unit = input.read(buffer) match {
 case -1 => ()
 case n => output.write(buffer,0,n); read()
 }
 read()
}

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.

val res = for (dividend <- Try(Console.readLine("entreu dividend: ") ;
 divisor <- Try(Console.readLine("entreu divisor: ")
 ) yield dividend / divisor
res match {
 case Success(v) => println ("correcte: " + v.toString)
 case Failure(err) => println ("error de lectura (del readLine) " + err.getMessage)
 }

Precondicions, postcondicions i invariants

Vegeu Assercions^[40] i Opció de compilació -enableassertions^[5]

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").^[41]

def mètode : Tipus = ??? // mètode pendent d'implementar (per poder passar la compilació)

La clàusula require ha estat declarada obsoleta i retirada a la v2.8.^[42]

Es recomana fer servir la definició per patrons per especificar les precondicions.

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

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

// malament a posta, per fer petar la postcondició
scala> def incrementa(x: Int) = { x - 1 } ensuring (_ > x, "el resultat no és superior")
incr: (x: Int)Int

scala> incrementa (5)
java.lang.AssertionError: assertion failed: el resultat no és superior
 at scala.Predef$Ensuring$.ensuring$extension3(Predef.scala:256)
 at .incr(<console>:10)
 ... 43 elided

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

Admet notació de llenguatge de marques XML com a literal, amb interpolació d'expressions entre claus "{}". Vegeu^[43]

object Main extends App {
 val idioma = "ca" ;
 val títol = "El meu títol" ;
 val xmlTítol = <title> {títol} </title>; // entre claus '{' <expr> '}' interpolació d'expressions.
 val xmlCapçalera = <head> {xmlTítol} </head>;
 val xmlCos = <body> Aquesta pàgina duu per títol: {títol} </body> ;

 // substitució a l'atribut, hi afegeix les cometes.
 val xmlPàgina = <html lang={idioma}> {xmlCapçalera} {xmlCos} </html> ;

 // prefix
 val capsalXml ="<?xml version='1.0' encoding='UTF-8' ?>\n" ;
 val doctype = "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" " +
 " \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n" ;
 println(capsalXml + doctype + xmlPàgina) ;
}

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

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

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:

// del Predef
// char2int permet emprar valors de tipus Char en paràmetres Int

implicit def char2int (x: Char): Int

É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^[44]

trait Set[A <% Ordered[A]]... // consulteu la ref.

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]).

 abstract class SemiGrup[A] {
 def suma(x: A, y: A): A
 }

 abstract class Monoid[A] extends SemiGrup[A] {
 def zero: A
 }
 object ImplicitTest extends App {

 // mòdul instància de Monoid per al tipus String

 implicit object StringMonoid extends Monoid[String] {
 def suma(x: String, y: String): String = x concat y
 def zero: String = ""
 }

 // mòdul instància de Monoid per al tipus Int

 implicit object IntMonoid extends Monoid[Int] {
 def suma(x: Int, y: Int): Int = x + y
 def zero: Int = 0
 }

 // sumaLlista
 // el paràm. implícit selecciona instància segons el tipus del paràm. actual (a la crida) 
 // entre els ''implícit object''s visibles en l'àmbit.

 def sumaLlista[A](xs: List[A])(implicit m: Monoid[A]): A = 
 xs match {
 case Nil => m.zero
 case y :: ys => m.suma(y, sumaLlista(ys))
 }

 println(sumaLlista(List(1, 2, 3))) // obté l'objecte implícit segons el tipus del paràmetre.
 println(sumaLlista(List(1, 2, 3)) (IntMonoid)) // explicita l'implícit quan n'hi ha diversos (Monoide per a la suma, per al producte, ...) 
 println(sumaLlista(List("a", "b", "c")))
 }

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.

 def sumaLlista[A: Monoid](xs: List[A]): A = { 

 val m = implicitly[Monoid[A]] // obté una instància de Monoid per al tipus A 
 xs match {
 case Nil => m.zero
 case y :: ys => m.suma(y, sumaLlista(ys))
 }
 }

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

 def nomFunció [A:Ordered](params...) = ...

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

 def nomFunció [A](params...)(implicit m:Ordering[A]) = ...

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.^[45]

object Test extends App {

 object Augmentador {

 class ToMyInt(s:String) {
 def toMyInt: Int = java.lang.Integer.parseInt(s)
 }

 implicit def string2ToMyInt(s: String) = new ToMyInt(s)
 }

 import Augmentador._ // incorpora l'implícit a l'àmbit

 println ("12".toMyInt) 
}

• Augment ràpid (en escriure'l però més lent d'execució).^[46]

object Test extends App {

 implicit def string2ToMyInt(s: String) = new {

 def toMyInt: Int = java.lang.Integer.parseInt(s)
 }

 println ("12".toMyInt) 
}