Functortown continues its study of the notion of applicative functors as contexts for computation. Previously we talked about the
Functor for the function type – or, more precisely, for
(->) a, the partially applied function type. In this lesson we again discuss functions, this time looking at the
Applicative instance often referred to as reader.
A lot of software has to deal with time in some form or another. Moments in time covers basic parsing and conversion operations for UTC times and Unix timestamps. Thanks to Taylor Fausak for submitting this example code during Hacktoberfest!
We’ve been giving a lot of thought lately to how to present some of the more exotic language extensions – like GADTs, type families, and rank-N types – and we’ve decided to start by focusing not on the individual extensions one at a time, but rather with the more broad aim of “getting a more sophisticated understanding of the type system.” We still plan to make a reference page for each extension, but the more important place to start if you’re entirely unfamiliar with these features will be the new atypical data constructors series. It begins with a lesson on type equality constraints, which will then lead naturally into understanding what GADTs are and what they’re useful for.
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
This week, we’ve added content to two of our courses, Functortown and Validation. The Functortown lesson is called Zippy applicatives and discusses the two list applicatives: the normal one, and
ZipList. Second, as many of our subscribers are aware, we had turned the Validation course into a book, and we made that free to anyone who was subscribed to Type Classes at the time when we published the book. The book included two chapters that did not appear on the site, however. The first of those, now added to the course, is on
Coercible. We expect to add the final chapter next week, so all that content will be available to all our subscribers. Enjoy!
Courses are series about a particular topic meant to be watched in order. Some are more theory-and-fundamentals oriented, while some focus on building a project. Each course has clearly identified prerequisites and goals, to help you choose which courses are right for you.
Profunctor, with motivating examples and discussions of what each is good for, the laws governing each, and how to property test instances.
fltkhsand Chris using
gtk3. Each lesson explains aspects of the library, illuminates important Haskell concepts such as concurrency primitives and implicit parameters, and gives you some basis for comparing libraries for your own native GUI application projects.
Validationtypes brings, as well as using
newtypeto differentiate inputs. We also demonstrate the difference between
Each article explains a single, sometimes small, Haskell topic in detail. Some articles include video. Haskell reference pages supplement, but are independent of, the courses and projects. Haskellers of any level will find them useful as reference.
transformerslibrary and use it to illustrate type aliases, newtypes, and various approaches for typeclass deriving, using the
TypeApplicationslets you visibly apply functions to type arguments. We demonstrate several common use cases.
ScopedTypeVariableslets you extend the scope of a type variable over a whole function, including its subexpressions.
reduce), monoids, and identity values.
scotty, a Haskell web framework.
This section covers topics that aren’t about the Haskell language itself, but about software that helps you be more productive with it.
:typecommand and never be at a loss for knowledge of types