Gain insights into Haskell's functional programming by learning to write pure functions, use pattern matching, recursion, and Lists, define data types, and execute IO operations.

tarball.tar.gz

ghci

Functional programming is a problem-solving paradigm that differs drastically from the imperative programming style of languages like C++ or Java. While functional programming principles have invaded most modern programming languages to some degree, there is no language that embraces this paradigm quite as Haskell does. As a result, Haskell code can reach a level of expressiveness, safety, and elegance that is difficult to achieve in other programming languages.

This course will introduce you to the core concepts of functional programming in Haskell. You will learn how to write pure functions using techniques such as pattern matching and recursion, and how to work with Haskell's powerful List data type. You will understand the basics of Haskell's powerful type system and define your own data types. Finally, you’ll learn how to perform IO operations the Haskell way. By the end of this course, you’ll have a new paradigm to add under your belt and you can start using functional programming in your own projects.

Learn Functional Programming in Haskell

The final basic data type we will cover is the `String` data type. Once more, a `ghci` terminal is available for you to follow along:

# The `String` type
Strings represent sequences of characters. To distinguish `String` values from `Char` values, they are written in double quotes (e.g. `"hello"`). Strings can also be empty (`""`). 
Note that single character strings are not the same as characters: they are of a different type, and thus, are not the same value.
```
Prelude Data.Char> :t "a"
"a" :: String
Prelude Data.Char> :t 'a'
'a' :: Char
```
Let's look at a few handy string functions.

## Concatenation

Two strings can be joined together using the `++` operator.
```
Prelude Data.Char> "hello, " ++ "world"
"hello, world".
```

## Reverse

Strings can be reversed using the `reverse` function.

```
Prelude Data.Char> reverse "hello"
"olleh"
Prelude Data.Char> reverse "radar"
"radar"
```
## Conversion to and from numbers

Turning numbers into strings is easy. We just need to use the fittingly named `show` function.
```
Prelude Data.Char> show 5
"5"
Prelude Data.Char> show 2.5
"2.5"
```
The counterpart to `show` is `read`. We can use it to parse numbers from strings.
```
Prelude Data.Char> read "5" :: Int
5
Prelude Data.Char> read "2.5" :: Double
2.5
```
Note that we have used type annotations here. This is sometimes necessary, to let `read` know which type it is expected to parse. The `read` function is used for many different types, including numeric types and many more (e.g. `Bool`).
```
read "True" :: Bool
True
```
Calling `read` on a string in `ghci` without annotating the type can lead to errors like this.
```
Prelude Data.Char> read "5"
*** Exception: Prelude.read: no parse

```
However, in many cases, Haskell's type inference can determine the appropriate type from the context of the value. This means that type annotations are often not necessary.
```
Prelude Data.Char> read "5" + 3
8
```
Another source of runtime errors in `read` can be strings that do not allow to parse a number.
```
Prelude Data.Char> read "hello" + 3
*** Exception: Prelude.read: no parse
```

This is an instance where Haskell can miss errors during compile time. In the end, when working with input data from the real world, situations such as `read` failing to parse cannot always be avoided. However, they can certainly be handled better than throwing an exception and crashing the program. We can even make use of the type system to find a better solution. We will cover this in a later lesson on [Creating Polymorphic Types](https://www.educative.io/courses/functional-programming-haskell/creating-polymorphic-types#using-maybe-for-error-handling).

Introduction

First Steps with Haskell

Techniques for Writing Functions

Working with Lists

Creating Data Types

Input and Output

Conclusion

Appendix

Strings

The `String` type

Strings

The String type

The `String` type