This is my own “re-telling” of the tour of Scala from the official Scala website. If you are wondering WhyAnotherTour, it’s mostly because it was fun and informative. I hope you feel the same way.

You should be able to go through these in the order listed, with each building on previous topics. I’ve also linked to the original tour topics as well as added my own where I thought it might help.

Basics

1. ScalaBasics – this covers some syntactic things that might surprise you, as well as some very basic things about working with Scala (not in the tour)
2. UnifiedTypes – everything is an object
3. ScalaClasses – Scala is object-oriented
4. ScalaProperties – Scala intelligently handles so-called “getters” and “setters”
5. ScalaPackages – Scala allows code to be packaged for visibility and organization
6. ScalaObject – Scala has direct support for singletons
7. ScalaTraits – Scala allows multiple inheritance via mixins.
8. ScalaGenerics – Scala allows parameterized types
9. ScalaAnnotations – Scala can use Java annotations
10. ScalaOperators – Scala’s flexible syntax lets you create your own operators.
11. JavaIntegration – Scala can call anything that Java can.

Intermediate

1. ScalaFunctions – Scala has strong support for functional programming
2. PatternMatching – Scala has an advanced switch/case system
3. FunctionCurrying – define a function that has received some of its parameters now, and will get the remainder later.
4. CaseClasses – taking switch statements to a useful level.
5. SealedClasses – tightening up CaseClasses.
6. XmlLiterals – Scala allows XML literals that are smarter than strings.
7. ForComprehensions – don’t let the name confuse you; this is about Scala’s powerful for loop construct
8. TypeBounds – Scala’s generic types can be restricted and bound (just as in Java)
9. InnerClasses – Scala supports nesting classes within objects and other classes.
10. ImplicitConversions – Scala can implicitly convert objects to other types.
11. TypeDependentClosures – Closures in general discussed here, too.

Advanced

1. ImplicitParameters – Scala can automatically pass parameters to methods that need them!
2. TypeVariance – Scala supports more advanced generics/type parameterization via covariance and contra-variance.
3. AbstractTypes – Scala supports type aliasing and abstract types as an alternative to generics/type parameterization.
4. AdvancedScalaObjects – Scala’s singleton objects are quite powerful.
5. DuckTyping – Scala supports duck typing. Take that, Ruby!
6. ActorsAndConcurrency – Scala uses an actor/message-passing style of concurrency
7. ExplcitlyTypedSelfReferences – This is like the final boss in Super Mario 3. Good luck.