Scala is a general-purpose programming language principally targeting the Java Virtual Machine. Designed to express common programming patterns in a concise, elegant, and type-safe way, it fuses both imperative and functional programming styles. Its key features are: an advanced static type system with type inference; function types; pattern-matching; implicit parameters and conversions; operator overloading; full interoperability with Java; concurrency
Scala is a general-purpose programming language principally targeting the Java Virtual Machine. Designed to express common programming patterns in a concise, elegant, and type-safe way, it fuses both imperative-programming and functional-programming styles. Its key features are:
- Static typing
- Advanced type system with type inference and declaration-site variance
- Function types (including anonymous) which support lexical closures
- Pattern-matching
- Implicit parameters and conversions which support the typeclass and enrich-my-library patterns
- Mixin composition
- Full interoperability with Java
- Powerful concurrency constructs
- Advanced language constructs such as delimited continuations and an experimental macro system
For more information, see the official Scala Introduction and Scala Documentation.
To search for Scala symbols such as => in Stack Overflow, you can use symbolhound search.
To search Scala documentation, you can use scalex.
A community list of available libraries is available at Awesome Scala
There is Scala Library Index by Scala Center: Scaladex.
Free Scala programming books and guides
- Programming in Scala, First Edition
- Scala By Example (PDF)
- A Scala Tutorial for Java programmers
- Scala for Java refugees
- Scala School
- Scala Tutorials
- Scala Tour
- Scala for the Impatient (first part available for free at http://typesafe.com/resources/free-books)
- Coursera Course - Functional Programming in Scala
- Scala Exercises
- Underscore books
- The Neophyte's Guide to Scala
Stack Overflow Scala Tutorial
- Introduction to Scala
- Variables/values
- Methods
- Equal sign in methods
- Operator notation and the rules
- Multiple ways to define a method/function (leave parentheses in method calls)
- Unary operators
- Multiple parameter lists
- Right-associative method names
- Side effect free methods
- How to mix punctuation with alphanumeric characters in method names?
- Shortcut methods (
+=,-=,*=, ...) - List of "magic method" names (apply, unapply/unapplySeq, update)
- Named arguments / optional parameters
- Type inference in return type
- Difference between
##andhashCode
- Literals, statements and blocks
- Loops/recursion
- Data structures / Collections
- Collections design tutorial
- Collection standard practice
- Immutable Collections
- Mutable Collections
- Lazy Collections
- Parallel Collections
- Conversions
- Memory footprint
- How are Scala collections able to return the correct collection type from an operation?
- For-comprehension
- Enumeration
- Pattern matching
- Explanation
- Value binding (
x @ X) / type binding (x: X) - How to do a multi-match
- Guards
- How to match variables or values?
- How is pattern match implemented under the hood?
- Exhaustive pattern
- Pattern match in for-expressions
- Ignore cases / no default value
- Conjunction
- Pattern match PartialFunctions
- Match Regex
- Pattern matching with more than one match
- Classes, objects and types
- Difference between
classandobject - Why is
objecta Singleton? - Why are singleton objects more object-oriented?
- Companion objects
- Difference between
classandtype - What's the difference between a class with a companion object and a class and object with the same name?
- Static initializer
- Constructor overloading
- Static data in non-objects
- How to get the static/runtime type of a class
- Type projection (
A#B)
- Difference between
- Packages, imports and visibility identifiers
- Imports
- Packages
- Visibility
- Explanation
- Private constructors
- Private variables
- Inheritance
- Explanation
- Early initializer
- Extractors
- Explanation (Example: conjunctions)
- Infix notation for type parameters (
X[A, B]=>A X B)
- Case classes
- Parameterized types
- How to declare them?
- Upper / lower bounds
- Unify numerics
- How to get around type erasure?
- Abstract Types vs Generics
- Variances
- Traits
- Self references
- Error handling
- Exceptions
- Option
- Either
- What to use?
- Type handling
- Annotations
- Functions/Function literals
- Explanation
- Functions vs methods
- Pass functions
- Currying
- PartialFunction
- Placeholder syntax and their replacement rules
- Placeholder syntax with right-associative methods
- Difference between
=> Type,() => TypeandUnit => Type - Functional Quicksort
- Keyword
returnin higher order functions and performance problem with that - Function composition
- Closures in Scala
- Type safety
- Implicits
- Reflection
- What is a TypeTag and how do I use it?
- How to work with Reflection?
- Enrich-my-library pattern (formerly known as pimp-my-library)
- Concurrency overview
- Actors
- Use Java from Scala and vice versa
- XML literals
- Explanation
- Scala Swing
- Explanation
- Examples
- Type Programming
- Functional Scala
- Is immutability expensive?
- Is Scala functional programming slower than traditional coding?
- OOP in a purely FP context?
- Continuations
- Design patterns for functional-oo hybrid languages?
- Type programming
- Higher kinded types
- Type lambdas (
SomeType[({type λ[α] = Either[A, α]})#λ]) - Virtual Classes
forallin Scala- Understanding
for comprehensionin Scala
Further learning
- Learning Resources
- REPL
- Working with
scalacandscala - Operator precedence
- Scala style
- Functional Programming Principles in Scala, a functional programming course on Coursera taught by Martin Odersky, the creator of Scala.
- Principles of Reactive Programming, a reactive functional programming course on Coursera taught by Martin Odersky, Erik Meijer, Roland Kuhn.
- Parallel Programming, a parallel programming course on Coursera taught by Viktor Kuncak and Aleksandar Prokopec.
