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:
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.
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.
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.
This video will develop motivation for learning a new approach to software development and a new and decidedly different programming language.
This video will outline the approach to managing complexity that functional programming (FP) encourages.
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.
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.
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.
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.
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.
We will drill deeper into values, function application and composition, and the various ways to declare functions.
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.
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.
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.
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.
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?
The aim of this video is to specify the desired behaviour of our program, its operations, and interactions.
Various packages exist for parsing command-line options. In this video, we’ll focus on one in particular optparse-applicative.
Optparse-applicative allows us to build up complex parsers using the functor, applicative, alternative type classes and product, and sum algebraic data types.
The aim of this video is to implement our whole parser and learn how to implement subcommands and finish off our parser.
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.
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.
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.
Our command-line parser is not yet complete. We used loosely typed strings where we should’ve used more structured types for our arguments.
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.
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.
In this video, we will implement the Remove command to remove the data for a single item from the data on the file system.
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.
In this video, we will implement the List command to list all the to-do list items in the data on the file system.
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.
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.
In this video, we`ve given the range of packages available in the ecosystem, ways to effectively search repositories which is an important skill.
Packt has been committed to developer learning since 2004. A lot has changed in software since then - but Packt has remained responsive to these changes, continuing to look forward at the trends and tools defining the way we work and live. And how to put them to work.
With an extensive library of content - more than 4000 books and video courses -Packt's mission is to help developers stay relevant in a rapidly changing world. From new web frameworks and programming languages, to cutting edge data analytics, and DevOps, Packt takes software professionals in every field to what's important to them now.
From skills that will help you to develop and future proof your career to immediate solutions to every day tech challenges, Packt is a go-to resource to make you a better, smarter developer.
Packt Udemy courses continue this tradition, bringing you comprehensive yet concise video courses straight from the experts.