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

# Introduction to IO

So far, all of the code we have written has been **pure** functional code without side effects. Of course, this is not suitable for IO operations, as their whole point is to execute side effects and interact with the "outside world". 

So, we will need a Haskell language feature to perform impure operations. At first glance, this seems troubling. If we allow the use of impure operations in any Haskell function, we will lose the advantage of referential transparency and code that is easy to reason about.

The solution of Haskell is to introduce a special type `IO a`. The meaning of a value of type `IO a` is "an operation which performs IO and produces a value of type `a`". Every function that handles IO must have `IO` as its return type. Conversely, a function that does not return `IO` may not interface with the outside world. Therefore, we can easily see from the type declaration whether a function is pure or not.

## Hello, World

To start, let's look at a "Hello, World!" program.

main :: IO ()
main = putStrLn "Hello, World!"

The function `main` has type `IO ()`, i.e., it performs IO and returns an empty tuple. Note that the notation `()` is used for both the type of empty tuples and the only value `()` of that type. The return type of an empty tuple is commonly used for functions which should return nothing, i.e., `main` is only executed for its side effects and not producing any value to be used further in the program. 

The type of `putStrLn` is 
```
putStrLn :: String -> IO ()
```
It takes a string and results in an IO action that produces nothing. In this case, the IO action is to print the input string to the screen.

We have already seen the `main` function in use in many executable code snippets throughout the course -- often together with the `putStrLn` or `print` functions. In all of these instances, we were performing `IO` actions all along!

Now that we are working with IO, we are no longer limited to test our functions in the interactive environment `ghci`. Additionally, we can compile and run our programs. The function name `main` is special: every Haskell program needs to contain exactly one function `main :: IO ()`. This is the function that is executed when the program is compiled and run. 

Let's put the "Hello, World!" program into a file `hello.hs`. We can compile the program by calling `ghc hello.hs`, which produces an executable file called `hello`. We can then execute `hello`, which will call the `main` function and print `Hello, World!` to the screen.

```
ghc hello.hs
./hello
Hello, World!
```

However, we can still use `ghci` for debugging our code if we want to, even if it includes `IO` operations. 
```
Prelude> sayHello = putStrLn "hello"
Prelude> sayHello
hello
```



In this lesson we introduce input/output operations in Haskell.

Introduction

First Steps with Haskell

Techniques for Writing Functions

Working with Lists

Creating Data Types

Input and Output

Conclusion

Appendix

IO By Example

Introduction to IO