Indice

  1. Prefazione
    1. Benvenuti a Programmare in Scala
    2. Convenzioni usate in questo libro
    3. Usare gli esempi di codice
      1. Ottenere gli esempi di codice
    4. Safari® Books Online
    5. Come contattarci
    6. Ringraziamenti
  2. Da zero a sessanta: una introduzione a Scala
    1. Perché Scala?
      1. Se siete programmatori Java…
      2. Se siete programmatori Ruby, Python, &c…
      3. Una introduzione a Scala
      4. Le seduzioni di Scala
    2. Installare Scala
    3. Per maggiori informazioni
    4. Un assaggio di Scala
    5. Un assaggio di concorrenza
    6. Riepilogo, e poi?
  3. Scrivere meno, fare di più
    1. In questo capitolo
    2. Punti e virgola
    3. Dichiarazioni di variabile
    4. Dichiarazioni di metodo
      1. Argomenti con nome e argomenti predefiniti per i metodi (Scala 2.8)
      2. Annidare le definizioni di metodo
    5. Inferire le informazioni di tipo
    6. Letterali
      1. Letterali interi
      2. Letterali in virgola mobile
      3. Letterali booleani
      4. Letterali carattere
      5. Letterali stringa
      6. Letterali simbolo
    7. Tuple
    8. Option, Some e None: evitare i valori nulli
    9. Organizzare il codice in file e spazi di nomi
    10. Importare i tipi e i loro membri
    11. Le importazioni sono relative
    12. Tipi astratti e tipi parametrici
    13. Parole riservate
    14. Riepilogo, e poi?
  4. Completare l’indispensabile
    1. Operatore? Operatore?
      1. Zucchero sintattico
    2. Metodi senza parentesi e punti
      1. Regole di precedenza
    3. Linguaggi domain-specific
    4. Le istruzioni if in Scala
    5. Le espressioni for in Scala
      1. Un semplice esempio
      2. Filtrare gli elementi
      3. Produrre gli elementi in uscita
      4. Ambito esteso
    6. Altri costrutti di ciclo
      1. I cicli while in Scala
      2. I cicli do/while in Scala
      3. Espressioni generatore
    7. Operatori condizionali
    8. Pattern matching
      1. Una semplice corrispondenza
      2. Usare variabili nelle corrispondenze
      3. Corrispondenze sul tipo
      4. Corrispondenze sulle sequenze
      5. Corrispondenze su tuple (e guardie)
      6. Corrispondenze sulle classi case
      7. Corrispondenze su espressioni regolari
      8. Legare variabili annidate nelle clausole case
      9. Usare le clausole try, catch e finally
      10. Considerazioni conclusive sul pattern matching
    9. Enumerazioni
    10. Riepilogo, e poi?
  5. Tratti
    1. Una introduzione ai tratti
      1. I tratti come mixin
    2. Tratti impilabili
    3. Costruire i tratti
      1. Classe o tratto?
    4. Riepilogo, e poi?
  6. Programmazione orientata agli oggetti in Scala: le basi
    1. I concetti di base per classi e oggetti
    2. Classi genitore
    3. I costruttori in Scala
      1. Invocare i costruttori della classe genitore
    4. Classi annidate
    5. Regole di visibilità
      1. Visibilità pubblica
      2. Visibilità protetta
      3. Visibilità privata
      4. Visibilità ristretta privata e protetta
      5. Considerazioni conclusive sulla visibilità
    6. Riepilogo, e poi?
  7. Programmazione orientata agli oggetti in Scala: elementi avanzati
    1. Ridefinire i membri di classi e tratti
      1. Tentare di ridefinire le dichiarazioni final
      2. Ridefinire i metodi astratti e concreti
      3. Ridefinire i campi astratti e concreti
      4. Ridefinire i campi astratti e concreti nei tratti
      5. Ridefinire i campi astratti e concreti nelle classi
      6. Ridefinire i tipi astratti
      7. Quando i metodi di accesso e i campi sono indistinguibili: il principio di accesso uniforme
    2. Oggetti associati
      1. Il metodo apply
      2. Il metodo unapply
      3. apply e unapply per le collezioni
      4. Gli oggetti associati e i metodi statici di Java
    3. Classi case
      1. Zucchero sintattico per le operazioni binarie
      2. Il metodo copy in Scala 2.8
      3. L’ereditarietà nelle classi case
    4. L’uguaglianza tra oggetti
      1. Il metodo equals
      2. I metodi == e !=
      3. I metodi ne ed eq
      4. L’uguaglianza tra array e il metodo sameElements
    5. Riepilogo, e poi?
  8. Il sistema a oggetti di Scala
    1. L’oggetto Predef
    2. Classi e oggetti: dove sono i membri statici?
      1. Oggetti package
    3. Gerarchie di classi sigillate
    4. La gerarchia di tipi di Scala
    5. Linearizzare la gerarchia di un oggetto
    6. Riepilogo, e poi?
  9. La programmazione funzionale in Scala
    1. Che cos’è la programmazione funzionale?
      1. Le funzioni in matematica
      2. Variabili che non sono tali
    2. La programmazione funzionale in Scala
      1. Letterali funzione e chiusure
      2. Purezza interna ed esterna
    3. Ricorsione
    4. La ricorsione in coda e la sua ottimizzazione
      1. Trampolino per le ricorsioni in coda
    5. Strutture dati funzionali
      1. Le liste nella programmazione funzionale
      2. Le mappe nella programmazione funzionale
      3. Gli insiemi nella programmazione funzionale
      4. Altre strutture dati nella programmazione funzionale
    6. Operazioni comuni sulle strutture dati funzionali
      1. Attraversamento
      2. Mappatura
      3. Filtraggio
      4. Ripiegamento e riduzione
      5. Option funzionali
    7. Pattern matching
    8. Funzioni parziali
    9. Currying
    10. Impliciti
      1. Conversioni implicite
    11. Parametri di funzione impliciti
      1. Considerazioni conclusive sugli impliciti
    12. Invocazione per nome o per valore
    13. Valori ritardati
    14. Riepilogo: le astrazioni per i componenti funzionali
  10. Programmazione concorrente robusta e scalabile con gli attori
    1. I problemi dello stato condiviso e sincronizzato
    2. Gli attori
      1. Gli attori in astratto
    3. Gli attori in Scala
      1. Inviare messaggi agli attori
      2. La mailbox
      3. Gli attori nel dettaglio
      4. Attori efficaci
    4. La concorrenza tradizionale in Scala: thread ed eventi
      1. Thread una tantum
      2. Usare java.util.concurrent
      3. Eventi
    5. Riepilogo, e poi?
  11. Lavorare con XML in Scala
    1. Leggere XML
      1. Esplorare XML
      2. Usare XML con i cicli e il pattern matching
    2. Scrivere XML
      1. Un esempio reale
    3. Riepilogo, e poi?
  12. Linguaggi domain-specific in Scala
    1. DSL interni
      1. Un DSL interno per il libro paga
      2. Notazione infissa per gli operatori
      3. Conversioni implicite e tipi definiti dall’utente
      4. Metodi apply
      5. Implementazione delle regole di pagamento come DSL
      6. DSL interni: considerazioni conclusive
    2. DSL esterni con la combinazione di riconoscitori
      1. Informazioni sulla combinazione di riconoscitori
      2. Un DSL esterno per il libro paga
      3. Una implementazione in Scala della grammatica di un DSL esterno
      4. Generare le buste paga con un DSL esterno
      5. DSL interni vs. esterni: considerazioni finali
    3. Riepilogo, e poi?
  13. Il sistema di tipi di Scala
    1. La riflessione sui tipi
    2. Capire i tipi parametrici
      1. Manifesti
      2. Metodi parametrici
    3. Varianza in caso di ereditarietà
      1. La varianza dei tipi mutabili
      2. Un confronto tra la varianza in Scala e in Java
      3. Note di implementazione
    4. Limiti sui tipi
      1. Limiti superiori sui tipi
      2. Limiti inferiori sui tipi
      3. Uno sguardo più attento alle liste
      4. Viste e limiti sulle viste
    5. Nothing e Null
    6. Capire i tipi astratti
      1. Un confronto tra tipi parametrici e tipi astratti
    7. Tipi dipendenti dal percorso
      1. Il percorso C.this
      2. Il percorso C.super
      3. Il percorso path.x
    8. Tipi valore
      1. Designatori di tipo
      2. Tuple
      3. Tipi parametrici
      4. Tipi annotati
      5. Tipi composti
      6. Tipi infissi
      7. Tipi funzione
      8. Proiezioni di tipo
      9. Tipi singleton
    9. Annotazioni self-type
    10. Tipi strutturali
    11. Tipi esistenziali
    12. Strutture dati infinite ed esecuzione ritardata
    13. Riepilogo, e poi?
  14. La progettazione di applicazioni
    1. Annotazioni
    2. Un confronto tra enumerazioni e pattern matching
    3. Considerazioni su annotazioni ed enumerazioni
      1. Le enumerazioni a confronto con le classi case e il pattern matching
    4. Un confronto tra null e Option
      1. Option e le espressioni for
    5. Le eccezioni e le alternative
    6. Astrazioni scalabili
      1. Regole di visibilità a grana fine
      2. La composizione dei mixin
      3. Annotazioni self-type e membri tipo astratti
    7. La progettazione efficace dei tratti
    8. I pattern di progettazione
      1. Il pattern Visitor: un’alternativa migliore
      2. L’iniezione di dipendenza in Scala: il pattern Cake
    9. Una progettazione migliore con la progettazione per contratto
    10. Riepilogo, e poi?
  15. Strumenti, librerie e IDE per Scala
    1. Strumenti a riga di comando
      1. Lo strumento scalac a riga di comando
      2. Lo strumento scala a riga di comando
      3. Gli strumenti scalap, javap e jad a riga di comando
      4. Lo strumento scaladoc a riga di comando
      5. Lo strumento sbaz a riga di comando
      6. Lo strumento fsc a riga di comando
    2. Strumenti di assemblaggio
    3. Integrazione con gli IDE
      1. Eclipse
      2. IntelliJ
      3. NetBeans
      4. Editor di testo
    4. Sviluppo guidato dai test in Scala
      1. ScalaTest
      2. Specs
      3. ScalaCheck
    5. Altre librerie e strumenti degni di nota per Scala
      1. Lift
      2. Scalaz
      3. Scalax
      4. MetaScala
      5. JavaRebel
      6. Varie librerie minori
    6. Interoperabilità con Java
      1. I generici in Java e Scala
      2. Usare le funzioni Scala in Java
      3. Proprietà JavaBeans
      4. I tipi AnyVal e i tipi primitivi in Java
      5. Nomi Scala nel codice Java
    7. Interoperabilità con le librerie Java
      1. AspectJ
      2. Spring
      3. Terracotta
      4. Hadoop
    8. Riepilogo, e poi?
  16. Glossario
  17. Riferimenti

© 2008–9 O’Reilly Media
© 2009–10 Giulio Piancastelli per la traduzione italiana