While FP has been around for many decades, its following has only been growing rapidly in recent years. More programmers are picking up functional programming languages or are programming in a functional style in non-functional languages than ever before. At the same time, existing non-functional programming languages are adopting a growing number of FP featuresand libraries.

In these ongoing developments, Haskell stands out as a reference for all. As a purely FP language, it embodies the ideal of FP. As a trailblazer for new (functional) programming language developments, it sets the bar for other languages to follow inits tracks.

Before diving into practical FP, this chapter gives a brief overview of what FP is and how Haskell fits in. Then, we start with our first Haskell functions. We learn how to define and call functions. This includes an explanation of all the syntactic elements (types, type signature, function body, and so on) and their role. Along the way...

From theWriting basic functions section onward, you will need a working Haskell environment: theGlasgow Haskell Compiler (GHC) anda code editor (e.g., Visual Studio). We refer to the Haskell website (in particular, the page athttps://www.haskell.org/get-started/) for directions on how to set up this environment. The main installer for GHC can be foundathttps://www.haskell.org/ghcup/.

The code shown in this book can be downloaded from its GitHubrepository:https://github.com/PacktPublishing/Soar-with-Haskell.

Before divinginto practical Haskell programming, we give a brief overview of FP, its history, and its applications. If you are eager to get your hands dirty, you may want to forge ahead to the next section, then return here at a later occasion when you are ready to put Haskellinto context.

Programming with functions

Functional programming (FP) is one of the main programming paradigms next to imperative programming andobject-oriented programming.

Declarative programming

What setsFP apart from the other two is that it is a member of thedeclarative programming family. Sometimes, theprinciple of declarative programming is summarized by saying that declarative programs statewhat should happen, not how it should happen. This means that its programs do not explicitly determine the order in which computation steps are executed; it is up to the language implementation. Haskell particularly stands out among other FP languages because it embraces the declarative...

In this section, wewrite our first Haskell functions to get acquainted with Haskell’s syntax andbasic elements.

Our first function

Let us start with a simple function for incrementingan integer:

increment :: Int -> Intincrement x = x + 1

This function definition consists of two lines. The first line is thetype signature and the second line defines the behavior of the function. The type signature states that the function has the name increment and, given a value of theInt type as input, produces a result of theInt type. Here,Int is of course the type of integers such as-1,0,and42.

The second line is anequation that says thatincrement x (wherex is any possible input) is equal tox + 1. We can read such an equation also operationally: given anyx input, theincrement function returns the resultx + 1. Here,x is called avariable; it acts as a placeholder for an actual input to the function. The resultx + 1 is called the...

Haskell comes with several built-in primitive types that are used inmost programs.

Int and Integer

We have already used theInt type of integers in several examples. It supports four common arithmeticinfix operators:

• (+) –addition
• (-) –subtraction
• (*) –multiplication
• (^)–exponentiation

The(-) operator can also be used as a prefix operator to negate a number. Besides these operators, two useful arithmetic functions areas follows:

1. div –integer division
2. mod –modulo

A common beginner mistake is to use the(/) operator forInt, but it is only defined for floating-point types such asFloatandDouble.

TheInt type only covers a finite range of integers. The Haskell language specification guarantees that this covers at least the integers in the range from -229 to (229-1), but the actual range can be implementation dependent. For example, in GHC 8.10.2...

Types are very important in Haskell. It is, after all, a statically typed language. This means that programs are (type-)checked before they are run, by a process called thetype checker. If the type checker finds that the program violates the typing discipline imposed by the language, then it raises a (type) error and the program will notbe executed.

The type checker helps in several ways during theprogramming process.

Checking function calls

Firstly, whencalling a function, it checks that we pass parameters of the appropriate type to that function. For instance, recall thatdiscount has theInt ->Float type:

*Main> discount True<interactive>:44:10: error:    • Couldn't match expected type 'Int' with actual type 'Bool'    • In the first argument of 'discount', namely 'True'      In the expression...

You can write larger Haskell programs by composing simple functions into morecomplex ones.

Calling functions from within functions

Functionsare composed simply by defining a more complex function in terms of simpler functions. This means that the definition of the complex function callsother functions.

For example, let us write a function to compute the price of a purchase given the price of the purchased item and the quantity at which itis purchased:

price :: Float -> Int -> Floatprice ip qty = ip * fromIntegral qty

This is already an example of the principle that a more complex function,price, calls simpler functions. In this case, the simpler functions are two predefined functions: the(*) operator and thefromIntegral function. Recall that thefromIntegral conversion is needed to convert theInt quantity to aFloat type before it can be multiplied by theitem price.

When our business logic evolves, we can introduce a discounted price...

This chapter has given us a brief introduction to FP and Haskell. We have written our first basic Haskell functions, used Haskell’s primitive types, and combined individual functions into larger programs. We have also learned about type checking and how ithelps us.

InChapter 2,Algebraic Datatypes, we will learn how to define our own custom datatypes, how to create values of these types with constructors, and how to take those values apart with pattern matching. We will also familiarize ourselves with a powerful abstraction mechanism for types that is used ubiquitously in Haskell:parametric polymorphism.

1. What are the key characteristics of theHaskell language?
2. What is the purpose of parenthesesin Haskell?
3. What is the difference between theInt andInteger types?
4. How does the type checker help in theprogramming process?
5. What are the different ways in which we can definelocal functions?

• Haskell 98 Language and Libraries: The Revised Report. Simon Peyton Jones et al. December2002.https://www.haskell.org/onlinereport/
• A history of Haskell: being lazy with class. Paul Hudak, John Hughes, Simon L. Peyton Jones, Philip Wadler. HOPL2007: 1-55.

1. Haskell is a lazy, purely FP language that is both principledand nimble.
2. Parentheses are used for overriding or disambiguating the precedence of function andoperator applications.
3. Because theInt type uses a fixed-size representation, it has a bounded range and wraps around when going beyond that range. In contrast, because the size of anInteger value is not fixed, it can bearbitrarily large.
4. The type checker makes sure that function definitions conform to their type signature and that function calls likewise respect that type signature. It also disambiguates overloaded functions and operators, and can automatically infer type signatures when noneare given.
5. Haskell provides two different syntaxes for this. Withlet…in…, we can define a local function anywhere in an expression. In contrast, awhere clause can define a function local toan equation.