These sound like dismissals or absurdities from the outside, but once you learn what they really mean, they take on a new light. In this article, I want to explain the third. (See the appendix if you are curious about the first two.)
Write You a Haskell ( Stephen Diehl )
Implementing a Hindley-Milner Type System (Part 1) | Blog
First part of a tutorial on implementing a Hindley-Milner type system for a simple, purely functional programming language in Haskell. We go over syntax representation, how the Hindley-Milner type system is defined, polymorphism vs. monomorphism, generalization, and instantiation.
Profunctor Optics, a Categorical Update
Optics are bidirectional data accessors that capture data transformation patterns such as accessing subfields or iterating over containers. Profunctor optics are a particular choice of representation supporting modularity, meaning that we can construct accessors for complex structures by combining simpler ones. Profunctor optics have previously been studied only in an unenriched and non-mixed setting, in which both directions of access are modelled in the same category. However, functional programming languages are arguably better described by enriched categories; and we have found that some structures in the literature are actually mixed optics, with access directions modelled in different categories. Our work generalizes a classic result by Pastro and Street on Tambara theory and uses it to describe mixed V-enriched profunctor optics and to endow them with V-category structure. We provide some original families of optics and derivations, including an elementary one for traversals. Finally, we discuss a Haskell implementation.
Co-Creator of Haskell: Functional Programming, Thinking in Types, Useless Languages | Simon Jones
Is Haskell the right language for teaching functional programming principles?
The “park bench” panel at the Haskell eXchange last week talked about a lot of things, but some of them can be summarised by the question ...
Slim Lim: "Concrete syntax matters, actually"
Abstracting Definitional Interpreters
In this functional pearl, we examine the use of definitional interpreters as a basis for abstract interpretation of higher-order programming languages. As it turns out, definitional interpreters, especially those written in monadic style, can provide a nice basis for a wide variety of collecting semantics, abstract interpretations, symbolic executions, and their intermixings. But the real insight of this story is a replaying of an insight from Reynold's landmark paper, Definitional Interpreters for Higher-Order Programming Languages, in which he observes definitional interpreters enable the defined-language to inherit properties of the defining-language. We show the same holds true for definitional abstract interpreters. Remarkably, we observe that abstract definitional interpreters can inherit the so-called "pushdown control flow" property, wherein function calls and returns are precisely matched in the abstract semantics, simply by virtue of the function call mechanism of the defining-language. The first approaches to achieve this property for higher-order languages appeared within the last ten years, and have since been the subject of many papers. These approaches start from a state-machine semantics and uniformly involve significant technical engineering to recover the precision of pushdown control flow. In contrast, starting from a definitional interpreter, the pushdown control flow property is inherent in the meta-language and requires no further technical mechanism to achieve.
Subtyping is Overrated - Caleb Meredith aka @calebmer at @ReactEurope 2018
Combinatory Logic
Explore combinatory logic, combinator birds, and tacit programming across different languages like BQN, J, APL, and Haskell.
GHC/Typed holes - HaskellWiki
Typed holes are a powerful feature in GHC inspired by Agda. But what are typed holes, and how do they help us write code?
Warnings for pattern matching
We examine the ML pattern-matching anomalies of useless clauses and non-exhaustive matches. We state the definition of these anomalies, building upon pattern matching semantics, and propose a simple algorithm to detect them. We have integrated the algorithm in the Objective Caml compiler, but we show that the same algorithm is also usable in a non-strict language such as Haskell. Or-patterns are considered for both strict and non-strict languages.
Darcs | Proceedings of the 2005 ACM SIGPLAN workshop on Haskell
We at Binghamton intend, at least for ourselves (and I believe Alberta at least expressed this interest) to abstract whatever we have that we feel we would be proud enough to make available to other people in printed form. We would hope by somewhere in ...
Null-tracking, or the difference between union and sum types
Functional programming features have been making their way into mainstreamlanguages lately, such as with new programming languages like Scala and Rust, ornew...
Functional programming with bananas, lenses, envelopes and barbed wire
We develop a calculus for lazy functional programming based on recursion operators associated with data type definitions. For these operators we derive various algebraic laws that are useful in deriving and manipulating programs. We shall show that all example functions in Bird and Wadler's “Introduction to Functional Programming” can be expressed using these operators.
Graphics and FPL: Porting a Haskell graphics framework to Rust (luminance)
I wanted to write that new article to discuss about something important I’ve been doing for several weeks. It’s actually been a month that ...