Scala Learning Tree (for Java developers)

Get Started. It's Free
or sign up with your email address
Scala Learning Tree (for Java developers) by Mind Map: 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. vals/vars

2.1. 'name:Type' instead of 'Type name'

2.2. equivalent to Java's final

2.3. immutability encouraged by default

3. To Be Organised

4. Scope

4.1. private[this]

4.2. private[package]

4.3. private[<whatever>]

5. notes on this map

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

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

6. Oddities and FAQs

6.1. null vs Option[]

6.2. null/None/Nothing/Nil

6.3. Tooling support

6.3.1. Build systems

6.3.2. IDEs

6.3.3. Code Coverage

7. Specialist Topics

7.1. Testing

7.1.1. Specs

7.1.2. ScalaTest

7.1.3. SUnit

7.2. Java Interop

7.2.1. Collections

7.2.2. Array and GenericArray

7.2.3. Generics (erasure)

7.3. Concurrency

7.3.1. threads

7.3.2. Actors

7.3.2.1. react/reply

7.3.2.2. reactors

7.3.2.3. lift/akka/scalaz

7.3.3. fork/join

7.4. 3rd Party Libs

7.4.1. scaladb

7.4.2. scalaz

7.4.3. scalax

7.4.4. akka

7.4.5. liftweb

8. Advanced Functions

8.1. higher-typed functions

8.1.1. call by name

8.2. PartialFunction

8.2.1. From a match block

8.2.2. isDefinedAt

8.3. closures

9. New node

10. Reflection

10.1. classOf[]

10.2. Manifest and ClassManifest

10.2.1. Passed with a Context Bound

10.3. instanceof

11. Implicits

11.1. Conversions

11.1.1. View Bounds

11.1.2. Pimp-My-Library

11.2. Parameters

11.2.1. Final Parameter List may be implicit

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

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

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

11.3. Implicit Scope

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

11.3.1.1. (Shadowed by name!)

11.3.2. Companion object of parts of expected type

12. Collections

12.1. Mutable vs Immutable

12.2. Seq vs List vs Iterable vs Traversable

12.3. Maps

12.3.1. A map is a function

12.4. Lists

12.4.1. cons

12.4.2. head

12.4.3. tail

12.4.4. Nil

13. Tuples / Pair

13.1. a -> b syntactic sugar

13.2. (a,b) syntactic sugar

14. Basic Generics

14.1. [] notation

15. Exception Handling

16. packages and imports

16.1. _ instead of *

16.2. import anywhere

16.3. multiple package statements and resolution

16.4. import from an instance

17. First-Class Functions

17.1. apply()

17.2. passing as an argument

17.2.1. higher-typed

17.3. functions vs methods

17.4. anonymous functions

17.4.1. underscore (_) as a placeholder

17.5. Partial Application

17.6. Currying

17.7. Singleton as a Function

17.7.1. Using apply on a companion object - factory pattern

17.8. Anonymous => syntactic sugar

18. Objects and Friends

18.1. classes

18.1.1. Body is the primary constructor

18.1.2. Secondary constructors

18.1.3. val & var on params

18.2. Singletons

18.3. Companions

18.3.1. Singleton is provided via companion object

18.4. Traits

18.4.1. mixins

18.5. Case Class Basics

18.5.1. hashcode/equals/canEqual

18.5.2. args as vals

18.5.3. Constructing without 'new'

18.5.3.1. Postpone explanation of how this is achieved

18.5.4. toString

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

18.6. Package Objects

19. Methods (defs)

19.1. Don't *require* parenthesis

19.2. multiple argument lists

19.3. Unit instead of void

19.3.1. '()' syntactic sugar

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

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

19.6. Named arguments

19.7. Default arguments

19.8. Varargs and the _* notation

19.9. override is a required keyword, not an annotation

19.10. Exception checking is not forced

19.10.1. the @throws annotation

19.11. 'Nothing' subclasses everything

19.12. Nested/inner methods

20. Uniform Access Principle

20.1. How getters/setters work

20.2. Overriding defs with vals/vars

20.3. @BeanPropery and @BeanInfo

21. Type Basics

21.1. Inference

21.1.1. With recursive functions

21.2. Type Ascription

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

21.3. Any/AnyRef/AnyVal vs Object

22. Patterns

22.1. binding

22.2. simple usage - assigning a tuple to 2 vals

22.3. match blocks

22.4. Matching on Structure

22.5. Matching on Type

22.6. Matching on absolutes

22.6.1. catch-all with an undescore

22.7. and case classes

22.7.1. sealed cases and exhaustive matches

22.8. Use in for comprehension

22.9. Extractors

22.9.1. unapply

22.9.2. unapplySeq

23. For Comprehensions

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

23.2. Multiple Generators

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

23.4. Desugaring to map/filter/flatmap/foreach