Learn the syntax, data types, and operations essential for programming in Scala

Become a Scala Developer

In this module, we will learn Scala from the ground up. This module aims to teach us how to write basic programs, assuming we have no prior knowledge of the language. We will start with a brief introduction to Scala to understand its functionality and applications. We will then move discuss the key features and functions of the language (data types, functions, classes, etc.) in detail. In the end, we will have all the basic knowledge of how to program in Scala.

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