Scala 101: The Intro
Tags: scala, functional, programming, beginners
Published: 2023-03-09 21:21:36


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ci0yge91nwxe68x05iui.jpg)

**Hey there! Are you ready for a fun-tastic journey into the world of Scala and functional programming?**

If you're not familiar with functional programming, don't worry, it's not as scary as it sounds. Think of it like a healthy diet for your code. Instead of relying on messy, mutable data structures and confusing control flow, functional programming emphasizes the use of functions and immutable data structures to keep your code clean and easy to digest.

In fact, functional programming is like a vegan diet for your code. It may seem restrictive at first, but once you start eating those delicious, nutrient-dense vegetables (i.e. functions and immutable data), you'll wonder how you ever survived on a diet of meaty, bloated spaghetti code.

So get ready to chow down on some functional programming goodness with our Scala series. We promise it won't give you gas, but it will give your code the energy and clarity it needs to thrive.

**What is Scala?**

Scala is a programming language that combines functional and object-oriented programming paradigms. It was created by Martin Odersky in 2004 and has gained popularity due to its expressiveness and seamless integration with Java. In this article, we will take a closer look at the types available in Scala and present a small challenge with its solution.

Let's dive into some examples of the awesome data types you can use in Scala 3.

To start with, we have Int which is perfect for all your whole number needs. Here's an example:

```scala
val myNumber: Int = 42
```
 
Next up, we have Double, Float, and BigDecimal for when you need to crunch some serious numbers with decimals. Here's an example of how to use them:

```scala
val myDouble: Double = 3.14159
val myFloat: Float = 2.71828f
val myBigDecimal: BigDecimal = BigDecimal("1234567890.123456789")
```
For handling text, we have String data type. Here's an example:

```scala
val myString: String = "Hello, Scala!"
```

And finally, we have Boolean data type, which is great for handling logic. Here's an example:

```scala
val myBoolean: Boolean = true
```

That's for the basics!, let's talk about collections and Lists in Scala 3 before we jump into a fun challenge!

**Collections**

So collections are super important in any programming language because they let us group and manipulate data in different ways. In Scala 3, we have many collection types, each with their own cool features and benefits.

One of the most common collection types in Scala is the List. It's an ordered collection that can hold any type of element. You can create a List by doing something like this:

 
```scala
val myList = List(1, 2, 3, 4, 5)
```

**Lists** are immutable, which means once you create one, you can't change what's in it. But you can create new **lists **by manipulating the old ones.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/lhb6xwqd1fn3lvvs08he.png)

Alright folks, it's time for a fun challenge!

**CHALLENGE!**

## Can you create a function that takes in a **list** of integers and returns the sum of all the odd numbers in the list?

> _A small hint:_ in lists you can use **filter** .
> **Filter** is a method that you can call on a collection in Scala to return a new collection that contains only the elements that satisfy a certain condition.

Don't worry if you're feeling stumped - that's just part of the fun! After all, as functional programmers, we love a good challenge. It's like a puzzle that we get to solve with code.

> And if you need a little inspiration, here's a joke to get your creative juices flowing: Why did the functional programmer get thrown out of the bar? He kept talking about monads and wouldn't stop until he got to the bottom of the glass.

So go ahead, give it your best shot! With Scala 3's powerful functional programming features, you can write elegant and efficient code to tackle even the toughest challenges.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/7kedrk3vn6xpzqvehnjr.png)

**Solution**

And now, for the moment you've all been waiting for - the solution to the challenge! 

[Code in one compiler](https://onecompiler.com/scala/3z26fe2kw)

```scala
def sumOfOddNumbers(numbers: List[Int]): Int = {
  numbers.filter(_ % 2 != 0).sum
}
```
This function takes in a **list** of integers and filters out all the even numbers. It then adds up the remaining odd numbers using the sum method.

But there are many ways to approach this challenge! 

**another example**

```scala
def sumOfOddNumbers(numbers: List[Int]): Int = {
  numbers.foldLeft(0)((acc, curr) => if (curr % 2 != 0) acc + curr else acc)
}
```

In this solution, we're using the **foldLeft** method to iterate over each element of the List and accumulate a running total of the odd numbers.

If you came up with a different solution is more than welcome. Share your code in the comments below and let's compare solutions!

If your solution is different, that doesn't mean it's wrong.  Creativity and diversity is always valuable in problem-solving approaches.

So keep coding and keep having fun, thanks for reading and see you on the next one!