What's new
Featured functions

We just started a new section of the site called “Featured functions” which will house quick overviews of functions that we think deserve some extra love and attention. The first two featured functions are mapMaybe and intercalate.

Web Servers lesson 12 is about connection persistence – reusing the same socket for multiple HTTP requests. We write two versions of the server, one using lazy I/O and the other using strict ByteStrings.
Coercion and datatype contexts
Two new reference pages: A lengthy discussion of the coerce function, what it’s for, and how to use newtypes more effectively; and a note of historical interest on datatype contexts which addresses a common beginner question about typeclasses.
Object oriented Haskell
We have new lessons in two of our ongoing courses. In the fourth installment of the Timepieces course, Julie examines how the hierarchy of fltkhs is meant to mirror that of FLTK. The latest lesson in the Web Servers course is about parsing message bodies. And we’ve added to our documentation of GHC language extensions with an article on NumericUnderscores.
Return of the Clocks
This week we’re excited to bring you a new lesson in the native GUI course. In this lesson, Chris uses gtk3, Pango, and TVars to transform the blank application window into a clock. And the latest lesson in the Functortown course, in which Julie introduces the laws of the Bifunctor class and goes into more detail about how ranges and shrinkage work when you’re property testing with hedgehog.
Align, These, and HTTP headers
Course updates: Functortown lesson 6, More than a sum; Web Servers lesson 10, Interpreting request headers.
Learn to love deriving: deriving strategies, stock deriving extensions, the via strategy, and why instance deriving is important when using monad transformers.
Coupons for Finding Success
Everyone who has an active Type Classes subscription as of today can get the book for free on Leanpub; check your account page under the section entitled “Leanpub coupons”. The link can be used twice, so you can give a copy to a Haskell-curious friend.
Underscores and request parsing
We’ve released Web Servers lesson 9, Parsing requests, which continues our study of HTTP and gives a practical introduction to Attoparsec. We also continue to show how to ask GHCi for help with guides for using the beloved typed holes feature, all the uses of underscores, and warnings related to unused values.
Rigid types and block arguments
Type Classes now supports annual subscriptions and country-based discounts. We’ve added pages on rigid type variables and BlockArguments.
Stripe Haskell packages
This week we made some billing changes: There’s now an annual billing option in addition to monthly, and we now offer region-based discounts. We also took some time to publish a lot of the code that we use to work the Stripe API. You can find the code in the typeclasses/stripe repository on GitHub.
Covariance and GUIs
This week, more reference pages and new lessons in two of our ongoing courses! Topics include: Threads, levity polymorphism, pattern type signatures, bimap, POSIX signal handling, drawing with Cairo.
Clock and reference
We start our new series, Timepieces, with getting started with fltkhs. In Functortown lesson 4, breaking the laws!, Julie introduces using the Hedgehog library. We also have an overview of parsing libraries, an intro to concepts related to primitives, and more reference pages.
Almost Time
This week we released the third lesson in Functortown, Laws and orders, and the eighth lesson in Web Servers, The Never-ending response, and announce the beginning of a new course.
The Lessons Continue
This week we released the second lesson in Functortown, More common functors, and the seventh lesson in Web Servers, Chunking the message body.
A New Course Begins
This week we are beginning the Functortown course, a complete introduction to all kinds of functors. We also have added two new lessons in the Web Servers course since our last blog post, and we added a site index so the tags on posts are now clickable!
Intro to Template Haskell
Our first Template Haskell article focuses on one narrow use case: Compile-time evaluation of constant expressions. Because we care dearly about avoiding sources of runtime errors wherever possible.
We’ve restructured the site to make it easier to find content, added two JavaScript articles (one, two), and published some packages to Hackage. What’s next: Starting the Functortown course and continuing the Web Servers course.
GHCi helps those who help themselves
Julie presented a workshop on maximizing the useful information you can get from GHCi. It wasn’t recorded, but we’re working on getting all that information onto the site for our subscribers.
The various forms of Text and ByteString
Check out our new Haskell tip, entitled Strict, lazy, and builder – It covers the various string types in the text and bytestring packages.
C∘mp∘se :: Melbourne
Julie gave the keynote at C∘mp∘se :: Melbourne and we launched our new career as Haskell pamphleteers!
Web servers course
We’ve started releasing the web servers course, which will explain a lot about HTTP and how to write network applications in Haskell.
Finishing the first course
I chose the “Validation” course to be our flagship course on Type Classes because it’s material I’ve tested with meetup groups. Taking the same starting point as one of my more popular blog posts, it successively refactors relatively simple code until we’ve learned about several of Haskell’s most important features.
Video player improvements
We’ve added additional video formats, so videos should now be working on most devices. This post includes some details on how the HTML <video> tag supports multiple formats and how we generate DASH and HLS encoded versions of our videos.
Videos from Haskell Summer School
Haskell Summer School has wrapped up, and we are back to work. Recordings of our classes are available.
ZuriHac and Monadic Party
Julie just taught the beginner Haskell track at ZuriHac, and this week we are both teaching classes at Haskell Summer School in Poznań, Poland.
[Announcement] Prepare for launch
We are in the final stages of editing the initial course and project, and that content is starting to go live.
[Explainer] Function pipeline monoid
“A monoid is a pipeline of functions”? Be careful not to get lost in a particular example for a typeclass.
[Announcement] What to Expect from Type Classes
Since our initial Type Classes announcement, we’ve been asked a number of questions about payments and planned content. Find out what’s available now, when we’ll start taking payments, and what you can expect as a subscriber.
[Announcement] Type Classes are Born
On February 24, 1988, Philip Wadler introduced the idea of type “classes” for Haskell, as a solution to the problem of overloading. Thirty years later, we present Type Classes: a series of focused video courses on Haskell, Nix, and related subjects.