Scala Learning Tree (for Java developers)

1. Variance in generics

1.1. Declaration vs Use-Site

1.1.1. ±notation

1.2. Co/Con/In-variance

2. Reflection

2.1. classOf[]

2.2. Manifest and ClassManifest

2.2.1. Passed with a Context Bound

2.3. instanceof

3. Implicits

3.1. Conversions

3.1.1. View Bounds

3.1.2. Pimp-My-Library

3.2. Parameters

3.2.1. Final Parameter List may be implicit

3.2.2. e.g Ordering[T] passed to sort method

3.2.3. Context Bounds as syntaactic sugar: foo[T: Ordered](a: Any) === foo[T](a: Any)(implicit ev1$: Ordered[T])

3.2.4. Poor Mans Typeclasses: http://lampwww.epfl.ch/~odersky/talks/wg2.8-boston06.pdf

3.3. Implicit Scope

3.3.1. Local members (vals/vars/object/defs) and Imported members

3.3.1.1. (Shadowed by name!)

3.3.2. Companion object of parts of expected type

4. Collections

4.1. Mutable vs Immutable

4.2. Seq vs List vs Iterable vs Traversable

4.3. Maps

4.3.1. A map is a function

4.4. Lists

4.4.1. cons

4.4.2. head

4.4.3. tail

4.4.4. Nil

5. Tuples / Pair

5.1. a -> b syntactic sugar

5.2. (a,b) syntactic sugar

6. Basic Generics

6.1. [] notation

7. Exception Handling

8. packages and imports

8.1. _ instead of *

8.2. import anywhere

8.3. multiple package statements and resolution

8.4. import from an instance

9. First-Class Functions

9.1. apply()

9.2. passing as an argument

9.2.1. higher-typed

9.3. functions vs methods

9.4. anonymous functions

9.4.1. underscore (_) as a placeholder

9.5. Partial Application

9.6. Currying

9.7. Singleton as a Function

9.7.1. Using apply on a companion object - factory pattern

9.8. Anonymous => syntactic sugar

10. vals/vars

10.1. 'name:Type' instead of 'Type name'

10.2. equivalent to Java's final

10.3. immutability encouraged by default

11. To Be Organised

12. Scope

12.1. private[this]

12.2. private[package]

12.3. private[<whatever>]

13. Objects and Friends

13.1. classes

13.1.1. Body is the primary constructor

13.1.2. Secondary constructors

13.1.3. val & var on params

13.2. Singletons

13.3. Companions

13.3.1. Singleton is provided via companion object

13.4. Traits

13.4.1. mixins

13.5. Case Class Basics

13.5.1. hashcode/equals/canEqual

13.5.2. args as vals

13.5.3. Constructing without 'new'

13.5.3.1. Postpone explanation of how this is achieved

13.5.4. toString

13.5.5. Postpone usage in pattern matching until pattern matching is introduced

13.6. Package Objects

14. notes on this map

14.1. Try not to mention any feature unless it's defined in terms of stuff above it on the list

14.1.1. Unless under 'To Be Organised', where anything goes!

15. Methods (defs)

15.1. Don't *require* parenthesis

15.2. multiple argument lists

15.3. Unit instead of void

15.3.1. '()' syntactic sugar

15.4. ': Unit' vs. not using '='

15.5. If single statement, don't require { braces }

15.6. Named arguments

15.7. Default arguments

15.8. Varargs and the _* notation

15.9. override is a required keyword, not an annotation

15.10. Exception checking is not forced

15.10.1. the @throws annotation

15.11. 'Nothing' subclasses everything

15.12. Nested/inner methods

16. Uniform Access Principle

16.1. How getters/setters work

16.2. Overriding defs with vals/vars

16.3. @BeanPropery and @BeanInfo

17. Type Basics

17.1. Inference

17.1.1. With recursive functions

17.2. Type Ascription

17.2.1. e.g. val b = 2 : Byte

17.3. Any/AnyRef/AnyVal vs Object

18. Oddities and FAQs

18.1. null vs Option[]

18.2. null/None/Nothing/Nil

18.3. Tooling support

18.3.1. Build systems

18.3.2. IDEs

18.3.3. Code Coverage

19. Specialist Topics

19.1. Testing

19.1.1. Specs

19.1.2. ScalaTest

19.1.3. SUnit

19.2. Java Interop

19.2.1. Collections

19.2.2. Array and GenericArray

19.2.3. Generics (erasure)

19.3. Concurrency

19.3.1. threads

19.3.2. Actors

19.3.2.1. react/reply

19.3.2.2. reactors

19.3.2.3. lift/akka/scalaz

19.3.3. fork/join

19.4. 3rd Party Libs

19.4.1. scaladb

19.4.2. scalaz

19.4.3. scalax

19.4.4. akka

19.4.5. liftweb

20. Patterns

20.1. binding

20.2. simple usage - assigning a tuple to 2 vals

20.3. match blocks

20.4. Matching on Structure

20.5. Matching on Type

20.6. Matching on absolutes

20.6.1. catch-all with an undescore

20.7. and case classes

20.7.1. sealed cases and exhaustive matches

20.8. Use in for comprehension

20.9. Extractors

20.9.1. unapply

20.9.2. unapplySeq

21. Advanced Functions

21.1. higher-typed functions

21.1.1. call by name

21.2. PartialFunction

21.2.1. From a match block

21.2.2. isDefinedAt

21.3. closures

22. For Comprehensions

22.1. Simple for (i <- 0 to 10) {println i}

22.2. Multiple Generators

22.3. Using yield to return a collection of the same type as the input

22.4. Desugaring to map/filter/flatmap/foreach

23. New node