What's new
Seq and complexity
We’ve added a page on `Seq` and an explanation of the basics of time complexity.
The final Applicative episode
Applicative lesson 11, identity and interchange, is up!
Homomorphism, and Applicative lesson 10
Applicative lesson 10, homomorphism and composition, is now available. As I mentioned yesterday, these lessons have taken a lot of work to organize. The turning point for me, what made everything fall together into a coherent story, is realizing that we can view homomorphism as the central concept for all four laws.
Functortown continues
I am very pleased to announce the release of lesson 9 of the Applicative series. In this lesson, we write property tests for the Applicative laws using Hedgehog. This episode includes a refresher on how to combine Hedgehog generators, and along the way we get to see some fun stuff like ambiguous type signatures and rank-N types. We write properties for three of the four laws, leaving the interchange property as an exercise. At the end of the lesson, we have a Hedgehog property group that we will use in the next two lessons to give a thorough discussion of what the laws mean and examples of what it means to break them.
New: The Alternative class
The Alternative typeclass is the last episode in our series on monoids.
Featured function: toIntegralSized
Another function we love: toIntegralSized, a safe way to convert between all the various types of whole numbers.
Free book for subscribers
As our latest Joy of Haskell monograph, Sockets and Pipes, is nearing completion, we have released the coupon that enables all Typeclasses members to download the book for free.
Search!
We’ve added a search page to help you find what you’re looking for on Type Classes. It uses the
New videos: Tweet history project
Last month we quietly released the Tweet history project, a series about reading CSV files in which we rewrite a program …
Exaggerating the negatives
A disturbing perspective pervades the practice of programming. “Everybody writes garbage code.”
Fixing a broken cabal update
I was having trouble running `cabal update` on my machine and, having figured out a solution using Nix, thought I should write the solution down.
Here we show you some boring Haskell, a shell script to generate some files we need to build a project.
We now offer a free introduction to Haskell crash course with video and full transcriptions available for each lesson. We have presented this course twice at ZuriHac and decided to make it permanently accessible here on our web site.
New in Functortown: An applicative Map
In this lesson we look at why an important data structure called Map is not a valid instance of Applicative. We…
The Interactive Compiler
This series gives a comprehensive introduction to basic GHCi commands and usage.
The Compose newtype
In this addition to the Applicative section of the Functortown series, we continue our discussion of applicative functor composition by…
Introduction to GHC Extensions Series
This series begins with an introduction to GHC extensions, what they are and how to use them. That page is connected to a series …
We’ve expanded the partial type signatures lesson. It discusses what kinds of things can be inferred with the extension, …
New lesson in the Applicative series: Applicatives compose
After a brief look at `IO` as an applicative functor, we explore what it means that functors compose, paying special attention to the …
New lesson in the GHCi series: :main and :run
The :main command in GHCi runs your program’s `main` action. But did you know that you can also pass it command-line …
New Phrasebook entry: Folding lists
Folding: A common task, and a common first step on the road to thinking functionally! Thanks to Jesus E. …
Stack and Nix
While Chris has previously written about the ways in which Stack and Nix are competing tools, we’ve found ourselves a few times using Stack and Nix, together.
New Phrasebook entry: A monitoring server
A monitoring server demonstrates using queues to communicate between threads, and using sockets to communicate between …
Applicative lesson 5: The Reader context
The Applicative series continues its study of the notion of applicative functors as contexts for …
New Phrasebook entry: Moments in time
A lot of software has to deal with time in some form or another. Moments in time covers basic parsing and …
Atypical data constructors
We’ve been giving a lot of thought lately to how to present some of the more exotic language
We’ve added two new lessons to the the Validation course, thus making all of the book’s content available to Type Classes members. One lesson is about using `coerce` safely and effectively for `newtype`-heavy code, while the other is an introduction to the `lens` library through the prisms in the `validation` package.
New lessons in two courses!
This week, we’ve added content to two of our courses, Functortown and Validation. The Functortown lesson is called Zippy
New posts in the Phrasebook and the GHCi series
We’ve received a number of great Hacktoberfest contributions to the Phrasebook. So far, we’ve added two new pages of free …
Happy Hacktoberfest!
We have decided to open the Haskell Phrasebook to community contributions. We especially encourage contributions from people who have never contributed to a Haskell project before but would like to.
New Phrasebook entry: Inverting functions
Often we find ourselves needing a pair of related functions: 1. to encode some simple sum type as a …
New Phrasebook entry: Dynamic typing
In Haskell, all types are known statically at compile time. Or are they? We don’t use `Dynamic`, but …
New Phrasebook entry: Cryptographic hashing
Since we had a Phrasebook entry for the hashable library, it seemed appropriate to add a page on cryptonite to …
New lesson of Functortown
Functortown is back with a lesson on the rest of the `Applicative` class, the two “bird operators,” `(<*)` and `(*>)`. Through three examples, we explore the sequencing…
Python iterators: A Big Finale
Today we add five new pages to the series on iterators, bringing the total up to 11 pages and …
Featured function: Rounding
The standard library for GHC Haskell includes at least four functions that perform a basic function …
Haskell art: A really magnificent Mandelbrot
The header art for the Validation course depicts a portion of the Mandelbrot set. We’ve written a lengthy discussion of the Haskell code …
We are excited to announce The Haskell Phrasebook. Taking an approach similar to Go by Example, it emphasizes how to get started writing programs quickly. In a departure from our usual style, this project does not explain everything in full detail; the Phrasebook’s role is only to be a traveler’s starting point and quick reference.
Using Nix as a Makefile
One of our first video series was about how we run Type Classes on Amazon EC2 using NixOS. We’re starting to expand our Nix
You may have noticed some recent colorful additions to our page headers, such as on the Validation and Web
Semirings!
The reference series on algebras that began with Semigroup has escalated to Semiring. We’ve given the semiring page …
Python data classes and Haskell records
This Python lesson discusses a decorator called `dataclass`. The primary role of a Python data class is to simply hold the values that …
A spoonful of Enum
We’re writing the Python course in a slightly different style from most of Type Classes, because it is aimed at a more focused audience. The idea is that if you are already familiar with Python, then we want to leverage as much of your existing Python knowledge as possible as you learn Haskell. For example, we’re not including quite as many type signatures in our explanations as we normally would, and we defer the introduction of some aspects of Haskell to minimize the amount of patience required if you just want to answers to questions of the form ‘I know how to do this thing in Python; how do I do it in Haskell?’ This post is about one particular small choice regarding range syntax.
The `zip` function in Python and Haskell
The latest Python lesson is all about zipping, a notion also sometimes referred to as aligning. We discuss three Python functions: `zip`,…
Our one-year anniversary celebration
Type Classes has been in business for a year. To celebrate and share our success, annual memberships are half-off through June 30.
Forward and back buttons
New: Monoid
A monoid is a type along with a binary associative operation and an identity element. We’ve written a …
Update: Using wildcards in type applications
Our guide to the many uses of underscore has been amended to include its usage with the type applications extension, which does…
New: `map` in Python and Haskell
The Python course continues with a discussion of `map` (with one iterator argument, or with multiple) and …
Update: Semigroup newtypes
We added documentation for the newtypes in the `Data.Semigroup` module, and with that the semigroup page is …
New: itertools.chain
To concatenate two Python iterators, we use `chain`. The corresponding Haskell function is `(++)`. The `chain`
New: Iteration to infinity in Python
The latest lesson in the Python course is about functions that produce simple never-ending iterators. The ability to represent concepts like “counting upward from one” and “repeating an item ”…
New: Iterator slicing in Python
We previously discussed in the iterators lesson how Python iterators relate to Haskell lists. If you’re …
New: Semigroup
A semigroup is a type together with a closed associative binary operation.
Python and the Monoid in the Applicative
We’ve added an article comparing Python iterators to Haskell lists. There’s also a new lesson of Functortown. Lesson 9, You got monoids in my functors!, goes further into Applicative functors. This lesson is supplemented by a reference page on Semigroup.
Applicative
This week’s theme is applicative functors. The eighth lesson of Functortown is called Mapping a Maybe function; it starts off with a concise practical example that brings the `Maybe` applicative to our attention. We’ve also written the reference page on the `ApplicativeDo` extension.
Web Servers lesson 13
The thirteenth and final lesson of the Web Servers course is out today! It introduces `pipes`. Our latest featured function is `null`.
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 `ByteString`s.
Coercion and datatype contexts
Two new reference pages: A lengthy discussion of the coerce function, what it’s for, and how to use `newtype`s more effectively; and a note of historical interest on datatype contexts which addresses a common beginner question about typeclasses.
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.
Course updates: Functortown lesson 6, More than a sum; Web Servers lesson 10, Interpreting request headers.
Deriving
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.
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!
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.
Restructuring
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.