Courses Scala

Scala course Learn Scala

Overview Scala Chapters Scala Discussions Scala Theory Scala Papers

Scala Course

Sign Up now
It's free or Login
Get it on Google Play

Scala Course Overview

Who is this course for Scala course is designed for programmers who are already familiar with the basics of Scala programming language and want to improve their knowledge, prepare for the interview or explore corner cases of programming aspects in Scala. This Scala tutorial is originally not designed for beginners, but still covers basic topics. Mostly designed for developers with professional backgrounds starting from Junior to Senior / Architect.

About this course What is Scala?
Scala combines object-oriented and functional programming in one concise, high-level language. Scala's static types help avoid bugs in complex applications, and its JVM and JavaScript runtimes let you build high-performance systems with easy access to huge ecosystems of libraries.

You can find Scala interview questions as well as code examples from different topics starting from functions and pattern matching to evaluation strategies (call-by-name, call-by-value) and Scala collections, also including more advanced topics from cats library - Monoids and Semigroups.

Programming in Scala can be tricky and challenging, so Scala quiz in this course is based on real programming code examples and nuances of the scala-lang.

Scala Chapters

Functions and recursion
Learn about functional literals, nested functions, currying, recursion and higher order functions.
Functional data structures: singly linked lists
The following set of questions based on the functional way to implement Scala list.
Collections, Option, for syntax
Scala lists, sets, maps and how to traverse them with for loop or for comprehension in Scala - find out here.
Classes, objects, inheritance
Interested what’s special about sealed traits, case classes, or how to override def with val? Check out this chapter.
Basic Structures and Operations
Find out more about pattern matching, Scala types, exception handling and built-in control structures.
Cats: Semigroups and Monoids
Here we explore first type classes, monoid and semigroup. These allow us to add or combine values.
Evaluation strategies
Difference between call by name, call by value, def, val - learn in this chapter.

Latest Scala Discussions

@vetalbabenko36 True! thanks :) it creates Warning:(4, 32) could not emit switch for @switch annotated match def tokenMe(ch: Char) = (ch: @switch) match { ^

May 18, 1:04:03 AM Scala

This example will be successfully compiled. It doesn't optimize to tableswtich , but it is compiled.

May 3, 8:37:51 AM Scala

Scala Theory

Scala

Arity-1
Arity-1
Scala has a special syntax for invoking methods of arity-1 (one argument): 
names.mkString(",")
// is the same as
names mkString ","
This syntax is formally known as “infix notation”. It should only be used for purely-functional methods (methods with no side-effects) - such as mkString -or methods which take functions as parameters - such as foreach: 
// right!
names foreach (n => println(n))
names mkString ","
optStr getOrElse ""
// wrong!
javaList add item
Read more: Scala documentation: Method Invocation
Read more >
infix notation arity-1
Scala

Scala namespaces for definitions
Scala has just two namespaces for definitions in place of Java’s four. Java’s namespaces are fields, methods, types, and packages. Scala’s namespaces are:
• values (fields, methods, packages, and singleton objects)
• types (class and trait names)

In Scala it is forbidden to define a field and method with the same name in the same class, whereas it is allowed in Java.
This Java class would compile just fine: 

class CompilesFine {
  private int f = 0;
  public int f() {
    return 1;
  }
}
But the corresponding Scala class would not compile: 
class WontCompile {
  private var f = 0
  def f = 1
}
The reason Scala places fields and methods into the same namespace is precisely so you can override a parameterless method with a val.
Source: Overriding methods and fields
Read more >
namespace
Scala

@switch annotatition
An annotation to be applied to a match expression. If present, the compiler will verify that the match has been compiled to a tableswitch or lookupswitch and issue an error if it instead compiles into a series of conditional expressions.

Example usage:


val Constant = 'Q'
def tokenMe(ch: Char) = (ch: @switch) match {
  case ' ' | '\t' | '\n'  => 1
  case 'A' | 'Z' | '$'    => 2
  case '5' | Constant     => 3  // a non-literal may prevent switch generation: this would not compile
  case _                  => 4
}
Note: for pattern matches with one or two cases, the compiler generates jump instructions. Annotating such a match with @switch does not issue any warning.
Scala Documetation
Read more >
match expression pattern matching switch tableswitch lookupswitch

Scala Papers

Scala

Implementing authorization for API on the top of Play Framework 2.4*
The article considers the implementation of an easy to use authorization mechanism based on Play Framework 2.4* Actions architecture with full power of classical Actions
Read more >
Didn't find the topic you're interested in?
You can always email us about your preferences: [email protected]
Vote for new CodeGalaxy courses

You can also take an active part and create Scala course questions. Check FAQ and learn how to contribute to CodeGalaxy community and earn Gravity.