Learning Path: Haskell: Functional Programming in Haskell

Name: Learning Path: Haskell: Functional Programming in Haskell
Rating: 4.0 (46 reviews)

Explore functional programming and build real-world applications with Haskell

Created byPackt Publishing

Last updated 9/2017

English

English [Auto],

What you'll learn

Understand how functional programming addresses complexity
Get familiar with the general characteristics of functional programs
Learn GHCi in brief
See how Haskell compares with other functional programming languages
Learn how to parse command-line options using the applicative style
Understand how to use strict and lazy file I/O
Learn to handle various common Haskell string types
Learn to read, create, delete, and update data items in your application

Course content

2 sections • 34 lectures • 5h 9m total length

The Course Overview4:09
This video provides an overview of the entire course.
Installing Stack on Windows7:43
This video takes the user through the steps required to install the Haskell Stack build tool on Windows using Windows 10 Pro as an example.
Installing Stack on Mac OS6:33
This video takes the user through the steps required to install the Haskell Stack build tool on Mac OS using Mac OS X 10.10.5 (Yosemite) as an example.
Installing Stack on Linux5:24
This video takes the user through the steps required to install the Haskell Stack build tool on Linux using Ubuntu 12.04.5 LTS as an example.
Problems FP and Haskell Can Address6:30
This video will develop motivation for learning a new approach to software development and a new and decidedly different programming language.
The FP Way10:54
This video will outline the approach to managing complexity that functional programming (FP) encourages.
The Haskell Way9:07
This video will talk about what Haskell has in common with other functional programming languages as well as the ways in which it is different.
Our First Haskell Programs15:42
This video will demonstrate some more realistic programs, incrementally built up from simpler programs. It will run them in GHC’s interpreted mode. We will see more Haskell syntax encounter more functions from Haskell’s standard prelude.
Whitespace, Layout, and Scoping8:38
Haskell is a whitespace-sensitive programming language. It’s worth gaining some comfort with the indentation rules, even though they correspond—for the most part—to the “obvious” way to lay a program out. We’ll relate layout to lexical scoping of names.
GHCi and Interactive Haskell8:55
When we’re learning a new programming language, it can be very helpful to be able to query the types of values and expressions, and to be able to browse types and modules. The GHC compiler provides the GHCi read-evaluate-print loop, which allows us to inspect Haskell code at runtime.
Debugging with GHCi11:29
Haskell employs a non-strict evaluation strategy which can be strange for newcomers to the language. Furthermore, we will inevitably write buggy code. GHCi has useful debugging capabilities that can allow to address both of these concerns.
Values and Expressions24:39
We will drill deeper into values, function application and composition, and the various ways to declare functions.
Types and Type Signatures18:42
So far, we have only skimmed over types and type signatures. You need to know enough to be able to read function declarations and build our own functions and values.
Algebraic Data Types11:46
We’ve looked at built-in types and values and functions that use them; you need to learn how to define our own composite data types. This will use Haskell’s support for user-defined algebraic data types.
Type Classes16:56
Haskell’s primary mechanism for implementing abstract data types is the type class. We need to know about some of the common built-in type classes as well as how to implement our own type classes and type class instances.
Pattern Matching12:28
You learn all about declaring our own ADTs and creating values for them. Before we can really consume ADTs, you need to know how to
extract values from them using pattern matching.

The Course Overview3:12
This video gives an overview of entire course.
What Real Programs Do?2:19
We’ve learnt enough Haskell to write real programs, but what can Haskell programs do and what is the high-level structure of real programs?

Discuss the kinds of application we can build in Haskell

Enumerate the types of interfaces and interactions Haskell programs can employ

Establish what type of UI and operations our program will perform
Command-line To-do List1:55
The aim of this video is to specify the desired behaviour of our program, its operations, and interactions.
The Applicative Way9:58
Various packages exist for parsing command-line options. In this video, we’ll focus on one in particular optparse-applicative.
ADTs for Command-line Options17:00
Optparse-applicative allows us to build up complex parsers using the functor, applicative, alternative type classes and product, and sum algebraic data types.
Subparsers and Wrapping Up19:41
The aim of this video is to implement our whole parser and learn how to implement subcommands and finish off our parser.
File I/O and Laziness5:46
Haskell provides many ways to interact with files on the file system, perhaps most significantly, there is a strong distinction between lazy and strict I/O which can have important consequences for the behaviour of our programs.
Strings Revisited3:24
We have discussed Haskell’s various types used to represents character strings. In this video, we’ll extend our study of file I/O operations to cover both ByteString and Text types.
Parsing and Writing YAML14:35
We will need to persist our application’s data to the file system, choosing a structured file format is an important consideration. In this video, we will learn how to parse and write YAML.
Other Data Types11:07
Our command-line parser is not yet complete. We used loosely typed strings where we should’ve used more structured types for our arguments.
Reading Items9:06
To-do list items are serialized to the file system using the YAML format. We need to implement the Read command to retrieve the data for a
single item and display it on the terminal.
Creating Items2:14
The aim of this video is to implement the Add command to create the data for a new item and add it to the data on the file system.
Deleting Items4:04
In this video, we will implement the Remove command to remove the data for a single item from the data on the file system.
Updating Items6:32
In this video, we will implement the Update command to modify the data for a single item in the data stored on the file system.
Displaying Our To-do List5:38
In this video, we will implement the List command to list all the to-do list items in the data on the file system.
Other Commands4:39
In this video, we will implement the housekeeping commands Info and Init to display information about the to-do list on the file system and to (re)initialize the to-do list file respectively.
Building on Our Example5:28
We have written a full, working, and useful Haskell application. In this video, we will see what our next steps in developing our app are and what the kinds of scaling issues we’ll encounter are.
Wrapping Up3:09
In this video, we`ve given the range of packages available in the ecosystem, ways to effectively search repositories which is an important skill.

Requirements

Experience in Object-oriented programming is required.

Description

Haskell is one of the powerful functional programming language designed to work with complex data. Its emphasis on "purity" makes it easier to create rock-solid applications which stay maintainable and error-free even as they grow in scale.

If you're a developer with some experience in object-oriented programming languages, such as C, C++, Java, and wish to build applications using Haskell, then you should surely go for this Learning Path.

Packt’s Video Learning Path is a series of individual video products put together in a logical and stepwise manner such that each video builds on the skills learned in the video before it.

Let's take a quick look at your learning journey. This Learning Path begins with making your familiar with the concepts of functional programming and Haskell language. Then, you will learn to address all the problems with functional programming and Haskell with distinguishing the difference between the two. You will also learn Haskell in depth with creating your first Haskell program. Next, you will be briefed through GHCi (Glasgow Haskell Compiler). As you progress, you will learn to develop real programs that will make use of file I/O, command-line parsers and various third-party packages. You will then see how to perform data processing and handling of the program. Finally, you will learn the different ways of storing data in your file system and interacting with them.

By the end of this Learning Path, you will be able to write your own Haskell programs and also have ample knowledge of the important functionalities of Haskell.

About the Author:

For this course, we have the best works of this esteemed author:

Richard Cook is a staff software engineer at Tableau Software and works on high-performance relational database systems. He works primarily in C++, but has experience in a broad range of languages and technologies. He is a keen user of Haskell in his spare time and is frequently able to apply his functional programming and Haskell experience to his daily work. He is organizer of the Seattle Area Haskell Users’ Group and an active member of the Seattle functional programming community. He is currently developing a machine-learning framework for Haskell. He has a deep interest in programming languages and type systems in general, having developed compilers and developer tooling in the past. He is also a keen user of Python and C# and works regularly on all major desktop operating systems and dabbles with web applications.

Who this course is for:

This Learning Path is for software developers with some experience in object-oriented programming languages such as C, C++, Java, C#, Python, or Ruby.

Learning Path: Haskell: Functional Programming in Haskell

What you'll learn

Explore related topics

Course content

Fundamentals of Practical Haskell Programming16 lectures • 3hr

Building an Application with Functional Haskell18 lectures • 2hr 10min

Requirements

Description

Who this course is for: