Eta in Practice: Working With Haskell Packages

Now we know we can integrate with Hackage pretty nicely. We’ll end with a practical tutorial on doing data transformations in Eta.

Example: Transforming JSON

Imagine you had a bug where you were measuring clicks and storing them as JSON and your math was wrong and you were off by 50 and your boss was yelling at you to get it fixed as soon as possible to get more accurate metrics. Well since you have Eta which makes data transformations simple, you roll up your sleeves and get going.

The way to do it in Haskell is to use the famous lens library, along with the lens-aeson library which provides specific lenses for working with JSON. Lenses are the power tool for making highly targeted updates to structured data in a strikingly succinct manner.

We’ll also prettify the JSON at the end to make the ouput a bit cleaner.

Follow along to get the Etlas project up and running!

1. Install Eta if you haven’t already.

2. Clone the eta-examples repository.

> git clone https://github.com/typelead/eta-examples

3. Browse to the 5-lens folder.

> cd 5-lens

3. Install all the dependent packages.

You can see the packages that are required by looking at the build-depends field of the lens-ex.cabalfile:

build-depends: base >=4.8 && <4.9
             , aeson
             , aeson-pretty
             , bytestring
             , lens-aeson
             , lens

To install the dependencies automatically, run

> etlas install --dependencies-only

4. Run the code.

The code is shown below:

Line 1: This declares the module.

Line 3–7: Imports the relevant modules that contain the functions that we’re going to use.

Line 9: The main function is the entry point for an Eta program. The function has type IO () which means it performs input/output and will eventually run () (pronounced as “unit”) which is equivalent to returning void or nothing in other languages.

As you can see, there’s a clear separation of code that performs real work vs code that just computes something. This will make things tremedously simpler when you start getting into concurrency and makes it more modular and testable as well!

Line 10: We start a do block with the dokeyword that is indentation-based, which means that we must put all the sub expressions inside the block at the same indentation level, beyond the current one, as shown above.

This is where we can perform I/O.

Line 11: The let keyword allows you to define bindings or immutable values. In this particular line, we define the jsonbinding that’s a simple string. This is also indentation-based you can define multiple bindings at the same indentation level.

Line 12: We define the json'binding which stores the updated json that fixes the mistake. It uses the concept of lenses. Lenses allow you to zoom into the exact portion of the data structure you want in a type-safe way that composes. This means that you can combine multiple lenses zooming in more and more after each combination using the . operator which just so happens to be plain old function composition!

In a language with a powerful type system and global type inference, you would hardly know that you’re even programming in a statically typed language!

The values . members . _Integral is the composite lens which zooms into each of the array elements, zooms into the values of the objects, and tries to see if the value is an integer or not. The %~ operator means that the lens provided to the left should be updated with the function provided on the right (add 50).

Line 14: We use the case expression to evaluate the expression between the case and the of— in this case (no pun intended) we’re doing to decode the string into a JSON. And if you haven’t guessed yet, this is also indentation-based.

Line 15: If the decoding worked (which it obviously will in this case), this branch will be taken and it’ll perform I/O by printing out the prettified JSON.

Note: The $ simply means to apply the function on the left to the argument on the right, so a $ b $ c = a (b (c)) — it’s a trick to avoid lots of parenthesis.

Line 16: If the decoding failed, this branch will just print out “Bad JSON!”

Ok, now that we have a basic understanding of what’s going on, let’s run this and see what happens.

> etlas run
[
    {
        "clicks": 51
    },
    {
        "clicks": 52
    },
    {
        "clicks": 53
    }
]

Great! That’s some pretty JSON.