Learning Haskell Programming

We want to get started with Haskell in a quick and engaging way, without having to start with a long lecture on syntax. So, to develop our familiarity with Haskell, we'll explore some of the basics, such as how to use and manipulate numbers and strings using 'ghci,' the interactive interpreter.

It's hard to write interesting programs with just simple types such as strings and numbers. In this video, we'll look at built-in data structures such as Lists and Tuples, and see how we might do a simple dictionary lookup using built-in functions and the Maybe type.

The interactive interpreter is a great tool, but we're not going to be able to write longer programs without breaking our text editor. In this video, we'll look at how to use ghci along with our source code files.

You can't do "Functional Programming" without functions. In this video, you'll learn about how to declare functions in Haskell and some of the important characteristics of Haskell functions—how they work with types, currying, and point-free style.

If you're worried that being a "strongly typed" language meant that Haskell's types would be restrictive, never fear! In this video, we'll see how to define not just synonyms, but new types, including recursive ones!

Now we've created our new data-type, how do we manipulate the data inside it? In this video, you'll learn how to calculate the Expression values that we created in the previous video, and look at how to do pattern matching on lists.

To make sure we're taking advantage of a solid structure to develop a more complicated application on, we'll create a project with 'stack.' We'll see how to structure our main module, library functions, and tests and look at how to develop, compile, and test the project.

In this video, we'll take the first steps towards declaring and displaying a simple grid of letters.

So we want to search the grid from left to right, right to left, top to bottom, and diagonally... phew! Let's keep things simple for now by searching just from left to right. We'll explore list manipulation functions and the similarities between the Bool and Maybe types.

Though we can now search the grid horizontally, we want to do it in all directions. The easiest way to do this isn't to make our function more complicated, but rather to learn how to transform our grid! We'll use a toolkit including 'map', 'reverse', 'transpose', and our own recursive functions to do this.

Although Haskell's type system by itself gives you a lot of reassurance that you're writing correct code, good unit tests can help you maintain and understand your code even better.

You will learn how to associate every character on the word grid with a set of coordinates such as (2, 3) pointing at its position by row and column. We can accomplish this by learning more about Haskell's list type, including how to work with infinite lists, repeat values, iterate them with the List monad and list comprehensions, and join lists together with zip.

Using the grid coordinates from the previous video, we will explore how to declare a Cell datatype and incorporate that into our code. This will also give us a good experience of refactoring code. We'll do this using Haskell's type system.

In the previous video, we saw that the search functions couldn't be refactored in a simplistic, mechanical way. We now have to think about how to change a simple string search using 'isInfixOf' into something that searches on characters, but returns a complex Cell type.

The moment we've all been waiting for: we'll now turn all of our hard work learning about functions and data types into an actual game that we can play!

While we can now play our game, it still has a few rough edges. We'll now polish off a few of these. Frist, we want to create a random jumble of characters in the part of the grid that we're currently displaying with "underscore" characters. Next, we want to highlight each of the found words by uppercasing them.