Another Tour of Scala


This is my own “re-telling” of the tour of Scala from the official Scala website. If you are wondering why another tour , 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.


  1. ScalaBasics - Scala has some surprising syntax for both Javaists and Rubyists. This is a crash course.
  2. UnifiedTypes - everything is an object. Even Int. Finally.
  3. ScalaClasses - Scala is object-oriented.
  4. ScalaProperties - Scala intelligently handles so-called “getters” and “setters”…by not having them
  5. ScalaPackages - Scala allows code to be packaged for visibility and organization.
  6. ScalaObject - Scala has direct support for singleton objects.
  7. ScalaTraits - Scala allows multiple inheritance via mixins.
  8. ScalaGenerics - Scala allows parametrized 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.


  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. ExceptionHandling - Scala does have exceptions, but they are handled more simply than Java
  6. OptionType - Scala prefers a different way of handling null, by using the null object pattern
  7. SealedClasses - tightening up CaseClasses .
  8. XmlLiterals - Scala allows XML literals that are smarter than strings.
  9. ForComprehensions - don’t let the name confuse you; this is about Scala’s powerful for loop construct.
  10. TypeBounds - Scala’s generic types can be restricted and bound for (alleged) understandability.
  11. InnerClasses - Scala supports nesting classes within objects and other classes.
  12. ImplicitConversions - Scala can implicitly convert objects to other types.
  13. TypeDependentClosures - Scala has proper support for closures. Take that, Java!
  14. DefaultParameterValues - Scala 2.8 now supports default parameter values
  15. NamedParameters - Scala 2.8 introduced named parameters. Take that, Objective-C!


  1. ImplicitParameters - Scala can automatically pass parameters to methods that need them!
  2. TypeVariance - Scala supports more advanced generics/type parametrization via covariance and contra-variance. Your instinct is to run far away, but I think I’ve found a way to explain it.
  3. AbstractTypes - Scala supports type aliasing and abstract types as an alternative to generics/type parametrization.
  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. TypeSpecialization - Scala 2.8 allows specialization of generics for primitive types.
  8. PackageObjects - Scala 2.8 provides a means for packages to include things other than just classes and objects.
  9. ExplcitlyTypedSelfReferences - This is like the final boss in Super Mario 3. Good luck.