Welcome to another issue of Haskell Weekly! Haskell is a safe, purely functional programming language with a fast, concurrent runtime. This is a weekly summary of what’s going on in its community.
This is the kind of problem that scalendar approaches — namely, managing availability over time for a set of identifiers (which represent resources), where the availability varies according to the state of a calendar that is affected by the history of reservations previously performed.
I saw this article comparing Ecto and ActiveRecord. I thought I would track alongside that post and show what the equivalent code looks like if you’re using the Persistent Haskell library.
I wrote this post to challenge basic assumptions that people make about software architecture, which is why I chose a deliberately provocative title. You might not agree with all the points that I am about to make, but I do hope that this post changes the way that you think about programming.
Ideally, whether we are using Template Haskell or Generics, we would like automatically derived code to be as fast as code we could have written and optimized manually. To understand what it takes to achieve such a result, I’ve recently started to work on the performance of Aeson, a JSON library in Haskell.
We gain some useful things when we have referential transparency. And what do we lose? When I started doing functional programming, I assumed there must be some trade-offs, because trade-offs in programming are so common.
This blog post explains how the Servant libraries are used to create a non-trivial type-safe HTTP/WebSockets client and discusses the efforts involved.
We’ll construct our API using the Servant library. Servant involves some advanced type level constructs, so there’s a lot to wrap your head around. There are definitely simpler approaches to HTTP servers than what Servant uses. But I’ve found that the power Servant gives us is well worth the effort.
Yes, this is a yet another “write you a language”. But this one is a little bit different. First, the language I’m going to implement is rather different from languages you used to see in such tutorials. Second, I have little experience in creating programming languages, so a lot of things will be new to me as well.
With functor oriented programming, one divides data structures into layers of functors that, when composed together, form the data structures that your program operates on. Instead of writing transformations between data structures, one writes natural transformations between functors.
Haskell is quite a bit different when it comes to control structures for directing your program flow. In this post, I want to focus on the difference between if-then-else, case expressions, and guards.
We need someone with a strong Haskell background to help maintain and develop new features across our PostgreSQL-Haskell-React stack. We have a stable backend written in Haskell, that interfaces with PostgreSQL using hpqtypes, with a dash of Java for manipulating PDFs. Scrive is the Nordic market-leading provider of electronic signatures.
- Call for contributions: Haskell Communities and Activities Report
- Edward Kmett: Monoidal parsing
- Growing a date picker in Reflex: Part 1
- Higher-order abstract syntax for Cartesian closed categories
- Making your brain tingle: Explaining monads
- micro-ci: A tiny CI server built around GitHub and Nix
- Monads in minutes: What are monads and why are they used?
- Recursion schemes, part IV: Time is of the essence
- Review: Bananas, Lenses, Envelopes and Barbed Wire
- Scry: An Atom package for de-emphasizing qualified identifiers
- What is new in cross compiling Haskell
Package of the week
This week’s package of the week is hasql, an efficient PostgreSQL driver and a flexible mapping API.
Call for participation
- liquidhaskell: Importing infix annotations
- smooch: Make it easier to test set uploads in development
- stack: Nix integration should use GC roots
- October 12 – 13: Haskell eXchange 2017
- October 15: Berlin Functional Programming Group
- October 16: Vancouver Functional Programmers
- October 17: Austin Haskell Users Group
- October 18: Atlanta Functional Programming Meetup
- October 19: San Diego Functional Programmers
- October 26 – 28: Haskell in Leipzig 2017