Explore Scala, a high-level, statically typed language combining functional and object-oriented programming. Gain insights into building scalable apps used by giants like Twitter and LinkedIn.

scala.tar.gz

Docker

Learn how to program in Scala, one of the most popular programming languages in the world right now -- not just amongst developers, but even amongst massive companies like Twitter and LinkedIn.

Scala provides you the tools to build scalable programs easily and effectively. It's a statically typed, high-level language that combines functional programming and object-oriented programming into one flexible package. 

This course will help you stay ahead of the curve, make awesome, scalable apps, and learn a highly coveted new programming language. Start learning today.

Learn Scala from Scratch

Which keyword is used for defining a function?

Which keyword is used for defining a function?

**function body wrapped in curly brackets** and **return type of the function**

**parameters wrapped in parenthesis** and **return type of the function**

**parameter type** and **function body wrapped in curly brackets**

**parameters wrapped in parenthesis** and **parameter type**

The following are optional when defining a basic function.

The following are optional when defining a basic function.

Evaluation only reduces an expression to a value if it is being used

Evaluation reduces expressions to a value.

Evaluation reduces a functions arguments to a value

What is the basic idea of the **substitution model**?

What is the basic idea of the substitution model?

They dictate which expressions should be evaluated

They dictate the order in which expressions are to be evaluated

They determine which expressions are to be terminated

What purpose do CBV and CBN have?

If the CBN evaluation of an expression terminates, then the CBV evaluation of the same expression is not guaranteed to terminate.

If the CBN evaluation of an expression terminates, then the CBV evaluation of the same expression is not guaranteed to terminate.

returns the minimum value in a given list

returns the median (middle value) in a given list

returns the maximum value in a given list

What does the following recursive function do?

```
def mysteryFunction(list: List[Int]): Int = { 
  def mysteryAccum(list: List[Int], theMystery: Int): Int = {
    list match {
      case Nil => theMystery
      case x :: tail =>
        val newMystery = if (x > theMystery) x else theMystery
        mysteryAccum(tail, newMystery)
    }
  }
  mysteryAccum(list, 0)
}
```

What does the following recursive function do?
<pre><code>def mysteryFunction(list: List[Int]): Int = { 
 def mysteryAccum(list: List[Int], theMystery: Int): Int = {
 list match {
 case Nil =&gt; theMystery
 case x :: tail =&gt;
 val newMystery = if (x &gt; theMystery) x else theMystery
 mysteryAccum(tail, newMystery)
 }
 }
 mysteryAccum(list, 0)
}
</code></pre>

Approximating the square root of a number using improved estimates

Approximating solutions using an iterative process

What is the general purpose of Newton's method?

What is the general purpose of Newton’s method?

```
def factorial(x: Int) = {
  def loop(accumulator: Int, x: Int): Int = {
    if(x==0) accumulator
    else loop(accumulator*x,x-1)
  }
  loop(1,x)
}
```

```
def factorial(x: Int): Int = {
  def loop(accumulator: Int, x: Int) = {
    if(x==0) accumulator
    else loop(accumulator*x,x-1)
  }
  loop(1,x)
}
```

```
def factorial(x: Int): Int = {
  def loop(accumulator: Int, x: Int): Int = {
    if(x==0) accumulator
    else loop(accumulator*x,x-1)
  }
  return loop(1,x)
}
```

Which function definition will give an error?

Which function definition will give an error?

Makes definitions outside a block visible to definitions inside a block

What is the benefit of lexical scoping?

```
def fib(x: Int): BigInt = {
  def fibHelper(x: Int, prev: BigInt = 0, next: BigInt = 1): BigInt = x match {
    case 0 => prev
    case 1 => next
    case _ => fibHelper(x - 1, next, (next + prev))
   }
   fibHelper(x)
  }
```

```
def sum(ints: List[Int]): Int = ints match { 
  case Nil => 0
  case x :: tail => x + sum(tail)
  }
 ```

```
def factorial(n: Int): Int = { 
  if (n == 0) 1
  else n * factorial(n-1)
} 
 ```
    
    

Which of the following is a tail recursive function?

Which of the following is a tail recursive function?

When you define something inside a block, it is only visible from within the block.

The definitions inside a block, shadow definitions of the same names outside the block.

You can define a variable inside a block with the same name as a variable outside a block without it affecting the outside variable.

Which of the following statements is true for blocks?

Which of the following statements is true for blocks?

In the next chapter, we will continue our discussion on functions and dive a bit deeper into functional programming.

In the following quiz, you will be tested on concepts you learned in this chapter.

Getting to Know Scala

Variables and Types

Operating with Operators

Strings and How to Use Them

Scala's Collection Library

Control Structures

Getting Started with Functions

Higher-Order Functions

Classes and Objects

Conclusion

Chapter Quiz