[Haskell-cafe] Issue 59 :: Haskell Weekly

Taylor Fausak taylor at fausak.me
Thu Jun 15 15:08:44 UTC 2017

 \   Haskell Weekly
\/\/ Issue 59


Welcome to another issue of Haskell Weekly! Haskell is a purely
functional programming language that focuses on robustness, concision,
and correctness. This is a weekly summary of what's going on in its

## Featured

-   Haskell on Android and iOS
    > With our framework, writing professional Haskell apps and games becomes a reality. In minutes one can have the complete toolchain and see the first app running on a phone or published on the online store. If you weren't considering using Haskell yet, we hope you soon change your mind.

-   Translating a C++ parser to Haskell
    > Recently I translated Nix's derivation parser to Haskell and I thought this would make an instructive example for how C++ idioms map to Haskell idioms. This post targets people who understand Haskell's basic syntax but perhaps have difficulty translating imperative style to a functional style.

-   The `ReaderT` design pattern
    > What many languages address via patterns, in Haskell we address via language features (like built-in immutability, lambdas, laziness, etc.). However, I believe there is still room for some high-level guidance on structuring programs, which I'll loosely refer to as a Haskell design pattern.

-   Front Row is hiring a senior backend Haskell engineer (ad)
    > Come change how 6.5+ million K-12 US students learn Math, Language Arts, Social Studies and more. Use data, advanced type systems, great product design and deep pedagogy to change lives.

-   10 things Idris improved over Haskell
    > This post describes some of the pleasant surprises you get trying out Idris, coming from the Haskell world. These pleasant surprises have nothing to do with the dependent typing features. They are simple yet impacting modifications, which improve the developer experience substantially.

-   Migrating text metrics to pure Haskell
    > text-metrics-0.3.0 is written in pure Haskell, almost as fast as the previous versions (especially for not very long inputs), and is more correct (we handle characters represented as two `Word16` values properly).

-   ZuriHac 2017 recap
    > This was my first time attending ZuriHac and it was too much fun --- will definitely be back next year! Big thanks to Jasper Van der Jeugt, Simon Meier, and all of the HSR folks that made the event happen. Props to the Haskell community too for being friendly and inviting.

-   Haddock markup quick reference
    > This page is a single-page quick reference for the markup used in GHC's Haddock documentation format. It doesn't list all the details of the format, just the basic markup, so for the vagaries and edge-cases of the syntax, it would be helpful to consult the Haddock user guide.

-   Haskell Summer of Code
    > The performance tests do two things: first, they make sure that when people change the compiler, they don't accidentally make it slower; secondly, they make sure that when people change the compiler, they don't accidentally make the generated code less efficient.

-   Use hpack
    > One of the remaining problems is that the `project.cabal` file is in a custom format. Custom formats are generally not good because you can't leverage the existing tools and free-ride other people's work.

-   Haskell taketh away: Limiting side effects for parallel programming
    > In designing parallel programming abstractions, taking away user capabilities is as important as granting them. In this talk, I'll explain the role of this idea in several different parallel programming libraries for Haskell, C++, and other languages --- spanning from shared memory to big data.

## Package of the week

This week's package of the week is generic-lens, a library that exposes
generic data structure operations as lenses.

## In brief

-   Binary instances for GADTs (or: RTTI in Haskell)

-   Data structures are antithetical to functional programming

-   Drive-by Haskell contributions

-   On friendly contributing policies

-   Taking a close look at lenses

-   Teaching Haskell for understanding

-   The Haskell Cast episode 14: Richard Eisenberg on dependent types

More information about the Haskell-Cafe mailing list