This article is part of the Scala knowledge bits Series.

Periodically, I will publish new exercises so you can slowly build up knowledge about Scala.

It is designed to be done in a very short amount of time and learn a little bit each day, just to create a routine.

This episode will teach you about Scala foldLeft.

Hope you are going to enjoy it! It is designed for anyone to learn Scala from scratch and slowly learn, one Bit at a time.

After this Bit, I would love to hear your feedback in the comments down below.

Feel free to join the Discord server as well if you would like some help and support from the rest of our community.

What are we learning today?

Today we are going to learn about Scala foldLeft !

Let me introduce accumulators and aggregations.

foldLeft is the generic concept that is under most of the function programming transformations. You can replace map, flatMap, filter and more by a foldLeft.

Time to try on the exercise on your own and scroll down for more information when you are done or if you are stuck.

Exercise

Here is an exercise to complete today.

If I did my job well, you should be able to guess by yourself the solution based on what you previously learned and based on the clues.

But if you get stuck, scroll down to get more information.

The goal of the exercise is to replace the ??? by a piece of code so that the exercise compiles and that's how you win! Good luck!

You can fill the exercise right in here:

Or, if it does not load, go on to Scastie (1YO5x72fSE686gtMiAxKzQ).

More information about Scala foldLeft

In this exercise you will learn (or have learned, if you have already solved the puzzle) about Scala foldLeft.

In this exercise, you can see two use cases of foldLeft. But first let's explain the syntax:

foldLeft(initialValue) { case (accumulator, currentElement) => 
    // return the new value of the accumulator
}

Note that when currentElement is the first element of the List, then accumulator is equal to initialValue. Also, if the the list is empty, then the returned value will be the initialValue.

The returned value can be anything, for instance:

foldLeft(List.empty) { case (accumulator, currentElement) => 
    accumulator :+ currentElement 
}

would return a new List with the same content as the input list.

An other example:

foldLeft(0) { case (accumulator, currentElement) => 
    accumulator + currentElement 
}

would return the total sum of the item of the List. This is similar to the first example in today's exercise. And scala provide a shortcut for it: .sum, this would be a special case of the exercise when the initial value is 0.

In the second use case, there is a bit more going on. It uses pattern matching to implement different behavior based on the current element and create a new list element by element.

As an extra exercise, try to compute the average of the list by changing the initialized value from startFold to (0, 0) and modify the function to aggregate the values.

You can also try to implement map, flatMap and, filter using foldLeft. Share your solution with our community on Discord !

Feel free to go back to the exercise, modify the code to try out new things and get a better intuition for Scala foldLeft.

Conclusion

I hope you have learned something new or had fun during this Scala Knowledge Bit.

Please ask questions or post feedback in the comments below.

Feel free to try on the next Scala Knowledege Bit.

If you are curious about the previous Scala knowledge Bits, go check it out! 🙂

Originally published at https://leobenkel.com on September 23, 2020.

SKB — Scala foldLeft was originally published in Scala Knowledge Bits on Medium, where people are continuing the conversation by highlighting and responding to this story.

This article is part of the Scala knowledge bits Series.

Periodically, I will publish new exercises so you can slowly build up knowledge about Scala.

It is designed to be done in a very short amount of time and learn a little bit each day, just to create a routine.

This episode will teach you about Scala pattern matching.

Hope you are going to enjoy it! It is designed for anyone to learn Scala from scratch and slowly learn, one Bit at a time.

After this Bit, I would love to hear your feedback in the comments down below.

Feel free to join the Discord server as well if you would like some help and support from the rest of our community.

What are we learning today?

Today we are going to learn about Scala pattern matching !

We are going to learn about pattern matching today. At least, an introduction. Pattern matching is one of the key functionality of scala and it contributes to help you write clean and readable code.

Time to try on the exercise on your own and scroll down for more information when you are done or if you are stuck.

Exercise

Here is an exercise to complete today.

If I did my job well, you should be able to guess by yourself the solution based on what you previously learned and based on the clues.

But if you get stuck, scroll down to get more information.

The goal of the exercise is to replace the ??? by a piece of code so that the exercise compiles and that's how you win! Good luck!

You can fill the exercise right in here:

Or, if it does not load, go on to Scastie (5VQri4WFQ6yrPuBJHNIh5A).

More information about Scala pattern matching

In this exercise you will learn (or have learned, if you have already solved the puzzle) about Scala pattern matching.

The main keyword to use pattern matching is match. But as you saw, you can also use it inside map, as well as flatMap and filter and more.

The overall syntax is:

value match {
    case holder => action
    case _ => default case
}

And similar inside a map or other:

list.map {
    case holder => action
    case _ => default case
}

There are plenty of ways that pattern matching can be used and we only saw a few here, let’s review:

• catch all: case n => ???
• catch all without the value: case _ => ???
• With condition: case n if n % 2 == 0 => ???
• Exact match: case 3 => ??? or case "abc" => ???
• List extraction:
• > Empty list: case Nil => ???
• > Extract head: case head :: tail => ???
• > One element: case head :: Nil => ???
• > Two elements: case first :: second :: Nil => ???
• > One element with condition: case head :: Nil if head % 2 == 0 => ???
• > Extract value: case 12 :: tail => ???
• With types: case n: String => ???
• Case classes: (there will be an SKB about it)
• > Extraction of field: case Person(firstName, lastName) => ???
• > Extraction of field with condition: case Person(firstName, lastName) if firstName.startsWith("L") => ???
• > Extraction of field with exact match: case Person("Leo", lastName) => ???
• With regex: There will be an SKB about it
• With Scala version of enumeration: There will be an SKB about it

I might have forgotten some. If so, please let me know in the comment below or on our discord server.

Feel free to go back to the exercise, modify the code to try out new things and get a better intuition for Scala pattern matching.

Conclusion

I hope you have learned something new or had fun during this Scala Knowledge Bit.

Please ask questions or post feedback in the comments below.

Feel free to try on the next Scala Knowledege Bit.

If you are curious about the previous Scala knowledge Bits, go check it out! 🙂

Originally published at https://leobenkel.com on September 21, 2020.

SKB — Scala pattern matching was originally published in Scala Knowledge Bits on Medium, where people are continuing the conversation by highlighting and responding to this story.

This article is part of the Scala knowledge bits Series.

Periodically, I will publish new exercises so you can slowly build up knowledge about Scala.

It is designed to be done in a very short amount of time and learn a little bit each day, just to create a routine.

This episode will teach you about SKB — Scala defined type.

Hope you are going to enjoy it! It is designed for anyone to learn Scala from scratch and slowly learn, one Bit at a time.

After this Bit, I would love to hear your feedback in the comments down below.

Feel free to join the Discord server as well if you would like some help and support from the rest of our community.

What are we learning today?

Today we are going to learn about SKB — Scala defined type !

Let’s make our own type!

Time to try on the exercise on your own and scroll down for more information when you are done or if you are stuck.

Exercise

Here is an exercise to complete today.

If I did my job well, you should be able to guess by yourself the solution based on what you previously learned and based on the clues.

But if you get stuck, scroll down to get more information.

The goal of the exercise is to replace the ??? by a piece of code so that the exercise compiles and that's how you win! Good luck!

You can fill the exercise right in here:

Or, if it does not load, go on to Scastie (MBpSt9KLQECIxOPK8Phaeg).

More information about SKB — Scala defined type

In this exercise you will learn (or have learned, if you have already solved the puzzle) about SKB — Scala defined type.

You saw how to parameterize the entire code.

Try change MyType from Int to String.

This seem simple but it is a building block required to understand generic type later.

If you want to start now, try to replace MyType by the following code:

type SubType = Int type MyType = List[SubType]

Do you see how you can combine types together ? Like Lego !

List can be parameterized, we used it with Int and String in the past, but you can use any type you want.

Feel free to go back to the exercise, modify the code to try out new things and get a better intuition for SKB — Scala defined type.

Conclusion

I hope you have learned something new or had fun during this Scala Knowledge Bit.

Please ask questions or post feedback in the comments below.

Feel free to try on the next Scala Knowledege Bit.

If you are curious about the previous Scala knowledge Bits, go check it out! 🙂

Originally published at https://leobenkel.com on September 18, 2020.

SKB — Scala defined type was originally published in Scala Knowledge Bits on Medium, where people are continuing the conversation by highlighting and responding to this story.

This article is part of the Scala knowledge bits Series.

Periodically, I will publish new exercises so you can slowly build up knowledge about Scala.

It is designed to be done in a very short amount of time and learn a little bit each day, just to create a routine.

This episode will teach you about Scala Set.

Hope you are going to enjoy it! It is designed for anyone to learn Scala from scratch and slowly learn, one Bit at a time.

After this Bit, I would love to hear your feedback in the comments down below.

Feel free to join the Discord server as well if you would like some help and support from the rest of our community.

What are we learning today?

Today we are going to learn about Scala Set !

We saw other data structures in previous SKB like List or Map.

Let’s look at Set.

Time to try on the exercise on your own and scroll down for more information when you are done or if you are stuck.

Exercise

Here is an exercise to complete today.

If I did my job well, you should be able to guess by yourself the solution based on what you previously learned and based on the clues.

But if you get stuck, scroll down to get more information.

The goal of the exercise is to replace the ??? by a piece of code so that the exercise compiles and that's how you win! Good luck!

You can fill the exercise right in here:

Or, if it does not load, go on to Scastie (Xnga8KMIQimJPP8BwT5VAQ).

More information about Scala Set

In this exercise you will learn (or have learned, if you have already solved the puzzle) about Scala Set.

Did you notice that Set cannot contain duplicate values? A Set is a list of unique values.

When you combine the two Set, it removes the duplicated values and only keep one of each.

One thing to know is that Set do not guarantee consistant ordering. You should not rely on index of the elements. If you want to learn more, you can read this great answer on Stackoverflow.

Last thing about Set is that it has all the same function as List such as map, flatMap, filter, etc...

Feel free to go back to the exercise, modify the code to try out new things and get a better intuition for Scala Set.

Conclusion

I hope you have learned something new or had fun during this Scala Knowledge Bit.

Please ask questions or post feedback in the comments below.

Feel free to try on the next Scala Knowledege Bit.

If you are curious about the previous Scala knowledge Bits, go check it out! 🙂

Originally published at https://leobenkel.com on September 16, 2020.

SKB — Scala Set was originally published in Scala Knowledge Bits on Medium, where people are continuing the conversation by highlighting and responding to this story.

This article is part of the Scala knowledge bits Series.

Periodically, I will publish new exercises so you can slowly build up knowledge about Scala.

It is designed to be done in a very short amount of time and learn a little bit each day, just to create a routine.

This episode will teach you about Scala main.

Hope you are going to enjoy it! It is designed for anyone to learn Scala from scratch and slowly learn, one Bit at a time.

After this Bit, I would love to hear your feedback in the comments down below.

Feel free to join the Discord server as well if you would like some help and support from the rest of our community.

What are we learning today?

Today we are going to learn about Scala main !

A main is the method that is being called to start your program. It needs a specific structure - called prototype when talking about methods - to be recognized.

Until now we ran all the SKBs in Worksheet mode which hides the main from us.

Time to try on the exercise on your own and scroll down for more information when you are done or if you are stuck.

Exercise

Here is an exercise to complete today.

If I did my job well, you should be able to guess by yourself the solution based on what you previously learned and based on the clues.

But if you get stuck, scroll down to get more information.

The goal of the exercise is to replace the ??? by a piece of code so that the exercise compiles and that's how you win! Good luck!

You can fill the exercise right in here:

Or, if it does not load, go on to Scastie (Eb9UJewvRlOeORHTpjD5lQ).

More information about Scala main

In this exercise you will learn (or have learned, if you have already solved the puzzle) about Scala main.

If you have tried to remove or change the main function, you might have noticed an exception:

java.lang.RuntimeException: No main class detected.

This Exception will be thrown if a main method cannot be found or is not contained within an object. Try to change the code to trigger it.

The main prototype is always of the form:

def main(args: Array[String]): Unit = { }

The args: Array[String] is where you would be able to read and use the arguments given to the application when started.

That is pretty much it concerning main, so I thought it would be nice to combine some of the things we've seen in the past. This SKB is using Map, object, Option, lazy val, def all into the same project. Try to play with it and make it your own.

Feel free to go back to the exercise, modify the code to try out new things and get a better intuition for Scala main.

Conclusion

I hope you have learned something new or had fun during this Scala Knowledge Bit.

Please ask questions or post feedback in the comments below.

Feel free to try on the next Scala Knowledege Bit.

If you are curious about the previous Scala knowledge Bits, go check it out! 🙂

Originally published at https://leobenkel.com on September 14, 2020.

SKB — Scala main was originally published in Scala Knowledge Bits on Medium, where people are continuing the conversation by highlighting and responding to this story.

This article is part of the Scala knowledge bits Series.

Periodically, I will publish new exercises so you can slowly build up knowledge about Scala.

It is designed to be done in a very short amount of time and learn a little bit each day, just to create a routine.

This episode will teach you about Scala List par.

Hope you are going to enjoy it! It is designed for anyone to learn Scala from scratch and slowly learn, one Bit at a time.

After this Bit, I would love to hear your feedback in the comments down below.

Feel free to join the Discord server as well if you would like some help and support from the rest of our community.

What are we learning today?

Today we are going to learn about Scala List par !

I am going to give you an introduction to parallelization. For this, I will be using par.

However, you have to know, that to use this in Scala 2.13+ you need extra steps. You can read more on Stackoverflow. I made the choice to still be using it because, I think, it is a great stepping stone to understand more complex subjects.

Let’s dive in!

Time to try on the exercise on your own and scroll down for more information when you are done or if you are stuck.

Exercise

Here is an exercise to complete today.

If I did my job well, you should be able to guess by yourself the solution based on what you previously learned and based on the clues.

But if you get stuck, scroll down to get more information.

The goal of the exercise is to replace the ??? by a piece of code so that the exercise compiles and that's how you win! Good luck!

You can fill the exercise right in here:

Or, if it does not load, go on to Scastie (8kl0ZPy6T2ycipzz5iNkSg).

More information about Scala List par

In this exercise you will learn (or have learned, if you have already solved the puzzle) about Scala List par.

Compare the output of the two map. In the first one, you see the numbers in the same order they are in the source Range. In the second one, the order is random, try running it several times ; you will see the order of the print statements change.

This happen because all the operation executed in the map happen at the same time, in parallel.

Remember the SKB on Thread.sleep, this was the introduction to the concept of Threads. To allow each operation to happen at the same time, Scala will manage a pool of threads for you. Each operation will be allocated to thread that the computer will compute and then return the result for each operation. Finally, the result will be combined before being returned to you.

In further SKBs, we are going to learn more about threads in more details. We are going to talk about Fiber, Future, asynchronous and more. Stay tuned!

Feel free to go back to the exercise, modify the code to try out new things and get a better intuition for Scala List par.

Conclusion

I hope you have learned something new or had fun during this Scala Knowledge Bit.

Please ask questions or post feedback in the comments below.

The next Scala knowledge bit is coming in a few days ! Come back soon to check it out.

If you are curious about the previous Scala knowledge Bits, go check it out! 🙂

Originally published at https://leobenkel.com on September 11, 2020.

SKB — Scala List parallel was originally published in Scala Knowledge Bits on Medium, where people are continuing the conversation by highlighting and responding to this story.

This article is part of the Scala knowledge bits Series.

Periodically, I will publish new exercises so you can slowly build up knowledge about Scala.

It is designed to be done in a very short amount of time and learn a little bit each day, just to create a routine.

This episode will teach you about Scala Range.

Hope you are going to enjoy it! It is designed for anyone to learn Scala from scratch and slowly learn, one Bit at a time.

After this Bit, I would love to hear your feedback in the comments down below.

Feel free to join the Discord server as well if you would like some help and support from the rest of our community.

What are we learning today?

Today we are going to learn about Scala Range !

I can’t believe we haven’t seen Range yet !

Time to try on the exercise on your own and scroll down for more information when you are done or if you are stuck.

Exercise

Here is an exercise to complete today.

If I did my job well, you should be able to guess by yourself the solution based on what you previously learned and based on the clues.

But if you get stuck, scroll down to get more information.

The goal of the exercise is to replace the ??? by a piece of code so that the exercise compiles and that's how you win! Good luck!

You can fill the exercise right in here:

Or, if it does not load, go on to Scastie (3mkgQBbsRAKu0Yqo3tzoxA).

More information about Scala Range

In this exercise you will learn (or have learned, if you have already solved the puzzle) about Scala Range.

Super easy ! Right ? And so useful and powerful.

Summary of the keywords:

• to: When you do 0 to 3, you will get the numbers 0, 1, 2, 3. Notice that the end boundary is included.
• until: When you do 0 until 3, you will get the numbers 0, 1, 2. Notice that the end boundary is not included.
• by: When you do 0 to 11 by 3, you will get the numbers 0, 3, 6, 9. The default value is by 1.

Feel free to go back to the exercise, modify the code to try out new things and get a better intuition for Scala Range.

Conclusion

I hope you have learned something new or had fun during this Scala Knowledge Bit.

Please ask questions or post feedback in the comments below.

Feel free to try on the next Scala Knowledege Bit.

If you are curious about the previous Scala knowledge Bits, go check it out! 🙂

Originally published at https://leobenkel.com on September 9, 2020.

SKB — Scala Range was originally published in Scala Knowledge Bits on Medium, where people are continuing the conversation by highlighting and responding to this story.

This article is part of the Scala knowledge bits Series.

Periodically, I will publish new exercises so you can slowly build up knowledge about Scala.

It is designed to be done in a very short amount of time and learn a little bit each day, just to create a routine.

This episode will teach you about Scala Try.

Hope you are going to enjoy it! It is designed for anyone to learn Scala from scratch and slowly learn, one Bit at a time.

After this Bit, I would love to hear your feedback in the comments down below.

Feel free to join the Discord server as well if you would like some help and support from the rest of our community.

What are we learning today?

Today we are going to learn about Scala Try !

One thing to know first is the concept of Exception. An Exception, in java and Scala, is when an error happen. It will stop the interruption of the program and throw an Exception.

Time to try on the exercise on your own and scroll down for more information when you are done or if you are stuck.

Exercise

Here is an exercise to complete today.

If I did my job well, you should be able to guess by yourself the solution based on what you previously learned and based on the clues.

But if you get stuck, scroll down to get more information.

The goal of the exercise is to replace the ??? by a piece of code so that the exercise compiles and that's how you win! Good luck!

You can fill the exercise right in here:

Or, if it does not load, go on to Scastie (qtHKpgWXTeiYGARNzTp6zA).

More information about Scala Try

In this exercise you will learn (or have learned, if you have already solved the puzzle) about Scala Try.

The way to manually trigger an Exception is with throw. The code will then spit out what is called a stack trace. The stack trace will display each line of code that was in the stack of operation when the Exception occurred. It is essential to know how to read those when fixing a bug in a software.

Sometimes, a code will trigger an unexpected error, not one you decide to trigger. For instance, with bad math or more commonly from a third party library like a database connection. The connection might fail or timeout, etc… And then you need to react from the error. Maybe it is a critical error and you will decide to let the program stop its execution. But sometimes, you might be able to recover, in the case of a database, you could retry until it works, or retries several times until it succeed.

Try is the way to handle Exception in Scala. It allows you to abstract the potential failure and use the same methods that Option has to manipulate the data that might or might not be there. But instead of None when the Option is empty, you get an Exception when it is not defined which would carry more information about the kind of failure that was encountered. Like Option you can use map, flatMap, get, getOrElse and more.

Go back to the editor and try to make some code using map and flatMap with Try.

You might have noticed the case as well. This is still pattern matching. It is a bit piece of Scala and it is hard to explain, which is why I have been trying to slowly introducing it so when it comes time to dive more into it, you will already have some kind of intuition about it. Patience 🙂

Feel free to go back to the exercise, modify the code to try out new things and get a better intuition for Scala Try.

Conclusion

I hope you have learned something new or had fun during this Scala Knowledge Bit.

Please ask questions or post feedback in the comments below.

Feel free to try on the next Scala Knowledege Bit.

If you are curious about the previous Scala knowledge Bits, go check it out! 🙂

Originally published at https://leobenkel.com on September 7, 2020.

SKB — Scala Try was originally published in Scala Knowledge Bits on Medium, where people are continuing the conversation by highlighting and responding to this story.

This article is part of the Scala knowledge bits Series.

Periodically, I will publish new exercises so you can slowly build up knowledge about Scala.

It is designed to be done in a very short amount of time and learn a little bit each day, just to create a routine.

This episode will teach you about Scala Curry.

Hope you are going to enjoy it! It is designed for anyone to learn Scala from scratch and slowly learn, one Bit at a time.

After this Bit, I would love to hear your feedback in the comments down below.

Feel free to join the Discord server as well if you would like some help and support from the rest of our community.

What are we learning today?

Today we are going to learn about Scala Curry !

No, we are not talking about food here.

It is just a fancy way to talk about something simple. It describes the transformation of a method that takes several arguments into a series of function that each take one of those arguments. Simple? Try on the exercise.

Time to try on the exercise on your own and scroll down for more information when you are done or if you are stuck.

Exercise

Here is an exercise to complete today.

If I did my job well, you should be able to guess by yourself the solution based on what you previously learned and based on the clues.

But if you get stuck, scroll down to get more information.

The goal of the exercise is to replace the ??? by a piece of code so that the exercise compiles and that's how you win! Good luck!

You can fill the exercise right in here:

Or, if it does not load, go on to Scastie (yOTTk60dS4W0xRVsPMejbg).

More information about Scala Curry

In this exercise you will learn (or have learned, if you have already solved the puzzle) about Scala Curry.

See? Simple. Some coding is worth a thousand words!

Writing the code that way has a few advantages.

For instance, you can decompose the function into partially applied functions, like add2 in the exercise. This example is simple, but imagine a complex function that takes a database connector and/or configurations. You could set those arguments, and then only reuse the partially applied function when needed, I like to call it a pre-configured operation.

I also like using it for aesthetics, It allows to use { }like in r3 in the exercise.

And you can have as many arguments chained that way, As well as also combinations, for instance the first block could have 2 arguments and then 1 and then 3 arguments. Use it wisely depending on your needs.

Feel free to go back to the exercise, modify the code to try out new things and get a better intuition for Scala Curry.

Conclusion

I hope you have learned something new or had fun during this Scala Knowledge Bit.

Please ask questions or post feedback in the comments below.

Feel free to try on the next Scala Knowledege Bit.

If you are curious about the previous Scala knowledge Bits, go check it out! 🙂

Originally published at https://leobenkel.com on September 4, 2020.

SKB — Scala Curry was originally published in Scala Knowledge Bits on Medium, where people are continuing the conversation by highlighting and responding to this story.

This article is part of the Scala knowledge bits Series.

Periodically, I will publish new exercises so you can slowly build up knowledge about Scala.

It is designed to be done in a very short amount of time and learn a little bit each day, just to create a routine.

This episode will teach you about Scala flatMap.

Hope you are going to enjoy it! It is designed for anyone to learn Scala from scratch and slowly learn, one Bit at a time.

After this Bit, I would love to hear your feedback in the comments down below.

Feel free to join the Discord server as well if you would like some help and support from the rest of our community.

What are we learning today?

Today we are going to learn about Scala flatMap !

I want to introduce you slowly to more complex problems. This one is still fun, as you know, the main topic is flatMap but you are going to get an intuition for a little more.

Enjoy the ride.

Time to try on the exercise on your own and scroll down for more information when you are done or if you are stuck.

Exercise

Here is an exercise to complete today.

If I did my job well, you should be able to guess by yourself the solution based on what you previously learned and based on the clues.

But if you get stuck, scroll down to get more information.

The goal of the exercise is to replace the ??? by a piece of code so that the exercise compiles and that's how you win! Good luck!

You can fill the exercise right in here:

Or, if it does not load, go on to Scastie (7hRt7xVTRmujNkv1beZrAQ).

More information about Scala flatMap

In this exercise you will learn (or have learned, if you have already solved the puzzle) about Scala flatMap.

Did you get flatMap ? It is map followed by flatten. Try to replace the flatMap in the code above by map and add flatten after it.

Ok, now that the topic of today’s episode is done. What is the wizardry with all the case ?! This is called pattern matching. I am sure that, right now, you have a good intuition about it, but we are going to dive more into it, soon.

Stay tuned!

Feel free to go back to the exercise, modify the code to try out new things and get a better intuition for Scala flatMap.

Conclusion

I hope you have learned something new or had fun during this Scala Knowledge Bit.

Please ask questions or post feedback in the comments below.

Feel free to try on the next Scala Knowledege Bit.

If you are curious about the previous Scala knowledge Bits, go check it out! 🙂

Originally published at https://leobenkel.com on September 2, 2020.

SKB — Scala flatMap was originally published in Scala Knowledge Bits on Medium, where people are continuing the conversation by highlighting and responding to this story.