# Installing Obsidian in Ubuntu

All the steps, yes even *Profit!*, are required to install from scratch.

To do a manual update, when a new installer is required, only repeat steps 2 to 4.

1. Create a new directory in `~/Applications`

    ```
    $ mkdir ~/Applications/Obsidian
    ```

2. Download the latest `AppImage` from [obsidian.md/download](https://obsidian.md/download?os=linux&arch=x64)

3. Give the file execution permissions

    ```
    $ cd ~/Downloads
    $ sudo chmod +x Obsidian-1.3.4.AppImage
    ```

4. Move the file to the new directory

    ```
    $ mv Obsidian-1.3.4.AppImage ~/Applications/Obsidian/obsidian
    ```

5. Create a desktop file with the following contents and place it in `~/.local/share/applications/Obsidian.desktop`

    ```toml
    [Desktop Entry]
    Type=Application
    Name=Obsidian
    Comment="A second brain, for you, forever."
    Icon=/home/your-user/Applications/Obsidian/icon.png
    Exec=/home/your-user/Applications/Obsidian/obsidian
    Terminal=false
    ```

    NOTE: this also requires an icon saved in the same directory as the AppImage. It can probably  be ignored and it will show a default icon.

6. Validate that the file is correct and install it:

    ```
    $ desktop-file-validate ~/.local/share/applications/Obsidian.desktop
    $ sudo desktop-file-install ~/.local/share/applications/Obsidian.desktop
    ```

7. Profit!

    ![Obsidian installed in Ubuntu](https://photos.collectednotes.com/photos/63/d6bebe98-0ff2-4cbb-a1c7-00ab6b8d0cf1?x-amz-acl=public-read&X-Amz-Expires=3600&X-Amz-Date=20230525T094645Z&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIA5W2WJOHUP7IHVD6I%2F20230525%2Fus-west-2%2Fs3%2Faws4_request&X-Amz-SignedHeaders=host&X-Amz-Signature=3b9a7ca18aedefc3ae523d410dde815e5fc5564df07f8c2a8e8f65f6d7de7a57)

For more information or questions refer to the forum: [How to use Obsidian AppImage](https://forum.obsidian.md/t/meta-post-linux-tips-tricks-solutions-to-common-problems/6291/3)

All the steps, yes even Profit!, are required to install from scratch.

To do a manual update, when a new instal...

Installing Obsidian in Ubuntu

# Muchachos, ahora nos volvimo' a enloquecer

```
En Argentina nací, tierra de Diego y Leonel
De los pibes de Malvinas que jamás olvidaré
Las finales que perdimos cuántos años las lloré
Pero eso se terminó porque en ahora en Qatar
La final con Mbappe la volvió a ganar papá

Muchachos, ahora nos volvimo' a enloquecer
Porque ganamos la tercera, porque somo' campeón mundial
Y al Diego, en el cielo, lo podemo' ver
Con don Diego y con la Tota, celebrandolo a Leonel

Muchachos, ahora nos volvimo' a enloquecer
Porque ganamos la tercera, porque somo' campeón mundial
Y al Diego, en el cielo, lo podemo' ver
Con don Diego y con la Tota, celebrandolo a Leonel

Somos campeones otra vez
Somos campeones otra vez
```

Muchachos, ahora nos volvimo' a enloquecer
En Argentina nací, tierra de Diego y Leonel
De los pibes de Malvinas que jamás olvidaré
Las final...

Muchachos, ahora nos volvimo' a enloquecer

# Recap of the state management history in React

![DALL·E 3 prompt: Sharp digital depiction of React's state management journey. Starting from the left, a rising sun over a simple landscape represents React's early days. Organized pathways with junctions symbolize Flux, which then merge into a cityscape of interconnected buildings for Redux. A hovering constellation of interconnected celestial bodies embodies GraphQL with Apollo and Relay. Glowing lantern chains signify Hooks, and densely packed atomic orbs represent the newer atomic hooks. The scene culminates with a swirling portal on the right, encapsulating SWR hooks' integration. The artwork is bathed in gentle pastel hues.](https://photos.collectednotes.com/photos/63/24d4ee4f-9850-4cf7-a347-623da81c455f?x-amz-acl=public-read&X-Amz-Expires=3600&X-Amz-Date=20231019T160852Z&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIA5W2WJOHUP7IHVD6I%2F20231019%2Fus-west-2%2Fs3%2Faws4_request&X-Amz-SignedHeaders=host&X-Amz-Signature=42322f5a4c6f69538d271d0b2a398bdf9c11c3afaf91f5ac86d70f677fa00d6d)

> This post was originally a note on my [Digital Garden 🌱](https://publish.obsidian.md/gillchristian)

**Disclaimer**: this is wildly inaccurate, I’m just writing it down from memory as a recap of where we came from to better understand where we are at today and what could come next.

## Wild West

When React was first introduced it was advertised as the V in MVC. For those that don’t know, MVC stands for Model-View-Controller, in other words, React’s initial concern was only about the view.

These were the days of `createClass`. See [React Without ES6](https://reactjs.org/docs/react-without-es6.html) if you have no idea what I’m talking about.

People were using React as the view layer on top of other frameworks like Backbone or even Angular.js 🤪 My guess is even Facebook had no idea what to do about state in React those days.

Two way data binding and DOM mutations were the way people managed state updates at the time.

## Flux

Then came [Flux](https://facebook.github.io/flux/).

> Application Architecture for Building User Interfaces

Yay we were saved! There was finally a way to manage state for React applications that made sense.

The problem with Flux is at the moment it was only an architecture pattern, there was no library. You had to build your own. I remember using [bloody-flux](https://www.npmjs.com/package/bloody-flux/v/1.0.0) for an small side project. Which turns out is still up an running on GitHub Pages: http://gillchristian.github.io/patriarchs-timeline.

## Time travel 🚀

Then Dan Abramov [introduced Redux on react-Europe 2015](https://youtu.be/xsSnOQynTHs) 🤯

Redux [took some really cool ideas](https://redux.js.org/understanding/history-and-design/prior-art) and brought them to React. And together came the possibility of fancy tooling. I remember the first time I tried time travel debugging, it was so cool! Your Angular.js application couldn’t do that!

Around the same time some other state management alternatives, like MobX, started to show up.

Redux itself became a whole thing, it inspired other frameworks like Vue and Angular to adopt similar patterns.

Since it was a relatively low level tool, just like React, that gave a lot of freedom to the user to find different ways to make it work for them. In particular when it came to async operations Redux itself gave no official solution. The most popular options are [redux-thunk](https://github.com/reduxjs/redux-thunk), [redux-observable](https://redux-observable.js.org/), and [redux-saga](https://redux-saga.js.org/). There were probably a dozen more options out there.

The problem with Redux was how verbose it could get to have all your state in there. And messing up the performance of the application was relatively easy as well.

## GraphQL as state management?

Then another technology from Facebook showed up and became popular. The hype was real, GraphQL would save us! From the perfectly fine and working RESTful approach to developing APIs that is.

With the GraphQL revolution people realized that for plenty of applications data fetching is so coupled with state management that it was probably a good idea to marry the two into a single ~~abomination~~ solution. And thus [Apollo](https://www.apollographql.com/) and [Relay](https://relay.dev/) showed up.

GraphQL never seemed like a great thing to me, probably because I never faced the problems it’s meant to solve. And so I never got into Apollo or Relay, so that’s all I can say. ¯\\\_(ツ)_/¯

## Hook me up, would ya?

Up until this point people would swear by the separation between [presentational and container components](https://medium.com/@dan_abramov/smart-and-dumb-components-7ca2f9a7c7d0), also called dumb and smart components.

The idea was that some components should care only about the presentation and others about the logic. Presentational components would not have any kind of logic or state and concern not with the model of the application, after all they were truly dumb. Container components, on the other hand, were the smart ones, all the state, interactions with the model, subscription to Redux, etc. would happen there and they would just render a single presentational component.

In other words, separation of concerns. Problem was people took it very seriously, I’ve had PR rejected and blocked because a component that was rendering a piece of UI also had some local state in it, say a toggle, that had no effect in the rest of the application. As you can see I’m still salty about it 😂

At this point hooks showed up and the line started to blur, a lot, to the point there was no line anymore. Hooks made it super easy to reuse logic and any component that needed that logic could use it. There’s still a need for highly reusable presentational components, of course, but nobody talks about containers anymore.

With the introduction of hooks and the PTSD people suffered from how verbose Redux can become devs started to write more and more local state.

There was no need to convert a functional component to a class to add state, that, I think, is what made the whole difference. There was no friction, only a `useState` away from it.

However local state is not a silver bullet. Nothing is, besides actual silver bullets, those used to kill a werewolf or witch.

The problem with local state, whether it is with hooks or not, is that whenever another part of the application that isn’t down the three where the state is defined needs that piece of state it forces the state to be moved up to a common parent.

It is not possible for `X` to access the state defined in `A`.

![react component tree state dependencies](https://photos.collectednotes.com/photos/63/c8214f14-1d3b-4212-b43f-e650292be247)

Instead we have to move the state up to a common parent.

![react lift state](https://photos.collectednotes.com/photos/63/e38ecc28-0928-4527-a211-1accc084c19e)

Do this process several times and you are suddenly longing for Redux again.

Context does solve this problem, but just like Flux, it’s a very low level solution and defining context by hand tends to be messy and verbose. *Ain’t nobody got time for that!*

## Going Atomic

This is when solutions like [Recoil](https://recoiljs.org/) and [Jotai](https://jotai.org/) come into play. The elevator pitch is: *imagine if `useState` was global*.

By defining this *atom* data structure one is able to share state between different parts of the component three without the need to lift state up to the common parent.

Boom 💥 any component can access the same state!

![react use atom](https://photos.collectednotes.com/photos/63/c58bb5a2-da55-4a3f-be34-c3b5e3b4c82e)

If I’m not mistaken these [ideas of *atoms* come from Clojure](https://clojure.org/reference/atoms).

## State is a job for the ~~feds~~ fetching

Remember coupling the state management and data fetching layers together? Turns out that we don’t need GraphQL for that.

Libraries like [react-query](https://react-query-v3.tanstack.com/) and [SWR](https://swr.vercel.app/) offer a very thin layer around data fetching that is able to manage your state as well. Or at least the state that has to be fetched from some remote location.

This approach can be seen as an inversion of control, instead of having the state management layer take care of the data fetching in some way or another, we now have the data fetching layer taking care of the state.

By leveraging caching strategies, like `state-while-revalidate` (that’s where SWR name comes from), this libraries can return (stale) data quickly and swap it for the fresh one once the new request resolves.

From [SWR](https://swr.vercel.app/) docs:

> With SWR, components will get a stream of data updates **constantly** and **automatically**. And the UI will be always **fast** and **reactive**.

From [react-query](https://react-query-v3.tanstack.com/) docs:

> Fetch, cache and update data in your React and React Native applications all without touching any "global state".
> 
> React Query […] in more technical terms, it makes **fetching, caching, synchronizing and updating server state** in your React applications a breeze.

## What’s next?

I don’t know what interesting, revolutionary, and wheel-reinventing pattern will become popular next. But all we can do is wait and be ready to rewrite our applications when that happens.

Or, maybe, come up with another pattern ourselves to speed up the process 😎

DALL·E 3 prompt: Sharp digital depiction of React's state management journey. Starting from the l...

Recap of the state management history in React

# Generic discriminated union narrowing

![DALL·E 3 prompt: Sharp digital drawing symbolizing the concept of 'Generic discriminated union narrowing' in TypeScript. The left side showcases various geometric shapes, each representing a different data type or union. As we move to the right, a funnel structure appears, narrowing down and filtering these shapes into a single, refined form, illustrating the process of narrowing. This transformation is accentuated by interconnected lines and nodes, highlighting the connections and relationships. Soft pastel colors provide a harmonious backdrop, underscoring the elegance and precision of TypeScript's capabilities.](https://photos.collectednotes.com/photos/63/fdbb62a3-5149-47ef-bbff-3363c32dad3f?x-amz-acl=public-read&X-Amz-Expires=3600&X-Amz-Date=20231019T161419Z&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIA5W2WJOHUP7IHVD6I%2F20231019%2Fus-west-2%2Fs3%2Faws4_request&X-Amz-SignedHeaders=host&X-Amz-Signature=b8f6876eca2b9addfc976a68f378c28d8155531918258175e43013b904f5a4fe)

> This post was originally a note on my [Digital Garden 🌱](https://publish.obsidian.md/gillchristian)

When working with discriminated unions, also known as tagged unions, in [TypeScript](https://publish.obsidian.md/gillchristian/Research/TypeScript) one often has to narrow down a value of the union, to the type of one of the members.

```ts
type Creditcard = {tag: 'Creditcard'; last4: string}

type PayPal = {tag: 'Paypal'; email: string}

type PaymentMethod = Creditcard | PayPal
```

Given the above type, we would want to either check that a value is of PayPal type to show the user's email or Creditcard type to show the last 4 digits.

This can be do simply but checking the discriminant property, in this case `tag`. Since each of the two members of the `PaymentMethod` type have different types for the `tag` property, TypeScript is able to, well, discriminate between them to narrow down the type. Thus the *tagged union* name.

```ts
declare const getPaymentMethod: () => PaymentMethod

const x = getPaymentMethod()

if (x.tag === 'Paypal') {
  console.log("PayPal email:", x.email)
}

if (x.tag === 'Creditcard') {
  console.log("Creditcard last 4 digits:", x.last4)
}
```

To avoid this explicit check of the `tag` property you might define [type predicates](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates), or guards.

```ts
const isPaypal = (x: PaymentMethod): x is PayPal => x.tag === 'Paypal'

const x = getPaymentMethod()

if (isPayPal(x)) {
  console.log("PayPal email:", x.email)
}
```

The problem with such guards is they have to be defined for each member of each discriminated union type in your application. Or *do they*?

If you are like me you probably wonder how to do this generically for all union types. Could this be even possible with some TypeScript type level black magic?

The short answer is yes.

```ts
const isMemberOfType = <
  Tag extends string,
  Union extends {tag: Tag},
  T extends Union['tag'],
  U extends Union & {tag: T}
>(
  tag: T,
  a: Union
): a is U => a.tag === tag
```

The proper response is, what the ~~f\*ck~~ ~~heck~~ hack?

Ok, let me explain.

We need four generic types, in practice the caller will not need to pass these, they are there with the purpose of allowing TypeScript to do its type inference business.

Notice that for all of them we are not allowing any type but instead using `extends` to inform TypeScript that those generic types should meet certain conditions.

- `Tag` is the union of all the tags of `Union`, it should extend the base type of our tag, in this case `string`
- `Union` is our tagged union type, it has to be an object with a `tag` property of type `Tag`
- `T` is the specific tag we want to narrow down with, and thus it should extend the `Tag` type
- And `U` is the specific member of `Union` we want to narrow down to, it should extend the `Union` and its tag should be `T`, the specific one we want

`Tag` and `Union` are there to define the union type we want to narrow down from and `T` and `U`, for the ~~lack~~ laziness of finding better names, are where the magic happens since they are the narrowed down types we expect to get to.

```ts
const x = getPaymentMethod()

if (isMemberOfType('Creditcard', x)) {
  console.log('Creditcard last 4 digits:', x.last4)
}

if (isMemberOfType('Paypal', x)) {
  console.log('PayPal email:', x.email)
}
```

*Et voilà*, it works!

![inferred creditcard type](https://photos.collectednotes.com/photos/63/7529fd81-1138-4360-a81a-c87d65fbd4bd)

And this is how TypeScript fills in the *holes* of the generics.

![inferred type arguments](https://photos.collectednotes.com/photos/63/ff441eb1-e044-4e22-97b1-2821742c1452)

There's a variation of `isMemberOfType` that I like to use which works as a sort of getter instead of type predicate.

```ts
const getMemberOfType = <
  Tag extends string,
  Union extends {tag: Tag},
  T extends Union['tag'],
  U extends Union & {tag: T}
>(
  tag: T,
  a: Union
): U | undefined =>
  isMemberOfType<Tag, Union, T, U>(tag, a) ? a : undefined
```

The usage is similar, but it requires a null check, of course.

```ts
const cc = getMemberOfType('Creditcard', getPaymentMethod())

if (cc) {
  console.log('Creditcard last 4 digits:', cc.last4)
}

const pp = getMemberOfType('Paypal', getPaymentMethod())

if (pp) {
  console.log('PayPal email:', pp.email)
}
```

There’s a little problem, the inferred type it returns is not so nice, since it's based on our definition of the generic (`U extends Union & {tag: T}`).

![inferred returned type of getter](https://photos.collectednotes.com/photos/63/bf825eb9-a82c-490e-b893-9c835e7b5db7)

In practice this is not a problem, but since we got this far, we can keep going, right?

Enter [Extract<Type, Union>](https://www.typescriptlang.org/docs/handbook/utility-types.html#extracttype-union), one of TypeScript's type utilities:

> Constructs a type by extracting from `Type` all union members that are assignable to `Union`.

For example, in the following case `T0` will be of type `'a'`:

```ts
type T0 = Extract<'a' | 'b' | 'c', 'a' | 'f'>
```

The definition is simple:

```ts
// Extract from Type those types that are assignable to Union
type Extract<Type, Union> = Type extends Union ? Type : never
```

![slaps roof of car meme](https://photos.collectednotes.com/photos/63/204e9c1d-c050-433a-a583-be737ff70fe6)

With our current definition of `isMemberOfType` and `getMemberOfType`, the returned type extends union: `U extends Union & {tag: T}`.

In the case of PayPal it would be `PayPal & { tag: 'PayPal' }`. By adding `Extract` to the returned type we can get `PayPal` instead.


```ts
const isMemberOfType = <
  Tag extends string,
  Union extends {tag: Tag},
  T extends Union['tag'],
  U extends Union & {tag: T}
>(
  tag: T,
  a: Union
): a is Extract<Union, U> => a.tag === tag

const getMemberOfType = <
  Tag extends string,
  Union extends {tag: Tag},
  T extends Union['tag'],
  U extends Union & {tag: T}
>(
  tag: T,
  a: Union
): Extract<Union, U> | undefined =>
  isMemberOfType<Tag, Union, T, U>(tag, a) ? a : undefined
```

![better inferred return type](https://photos.collectednotes.com/photos/63/78d2280d-a28a-4be3-9cec-6e4bd264a615)

Much cleaner this way! Now I can sleep in peace …

In conclusion, we went from simple discriminant property check to a monstrosity of generics and type inference that achieves the same thing. Should you use these utilities in production? ~~Of course! Even more so if it will confuse our colleagues.~~ Maybe not, but it was fun to discover some of the cool stuff we can achieve with TypeScript.

[Here's the final version of the examples in the TypeScript Playground](https://tsplay.dev/NBRQbN).

DALL·E 3 prompt: Sharp digital drawing symbolizing the concept of '' ...

Generic discriminated union narrowing

# Stream, Season 2

![phone with twitch app](https://photos.collectednotes.com/photos/63/12d1781b-8bc8-45e1-8992-26ec7e08bde8)

A few weeks ago I started to stream again after taking a break for a couple of months. I'm now on Season 2 of the stream.

## Why?

I started to stream in 2020. Around May, if I remember correctly.

I remember back in 2015 I discovered programming streams, think it was on [livecoding.tv](https://blog.educationecosystem.com/livecoding-tv-watch-people-code-products-live/). I'd watch and think that one day I would stream myself. Took me a few years, but I did it xD

To be honest I don't even know why I decided to stream. What I do know is that as awkward as my streams are, I enjoy doing it.

## Season 1

Season 1 was random. Like a TV Show that producers aren't sure if there's going to be another season or not.

It was mostly about Functional Programming and doing whatever I felt like doing. I tried out a few things that never finished like [the Fantasy Land series](https://www.youtube.com/watch?v=EA9-Ov7kkfY&list=PLEhkZhBLBv83FdvJXb3p2XMSDXLx03uw0) and [working through books](https://www.youtube.com/watch?v=tuaP7Nn1Buw&list=PLEhkZhBLBv83fvFQ3XrM0o50UMGNGyHZW).

Here are some other things I did:

- Learn PureScript and build a few things with [Halogen](https://publish.obsidian.md/gillchristian/Knowledge/Halogen)
- A [tool to generate PureScript identifiers for all the Tailwind classes](https://github.com/gillchristian/tailwind-purs).
- Automate some of my stream setup ([gillchristian/strem](https://github.com/gillchristian/strem)). So meta!
- Build the UI of [Listas](https://publish.obsidian.md/gillchristian/Projects/Listas) with Halogen and Tailwind.

I also uploaded some of the [VODs to YouTube](https://www.youtube.com/channel/UCffp5zsEcCty7DVric3QEuw), which some people found very useful. I should probably do more of that.

Eventually I got tired of it, I figure because I had no goal in mind. Every week would be a new random thing.

And also, during this time I moved to a new place and have been busy with a ton of renovation projects, which make up a big chunk of my free time now. Maybe I should stream that?

## Season 2

Time passed by and I started to miss the stream. I felt like break was over. And so I decided to start again. Since I had quite some time to think about the stream, instead of you know, actually streaming, I realized that I need to set a goal for the stream. Or at least a theme to stick to. Something that would keep me motivated, hold me accountable, and give purpose to it.

While Season 1 was all random and doing whatever, Season 2 is going to be about figuring out what the hack do I want with my stream.

The main thing I'm changing already is the randomness of it. For the foreseeable future I will stick to a single project at a time. At the moment it is [therssproject](https://therssproject.com/). I'm not sure what will be next. But I do want to take a more *indie hacker* approach on my side projects from now on, and that will reflect on the stream as well.

I would like to grow my audience as well. The days I had the most fun on the stream where when people showed up and it wasn’t just me.

One recent thing that really got me inspired is [@ThePrimeagen](https://twitter.com/theprimeagen)'s video [Why I make Content](https://www.youtube.com/watch?v=7FsyXTMLPBY). I hope to be able to share that passion for programming as well!

See you on [twitch.tv/gillchristian](https://www.twitch.tv/gillchristian)! 


phone with twitch app

A few weeks ago I started to stream again after taking a break for a couple of months. I'm now on Season...

Stream, Season 2

# A day in the life of a software engineer

![DALL·E 3 prompt: atercolor artwork of a software engineer relishing a work-from-home day. The scene spans the entire canvas, depicting the engineer at a neat home desk, surrounded by bookshelves and a window that offers a glimpse of a tranquil outdoor setting. Adjacent to the desk, a comfortable couch invites relaxation during breaks. A fireplace radiates warmth in the room, and a fluffy Samoyed dog is curled up in a ball nearby, adding to the coziness. The composition is painted in soft pastel tones, emphasizing the serene and nurturing ambiance of a home workspace.](https://photos.collectednotes.com/photos/63/b9eec1c2-cef5-4db6-a597-9e10b021b511?x-amz-acl=public-read&X-Amz-Expires=3600&X-Amz-Date=20231019T162141Z&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=AKIA5W2WJOHUP7IHVD6I%2F20231019%2Fus-west-2%2Fs3%2Faws4_request&X-Amz-SignedHeaders=host&X-Amz-Signature=b1f790bae9ac645402c3254d5f03de7354e4d256c8bfa5a2513e7e0a3a095bf1)

What's like to work as a software engineer? In a nutshell you'll write code to solve problems and collaborate on meetings. Of course it's more complicated than that.

There are plenty of videos and articles on the internet about what the day of the a software engineer looks like. Instead of going doing yet another of those, I want to share what key aspects for me.

## Your mileage may vary

Although there are constants, software development jobs are all different. Some companies have more meetings than actual development time, some only communicate through documents ([like Gumroad](https://sahillavingia.com/work)), some emphasize the social aspects while others are just about work.

## Solving problems

Software engineering is about solving problems. That's it, that's the Tweet.

Technical problems like how to make a build tool work for your project's setup or optimizing the performance of an algorithm to be fast enough and product problems which always revolve about making a better experience for your users.

## Communication is key

Computers are the easy part. Humans and communication are the hard part. Learn to communicate. You will never work in completely isolation. There are clients, managers, colleagues from all sorts of domains, candidates to interview.

Communication involves listening and understanding what others are trying to say, and expressing yourself clearly so other can understand your point of view.

## Learning

Technology is always changing. That's a constant. Which means you'll never be able to stop learning. Those that embrace the constant learning do better.  [Learn how to learn](https://jamie.build/learning-how-to-learn.html).

## Flexibility & Opportunities

Software engineering, and tech in general, is a very flexible industry. Although some jobs lean more on the traditional 9 to 5 approach.

Maybe you want to only work 4 days a week, or prefer to start your day super early and have the afternoon free. You might want to work for a company that is doing some good impact in the world and resonates with you, you might want to move to another city, country or continent. There are plenty of opportunities in this field, find what works for you.

## Formalities

It's not all fun and games, there are boring parts of the job as well. It's a job after all. Filling reports, attending meetings that could've been and email. But since you are getting paid to do it ¯\\\_(ツ)_/¯

DALL·E 3 prompt: atercolor artwork of a software engineer relishing a work-from-home day. The scene spa...

A day in the life of a software engineer

---
path: bible-notes-idea
---

# Idea: Aplicación para notas bíblicas

![empty notes](https://photos.collectednotes.com/photos/63/73f7dc3e-699b-4984-9f3e-1dd7be1d42b9)

![first note](https://photos.collectednotes.com/photos/63/a255f930-f124-4c22-9f90-abe0f8d09d0b)

![note view](https://photos.collectednotes.com/photos/63/08f22ed6-f802-4a8d-9b14-80469716e956)

![several notes](https://photos.collectednotes.com/photos/63/0f96e8f9-217e-4434-ad32-d591e8852d58)

![connected notes](https://photos.collectednotes.com/photos/63/2aab4512-196c-4fb7-9031-9c93fd327f80)

![many notes](https://photos.collectednotes.com/photos/63/3cf5a61c-fca5-4b10-9c2c-2fa24d0a574b)

![a lot of notes](https://photos.collectednotes.com/photos/63/969f0d7b-f956-4dd9-97d7-ad15bd76252b)

empty notes

first note

note view

several notes

connected notes

many no...

Idea: Aplicación para notas bíblicas

# Most used shell commands

https://gist.github.com/gillchristian/365ab84c7d8f6f4ed9953a7df734980c

https://gist.github.com/gillchristian/365ab84c7d8f6f4ed9953a7df734980c

Most used shell commands

# Code Reviews Comments Convention

A convention to clarify the intention of a comment in a Pull Request (PR) review using prefixes.

![xkcd standars](https://photos.collectednotes.com/photos/63/9be36614-4d0b-4c70-98f7-2ffab8ae783c)

*[Mandatory xkcd](https://xkcd.com/927/)*

Although it is possible to express the intent in the way the comment is written, it is easier to do so with a simple prefix. Not only it requires less words but it is also easier to take a quick look at the comments and understand what is the intention/meaning of each one.

My rule of thumb is, only reviews that include `[req]` and/or `[q]` should _Reject_ the PR. In other cases just make the review a _Comment_ or _Approve_.

## Prefixes

**`[req]` (requested change)**

Reviewer *believes* something should be changed.

**`[nth]` (nice to have)**

Reviewer suggests something better/more thorough/common pattern etc.

**`[pp]` (personal preference *of the reviewer*)**

This shows own opinion on style/unification etc. Might influence the author to apply some changes, but does not provide any benefits (it's not for optimization/better interfaces etc.)

**`[q]` (question)**

Reviewer would like to get some explanation on topic.

**`[fixed]`**

Author fixed/changed based on the comment.

**`[wont-fix]`**

Author declines the request. It should be first discussed with reviewer and explained in comment.

## Credits

To whoever came up with this convention 😅

If you know let me know, so I can credit & thank them! 🙏

---

**Happy and safe coding** ✌️

A convention to clarify the intention of a comment in a Pull Request (PR) review using prefixes.

xkcd standars...

Code Reviews Comments Convention

# Composing predicates

A few days ago I was writing some validation functions that were basically a composition of several other predicates.

Which would look something like this:

```hs
predA :: a -> Bool

predB :: a -> Bool

predC :: a -> Bool

predABC :: a -> Bool
predABC a = predA a && predB a && predC a
```

A Haskeller would be bothered by having to manually pass `a` to all the predicates. A **true** Haskeller would not, probably. But I'm far from that level of enlightenment. So I decided to find a way to compose predicates.

Note that by compose I mean not function composition but to combine two predicates together to get a new one. Either by conjunction (`&&`) or disjunction (`||`).

## Monoids

Since Monoids let us combine things, they were bound to show up in my search.

As we said, booleans (and predicates) can be combined in more than one way, so there isn't a default Monoid instance for Bool.

`Data.Monoid` defines:

- [All](https://hackage.haskell.org/package/base-4.14.0.0/docs/Data-Monoid.html#t:All) for conjunction.
- [Any](https://hackage.haskell.org/package/base-4.14.0.0/docs/Data-Monoid.html#t:Any) for disjunction.

```
λ> getAll (All True <> All False)
False
λ> getAll (All True <> All True)
True
```

```
λ> getAny (Any True <> Any False)
True
λ> getAny (Any False <> Any False)
False
```

Since the goal is to compose not booleans but predicates, we need to some mapping and folding to achieve that.

```hs
predABC :: a -> Bool
predABC = getAll . foldMap (All .) [predA, predB, predC]
```

```
λ> predABC a
True
λ> predABC b
True
λ> predABC z
False
```

Success? Well, it works and we can add as many predicates as we like with very low effort. But to compose just three predicates I'm not sure if it's worth.

## Applicative

If there are two ways to do this, there has to be a third.

From [#100DaysOfFP Day 33]( https://twitter.com/gillchristian/status/1229705223419105281)

> [Applicative instance of (->) functions](https://hackage.haskell.org/package/base-4.14.0.0/docs/src/GHC.Base.html#line-973) allows to apply an argument (x) to two unary functions (f & g) and then apply the result of each to a third function (h) to produce the result (y).

![applicative functions](https://photos.collectednotes.com/photos/63/4ba32968-eb68-487a-b46d-b379461d96a3)

That's exactly what I want!

```hs
(&&&) :: (a -> Bool) -> (a -> Bool) -> a -> Bool
f &&& g = (&&) <$> f <*> g

(|||) :: (a -> Bool) -> (a -> Bool) -> a -> Bool
f ||| g = (||) <$> f <*> g
```

Composing the predicates is way simpler now

```hs
predABC :: a -> Bool
predABC = predA &&& predB &&& predC
```

And is possible to use both combinators. Which was not possible with Monoids (*most probably is possible but not as straightforward*).

```hs
predAandBorC :: a -> Bool
predAandBorC = predA &&& predB ||| predC
```

Yup, I'm going to stick with those for combining my predicates 😏

One more thing, I declared the types of `(&&&)` and `(|||)` specified for the function instance of applicative. But they could work with any applicative.

```hs
(&&&) :: Applicative f => f Bool -> f Bool -> f Bool
f &&& g = (&&) <$> f <*> g

(|||) :: Applicative f => f Bool -> f Bool -> f Bool
f ||| g = (||) <$> f <*> g
```

```
λ> (Just True) &&& (Just False)
Just False
λ> (Just True) &&& (Just True)
Just True
λ> (Just False) &&& (Just False)
Just False
```

Yet another thing. `liftA2` could make the implementations even shorter.

```hs
(&&&) :: Applicative f => f Bool -> f Bool -> f Bool
(&&&) = liftA2 (&&)

(|||) :: Applicative f => f Bool -> f Bool -> f Bool
(|||) = liftA2 (||)
```

---

**Happy and safe coding** 🦄



A few days ago I was writing some validation functions that were basically a composition of several other predicates.

Whic...

Composing predicates

# Crossposting to dev.to

Last week [I migrated all my articles from dev.to](https://collectednotes.com/gillchristian/from-dev-to-to-collected-notes). I wrote a Haskell script to do that (duh!)

Although I'm posting in CollectedNotes now I do want to continue crossposting on [dev.to](https://dev.to/gillchristian). So is time for another script 🤓

## The Script

Very similar to the previous one. But now it accepts a few config options like the dev.to article series, tags and what article to publish (defaulting to the latest public one).

👇 *The help text produced by optparse-applicative*

```
$ ./collected-to-dev.hs --help
Post a note from CollectedNotes to dev.to

Usage: collected-to-dev.hs --site-id SITE_ID --email EMAIL --token TOKEN
                           --api-key API_KEY [--publish] [--tags TAGS]
                           [--series SERIES] [--note NOTE_SLUG]

Available options:
  --site-id SITE_ID        CollectedNotes notes site ID
  --email EMAIL            Your CollectedNotes email
  --token TOKEN            CollectedNotes API Token
  --api-key API_KEY        dev.to API Key
  --publish                Publish the article (creates as a draft by default)
  --tags TAGS              Comma separated list of tags (max 4)
  --series SERIES          dev.to article series
  --note NOTE_SLUG         The path of the note to publish
                           (collectednotes.com/my-site/<NOTE_SLUG>). If missing
                           the latest note will be published
  -h,--help                Show this help text
```
`collected-to-dev.hs` ([see on GitHub](https://github.com/gillchristian/scripts.hs/blob/master/collected-to-dev.hs))

```hs
#!/usr/bin/env stack
{- stack
   script
   --resolver lts-13.27
   --package aeson
   --package sort
   --package lens-aeson
   --package wreq
   --package lens
   --package text
   --package bytestring
   --package parsec
   --package optparse-applicative
-}

{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}

import Control.Applicative (optional)
import Control.Lens hiding ((.=))
import Data.Aeson
import Data.Aeson.Lens
import qualified Data.ByteString.Internal as BS
import qualified Data.ByteString.Lazy.Internal as LazyBS
import Data.List.NonEmpty (NonEmpty (..))
import qualified Data.List.NonEmpty as NonEmpty
import Data.Maybe
import Data.Ord
import Data.Sort
import qualified Data.Text as Text
import Data.Text (Text)
import GHC.Generics
import Network.Wreq
import qualified Options.Applicative as Opt
import Options.Applicative ((<**>))
import Text.Parsec hiding (optional)
import Text.Parsec.Char
import Text.Parsec.Text

data DevtoArticle = DevtoArticle
  { title :: Text,
    published :: Bool,
    main_image :: Text,
    canonical_url :: Text,
    tags :: Maybe (NonEmpty Text),
    series :: Maybe Text,
    body_markdown :: Text
  }
  deriving (Show, Generic, ToJSON)

eitherToMaybe :: Either e a -> Maybe a
eitherToMaybe (Right a) = Just a
eitherToMaybe _ = Nothing

stripTitleAndFirstImage :: Parser Text
stripTitleAndFirstImage = do
  _ <- spaces
  _ <- manyTill anyChar $ try newline
  _ <- spaces
  before <- manyTill anyChar $ try $ string "!["
  _ <- manyTill anyChar $ try $ char ')'
  Text.pack . (before <>) <$> many anyChar

parseTags :: Text -> [Text]
parseTags =
  take 4 . filter (not . Text.null) . fmap Text.strip . Text.splitOn ","

collectedToDev :: Config -> CollectedArticle -> Either ParseError DevtoArticle
collectedToDev Config {..} (title, body, _, url, image, _) =
  DevtoArticle title optPublished image url tags' optSeries . Text.strip
    <$> parse stripTitleAndFirstImage "" body
  where
    tags' = NonEmpty.nonEmpty =<< parseTags <$> optTags

sixth :: (a, b, c, d, e, f) -> f
sixth (_, _, _, _, _, f) = f

processPosts :: Config -> Response LazyBS.ByteString -> [DevtoArticle]
processPosts config =
  mapMaybe eitherToMaybe . fmap (collectedToDev config) . findNoteToPublish . extract
  where
    findNoteToPublish = case optNote config of
      Just note -> filter ((note ==) . sixth)
      Nothing -> take 1

type CollectedArticle =
  ( Text, -- title
    Text, -- body
    Text, -- visibility ("public" | "private")
    Text, -- url
    Text, -- poster (picture)
    Text -- path (ie. slug)
  )

extract :: Response LazyBS.ByteString -> [CollectedArticle]
extract r =
  let Fold article =
        (,,,,,) <$> Fold (key "title" . _String)
          <*> Fold (key "body" . _String)
          <*> Fold (key "visibility" . _String)
          <*> Fold (key "url" . _String)
          <*> Fold (key "poster" . _String)
          <*> Fold (key "path" . _String)
   in r ^.. responseBody . values . article

getCollectedArticles :: Config -> IO (Response LazyBS.ByteString)
getCollectedArticles Config {..} =
  getWith reqConfg url
  where
    -- curl -H "Authorization: your@email.com your-secret-token" \
    --   -H "Accept: application/json" \
    --   -H "Content-Type: application/json" \
    --   https://collectednotes.com/sites/1/notes
    reqConfg =
      defaults
        & header "Authorization" .~ [email <> " " <> collectednotesToken]
        & header "Content-Type" .~ ["application/json"]
        & header "Accept" .~ ["application/json"]
    url = "https://collectednotes.com/sites/" <> siteId <> "/notes"

postDevtoArticle :: Config -> DevtoArticle -> IO ()
postDevtoArticle Config {..} article = do
  putStrLn $ Text.unpack $ "Posting: " <> title article
  r <- postWith reqConfg url body
  putStrLn $ Text.unpack $ successMsg r
  where
    -- curl -X POST -H "Content-Type: application/json" \
    --   -H "api-key: API_KEY" \
    --   -d '{"article":{"title":"Title","body_markdown":"Body","published":true,"tags":["discuss", "javascript"]}}' \
    --   https://dev.to/api/articles
    reqConfg =
      defaults
        & header "api-key" .~ [devtoApiKey]
        & header "Content-Type" .~ ["application/json"]
        & header "Accept" .~ ["application/json"]
    url = "https://dev.to/api/articles"
    body = object ["article" .= article]
    successMsg r =
      "✓ dev.to post created: ("
        <> fromMaybe "<no response body>" (r ^? responseBody . key "url" . _String)
        <> ")\n"

data Config = Config
  { siteId :: String,
    email :: BS.ByteString,
    collectednotesToken :: BS.ByteString,
    devtoApiKey :: BS.ByteString,
    optPublished :: Bool,
    optTags :: Maybe Text,
    optSeries :: Maybe Text,
    optNote :: Maybe Text
  }
  deriving (Show)

configP :: Opt.Parser Config
configP =
  Config
    <$> Opt.strOption
      ( Opt.long "site-id"
          <> Opt.metavar "SITE_ID"
          <> Opt.help "CollectedNotes notes site ID"
      )
    <*> Opt.strOption
      ( Opt.long "email"
          <> Opt.metavar "EMAIL"
          <> Opt.help "Your CollectedNotes email"
      )
    <*> Opt.strOption
      ( Opt.long "token"
          <> Opt.metavar "TOKEN"
          <> Opt.help "CollectedNotes API Token"
      )
    <*> Opt.strOption
      ( Opt.long "api-key"
          <> Opt.metavar "API_KEY"
          <> Opt.help "dev.to API Key"
      )
    <*> Opt.switch
      ( Opt.long "publish"
          <> Opt.help "Publish the article (creates as a draft by default)"
          <> Opt.showDefault
      )
    <*> optional
      ( Opt.strOption
          ( Opt.long "tags"
              <> Opt.metavar "TAGS"
              <> Opt.help "Comma separated list of tags (max 4)"
          )
      )
    <*> optional
      ( Opt.strOption
          ( Opt.long "series"
              <> Opt.metavar "SERIES"
              <> Opt.help "dev.to article series"
          )
      )
    <*> optional
      ( Opt.strOption
          ( Opt.long "note"
              <> Opt.metavar "NOTE_SLUG"
              <> Opt.help "The path of the note to publish (collectednotes.com/my-site/<NOTE_SLUG>). If missing the latest note will be published"
          )
      )

opts :: Opt.ParserInfo Config
opts =
  Opt.info
    (configP <**> Opt.helper)
    ( Opt.fullDesc
        <> Opt.header "Post a note from CollectedNotes to dev.to"
    )

main :: IO ()
main = do
  config <- Opt.execParser opts
  r <- getCollectedArticles config
  processPosts config r
    & ( \case
          [a] -> postDevtoArticle config a
          [] -> putStrLn "404: Note not found"
          _ -> putStrLn "500: Found more than one note"
      )
```

---

**Happy and safe coding!** 🦄

Last week I migrated all my articles from dev.to. I wrote a Haskell script to do that (duh!)

Although I'm posting in Col...

Crossposting to dev.to

# TypeScript Short links

![typescript playground](https://photos.collectednotes.com/photos/63/bb3f4bba-5657-462b-ba19-8bacd1f1a21d)

If you know or use TypeScript you ought to be familiar with its [Playground](https://www.typescriptlang.org/play/). It is an awesome tool, being able to play around with TypeScript on the browser, try things out. Is also great for collaboration, since the editor's state (code and config) is kept serialized in the URL, all it take is `ctrl + s` (or `Cmd` if you are in need Mac) and the link is on the clipboard and ready to be shared.

But then you paste the link on Slack and it is looonger than the *yarn.lock* of a React application 😰

A fairly short snippet results in something like this: https://www.typescriptlang.org/play/index.html#code/PTAEBUE8AcFMGUDGAnAltALqayD2A3VAE1gGdQBHAV1UQGsBaAM1QA9RlZFcBbH2AHZEAhhlS4B5JrmQBYAFAhQ3PhNDDEiYoIykANKAwALWJFCkjuAO6gq0UKgGhIuKslCwiqDDNAAjYVJPBSU1ThV+IVFxSQA6BRCwADFfWFZhHmgAG1gIGAQUdCxEYSccAm1KGnpmNjJE0Gl3DBhcckdnV2b80gAuBPluSSxYKhzkUgA5Kh4-WHcAXlAAJliAdgBGAA5lre3dgBYFUfGpmbnkWJ94DGRSgHMACgBKAG4G0E+v74A9AH0AYCfqAGOZYDlEFhjKhyD4wbljLksqh7kYsH4aFkiANEFlAuQAKLpTI5ADCeNI5AA3gpPvxjLgiC9QDT5N9oaRYgJcBgACJcPGcIigJYbAAM7zZoAAvgppUA

That's a big nope from your coworkers who hate long links *polluting* the Slack history. And if you are anything like me you don't even like to be the one sharing long links either.

## What if ... ?

What if those long links looked like this instead?

[tsplay.dev/vwj58W](https://tsplay.dev/vwj58W)

[tsplay.dev/hello](https://tsplay.dev/hello)

## Yet another link shortener

Yes there are already a ton of link shorteners out there. But it is great to have a dedicate one. It creates identity. When you see [tsplay.dev](https://tsplay.dev) you know it'll be some TypeScript code.

🛡️ It is also about security. You never know where _tinyurl.com_ or _bit.ly_ short-links could redirect to.

## In the making

For now short links can only be created on [tsplay.dev](https://tsplay.dev).

But we are working on a [playground plugin](https://www.staging-typescript.org/dev/playground-plugins/) to create short links right there in the playground. Which should be available when the [new version of the TypeScript website](https://www.staging-typescript.org) is fully released.

---

By [Nahuel](https://dvnahuel.website/) 🎨 [Joni](https://jonidelv.me/) 💻 & myself 💻

typescript playground

If you know or use TypeScript you ought to be familiar with its Playground. It is an awesome tool,...

TypeScript Short links

# ZuricHac quotes

**Tobias Dammers** :

> **What do you bring to your main work language from doing Haskell on the side?**

> Currently doing Haskell at work, but have been in that situation for a long while before. I think the main things I got from Haskell were the "equational reasoning" thing (structure your code such that you can reason in terms of which things are equal / equivalent, instead of "what happens then"), and the "DSL" approach (instead of decomposing the problem into ever-smaller steps until they are small enough to express in the language directly, start by building a domain-specific language that captures the entities in your problem domain and how they can interact, and then express the solution in that DSL).
>
> Another big one is the "correct by construction" idea, i.e., defining data structures and function signatures etc. such that they can only represent valid states; now you don't have to check for invalid states anymore, and "forgetting a check" becomes a non-problem.
>
> A less fun effect of learning Haskell is that I saw the flaws in other languages more clearly - "this would be trivial in Haskell" is a thought that popped up more often than I'd be comfortable with
>
> (they say Haskell ruins other languages for you, and I think there's some truth to that)

**Tobias Dammers** on

> **Beginner vs. Intermediate vs. Advanced**
>
> FWIW, I'm one of the two people to provide this year's "Advanced Track" sessions, I have worked on some fairly nasty GHC issues, I have been Haskelling for 12 years, and still I routinely feel overwhelmed by some of the stuff that comes naturally to some of my "more advanced" colleagues, or even some CS students who happen to specialize in topics that I don't have a good grasp on (yet). I recommend considered the "advanced" label a relative one.


## Effects for Less

Different ways to handle effects (*effect systems and the like*):

- [monad transformers](https://wiki.haskell.org/Monad_Transformers)
- [mlt](http://hackage.haskell.org/package/mtl)
- [fussed-effects](https://hackage.haskell.org/package/fused-effects)
- [polysemy](https://hackage.haskell.org/package/polysemy)

GHC optimizations are 🤯

☝️ Those are only applied for "same module" code.

Compilers, in general, are 🤯

There's SO MUCH to learn! And SO MUCH I don't know!

> Effect systems are about dynamic dispatch

ie: *implementation to effects is defined "later"*

To check:
- [hasura/eff](https://github.com/hasura/eff)
- [GHC's Users Guide](https://downloads.haskell.org/ghc/latest/docs/html/users_guide/)

[youtube 0jI-AlWEwYI]

Tobias Dammers :



What do you bring to your main work language from doing Haskell on the side?

Currently doing Hask...

ZuricHac quotes

# Writing Queue

-[] Lazy evaluation & `(|||)`
-[] Lenses & JSON Values
-[] Re-starting tsearch.io
-[] Rust vs. Haskell
-[] Lazy IO pitfalls with files
-[] Small & cozy communities
-[] Notes on streaming
-[x] ZuricHac
-[x] Post from collected to dev.to

Lazy evaluation &amp; (|||)
        
      

      
        
          
          Lenses &amp; JSON Values
        
      

      
        
          
          Re-starting tsearch.io
        
      

      
        
          
          Rust vs. Haskell
        
      

      
        
          
          Lazy IO pitfalls with f...

Writing Queue

# ZuricHac 2020

![alt](https://photos.collectednotes.com/photos/63/d2f52018-3a62-4592-8339-70f0ce363f50)

Last weekend I participated in [ZuricHac](https://zfoh.ch/zurihac2020/). It was an **awesome event**. Well organized 👏🙇 and full of interesting people!

> ZuriHac is the biggest [Haskell](https://www.haskell.org/) Hackathon in the world: a completely free, three-day grassroots coding festival organized by [Zürich Friends of Haskell](https://zfoh.ch/). It features fantastic keynotes, interesting tracks, and of course lots of hacking and socializing!

This year, due to Corona 🦠😷 the event took place online. Everything revolved around a [Discord](https://discord.com/) server. There were channels for particular projects people were hacking on, channels for the different tracks (beginner, intermediate and expert) and common channels to discuss the talks, hang out and share pictures of coffee ☕

Here's a small recap of the things I did and learned.

## did

- Joined 3 talks
  - [Languages all the way down](https://www.youtube.com/watch?v=kCpQ4aTzlis) by [@rob_rix](https://twitter.com/rob_rix)
  - [(Programming Languages) in Agda = Programming (Languages in Agda)](https://www.youtube.com/watch?v=x0R5h190Yts) by Philip Wadler
  - [Effects for Less](https://www.youtube.com/watch?v=0jI-AlWEwYI) by [@lexi_lambda](https://twitter.com/lexi_lambda) 🤯
- Joined one live coding session on GHC language extensions. [Write a GHC extension in 30 minutes](https://www.youtube.com/watch?v=bhhE2DxbrJM) by [@RaeHaskell](https://twitter.com/RaeHaskell).
- Joined one spontaneous call about lazy IO pintfalls when working with files by [@me_coot](https://twitter.com/me_coot).
- Found some fellow Spanish speakers _#lakeside-spanish_ (Spain, Argentina, Mexico, Guatemala, probably more!) 🇬🇹🇲🇽🇪🇸🇦🇷
- Collaborated on [tsearch.io](https://tsearch.io) and even got a contributor!!! 🤩
- Participated in different conversations and reacted with tons of emoji 🥳

## learned

- Lazy evaluation / lazy IO one of Haskell main features. As much as it enables some good stuff it can also cause some problems. When reading files (`readFile :: String -> IO String`), the files are open but not read until the evaluation is forced which might result in too many open files issues. Since files are closed as soon as the content is read the solution is to force the evaluation. 🤕
- Effect systems are all about abstraction of effects and being able to represent those effects in different ways.
- Effect systems have performance penalties due to polymorphism.
- The compiler (GHC) does a mind-blowing job optimizing code. 🤯
- To there's some much the compiler can do. So is up to the developers to find ways to produce more optimized code.
- Is important to know how and why the compiler optimizes (or not) certain code.
- TypeScript is harder than Haskell. Being able to type JavaScript programs makes for a very complex type system.
- Formal proof languages like Agda are less scary than they seem! 🤓

---

*And a huge thanks to the organizers and everyone who made the event possible!*

*I look forward to participate next year in person.*

alt

Last weekend I participated in ZuricHac. It was an awesome event. Well organized 👏🙇 and full of interesting people!



Zu...

ZuricHac 2020

# From dev.to to Collected Notes

![Collected Notes, so hot right now](https://i.imgflip.com/44o4l5.jpg)

I have been publishing notes an articles on [dev.to](https://dev.to) for around a year and a half already. Although it's a great platform and there's a pretty nice community around it, I always wanted to have my own thing. Something simpler, just upload my content and that's it. No likes, no feeds, no related posts from other users. So I got very excited when [@esacrosa](https://twitter.com/esacrosa/) announced Collected Notes and I was able to try out the alpha version 🎉

From now on I'll writing here on Collected Notes. And cross-post to [dev.to](https://dev.to) most probably.

If I'll be writing here then I should have the rest of articles and notes from [dev.to/gillchristian](htts://dev.to/gillchristian) here as well.

Inspired by [@RiccardoOdone](https://twitter.com/RiccardoOdone) videos on [scripting](https://youtu.be/XsgixFYo_Sc) [with Haskell](https://youtu.be/PU9Gs-XRYEQ) and becase  both [dev.to](https://dev.to) and Collected Notes have APIs I did what anybody would do, write some code to automate the process.

![xkcd #974](https://imgs.xkcd.com/comics/the_general_problem.png)

*\* Disclaimer, in my case it won't save time in the long run since it is a one time script.*

## The script

I won't go into detail of how the script is implemented but I do think it is worth pointing out the libraries and tools involved:

- [Stack script interpreter](https://docs.haskellstack.org/en/stable/GUIDE/#script-interpreter) allows to use Haskell for scripting, even to use libraries and a particular compiler version if needed
- [optparse-applicative](https://hackage.haskell.org/package/optparse-applicative) a command line options parsing with an applicative flavor 🌯
- [wreq](https://hackage.haskell.org/package/wreq) for HTTP requests
- [lens](http://hackage.haskell.org/package/lens), [aeson](http://hackage.haskell.org/package/aeson) & [lens-aeson](http://hackage.haskell.org/package/lens-aeson) for manipulating JSON data. It's the first time I use lenses so no idea what I was doing 🐶
- [parsec](https://hackage.haskell.org/package/parsec), a parser combinator library, which I used to parse the markdown and remove the Front Matter (metadata) section

👇 *The help text produced by optparse-applicative*

```
$ ./dev-to-collected.hs --help
Script to migrate all your dev.to articles to CollectedNotes

Usage: dev-to-collected.hs --email EMAIL --token TOKEN --api-key API_KEY

Available options:
  --email EMAIL            Your CollectedNotes email
  --token TOKEN            CollectedNotes API Token
  --api-key API_KEY        dev.to API Key
  -h,--help                Show this help text
```

`dev-to-collected.hs` ([see on GitHub](https://github.com/gillchristian/scripts.hs/blob/master/dev-to-collected.hs))

```hs
#!/usr/bin/env stack
{- stack
   script
   --resolver lts-13.27
   --package aeson
   --package sort
   --package lens-aeson
   --package wreq
   --package lens
   --package text
   --package bytestring
   --package parsec
   --package optparse-applicative
-}

{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}

import Control.Lens hiding ((.=))
import Data.Aeson
import Data.Aeson.Lens
import qualified Data.ByteString.Internal as BS
import qualified Data.ByteString.Lazy.Internal as LazyBS
import Data.Maybe
import Data.Ord
import Data.Sort
import qualified Data.Text as Text
import Data.Text (Text)
import Network.Wreq
import qualified Options.Applicative as Opt
import Options.Applicative ((<**>))
import Text.Parsec
import Text.Parsec.Char
import Text.Parsec.Text

type DevtoArticle =
  ( Text, -- title
    Text, -- published
    Text, -- cover_image
    Text, -- url
    Text -- body
  )

eitherToMaybe :: Either e a -> Maybe a
eitherToMaybe (Right a) = Just a
eitherToMaybe _ = Nothing

stripMeta :: Parser Text
stripMeta = do
  _ <- spaces
  _ <- string "--"
  _ <- spaces
  _ <- manyTill anyChar $ try $ string "---"
  _ <- spaces
  Text.pack <$> many anyChar

devtoToCollected :: DevtoArticle -> Either ParseError (Text, Text)
devtoToCollected (title, _, cover_image, url, body_markdown) =
  makeArticle <$> parse stripMeta "" body_markdown
  where
    makeArticle body =
      ( title,
        Text.unlines
          [ "# " <> title <> "\n",
            "*Originally posted on [dev.to/gillchristian](" <> url <> ")*.\n",
            "![" <> title <> "](" <> cover_image <> ")\n",
            body
          ]
      )

extract :: Response LazyBS.ByteString -> [DevtoArticle]
extract r =
  let Fold article =
        (,,,,) <$> Fold (key "title" . _String)
          <*> Fold (key "published_at" . _String)
          <*> Fold (key "cover_image" . _String)
          <*> Fold (key "url" . _String)
          <*> Fold (key "body_markdown" . _String)
   in r ^.. responseBody . values . article

snd5 :: (a, b, c, d, e) -> b
snd5 (_, b, _, _, _) = b

processPosts :: Response LazyBS.ByteString -> [(Text, Text)]
processPosts = mapMaybe eitherToMaybe . fmap devtoToCollected . sortOn snd5 . extract

getDevtoArticles :: Config -> IO (Response LazyBS.ByteString)
getDevtoArticles Config {..} =
  getWith reqConfg url
  where
    -- curl -H "api-key: API_KEY" https://dev.to/api/articles/me/published
    url = "https://dev.to/api/articles/me/published"
    reqConfg = defaults & header "api-key" .~ [devtoApiKey]

postCollectedArticle :: Config -> (Text, Text) -> IO ()
postCollectedArticle Config {..} (title, postBody) = do
  putStrLn $ Text.unpack $ "Posting: " <> title
  r <- postWith reqConfg url body
  putStrLn $ Text.unpack $ successMsg r
  where
    -- curl -H "Authorization: your@email.com your-secret-token" \
    -- -H "Accept: application/json" \
    -- -H "Content-Type: application/json" \
    -- https://collectednotes.com/sites/1/notes \
    -- -d '{"note": {"body": "# My new note title\nThis is the body", "visibility": "private"}}'
    reqConfg =
      defaults
        & header "Authorization" .~ [email <> " " <> collectednotesToken]
        & header "Content-Type" .~ ["application/json"]
        & header "Accept" .~ ["application/json"]
    url = "https://collectednotes.com/sites/57/notes"
    body = object ["note" .= object ["body" .= postBody, "visibility" .= ("private" :: Text)]]
    successMsg r =
      "✓ Note created: ("
        <> fromMaybe "<no response body>" (r ^? responseBody . key "url" . _String)
        <> ")\n"

data Config = Config
  { email :: BS.ByteString,
    collectednotesToken :: BS.ByteString,
    devtoApiKey :: BS.ByteString
  }
  deriving (Show)

configP :: Opt.Parser Config
configP =
  Config
    <$> Opt.strOption
      ( Opt.long "email"
          <> Opt.metavar "EMAIL"
          <> Opt.help "Your CollectedNotes email"
      )
    <*> Opt.strOption
      ( Opt.long "token"
          <> Opt.metavar "TOKEN"
          <> Opt.help "CollectedNotes API Token"
      )
    <*> Opt.strOption
      ( Opt.long "api-key"
          <> Opt.metavar "API_KEY"
          <> Opt.help "dev.to API Key"
      )

opts :: Opt.ParserInfo Config
opts =
  Opt.info
    (configP <**> Opt.helper)
    ( Opt.fullDesc
        <> Opt.header "Script to migrate all your dev.to articles to CollectedNotes"
    )

main :: IO ()
main = do
  config <- Opt.execParser opts
  r <- getDevtoArticles config
  mapM_ (postCollectedArticle config) $ processPosts r
  putStrLn "Great success!!! 🎉"
```

Is it an overkill? No doubt.

Did I learn new and cool stuff in the process? No doubt 🤓

---

**Happy and safe coding!** 🖖

Collected Notes, so hot right now

I have been publishing notes an articles on dev.to for around a year and a hal...

From dev.to to Collected Notes

# Apply me both lists

*Originally posted on [dev.to/gillchristian](https://dev.to/gillchristian/apply-me-both-lists-2kkm)*.

![Apply me both lists](https://res.cloudinary.com/practicaldev/image/fetch/s--ccl23pq1--/c_imagga_scale,f_auto,fl_progressive,h_420,q_auto,w_1000/https://thepracticaldev.s3.amazonaws.com/i/jxrxbwhhiu3nuynzwblp.jpg)

As we saw in the previous one, Applicative allows to apply *n-ary* functions in a context. The context might be a parser, values that are potentially be errors, a list or a tree, optional values, IO actions, etc.

In my short learning experience so far, I've used it in practice for two things mostly.

Constructing values with data constructors that take several values. For example, those values would come from sequential parsers when working with parser combinators (like [Parsec](https://hackage.haskell.org/package/parsec)).

```hs
data User = User String String Int

-- "John Doe 26" -> User "John" "Doe" 26
parseUser :: Parser User
parseUser =
  User <$> (parseWord <* whitespace)
       <*> (parseWord <* whitespace)
       <*> parseAge

parseWord :: Parser String
parseAge :: Parser Int

whitespace :: Parser () -- consumes as much whitespace as possible

-- Defined in Control.Applicative
(<*) :: Applicative f => f a -> f b -> f a
```

`(<*)` is the lifted version of `const`, [here](https://dev.to/gillchristian/lifting-const-1a3l) is something I wrote about that. As we can guess from the signature, in this case it applies both parses (ie. both consume input) but returns the first one, ignoring the second.

And the other use case, applying *n-ary* functions to values that might not be there. In other words, when the context is Either or Maybe.

```hs
add <$> (Just 1) <*> (Just 2) -- Just 3
add <$> Nothing  <*> (Just 2) -- Nothing
add <$> (Just 1) <*> Nothing  -- Nothing
add <$> Nothing  <*> Nothing  -- Nothing

add <$> (Right 1)      <*> (Right 2)      -- Right 3
add <$> (Left "err 1") <*> (Right 2)      -- Left "err 1"
add <$> (Right 1)      <*> (Left "err 2") -- Left "err 2"
add <$> (Left "err 1") <*> (Left "err 2") -- Left "err 1"
```

### Lists

Until last week I hadn't found a use case for Applicative when working with lists. I knew how it works but never had ~~an excuse~~ a reason to use it.

Let's take a look at the instance and some examples first.

```hs
(<*>) :: Applicative f => f (a -> b) -> f a -> f b

-- With [] applied to f (using TypeApplications extension)
(<*>) @[] :: [a -> b] -> [a] -> [b]

(+) <$> [1, 2, 3] <*> [1, 2, 3]
-- [2,3,4,3,4,5,4,5,6]

(,) <$> [1, 2, 3] <*> [1, 2, 3]
-- [(1,1),(1,2),(1,3),(2,1),(2,2),(2,3),(3,1),(3,2),(3,3)]

[(++ "!"), (++ "?")] <*> ["Hola", "Mundo"]
-- ["Hola!","Mundo!","Hola?","Mundo?"]
```

As we can see, it takes a list of functions (`[a -> b]`) and a list values (`[a]`) and applies all the functions from the first list to all the values from the second one, this results in a larger list (duh!). If list sizes are `n` and `m`, respectively, the size of the returned list is `n * m`.

That's not a use case that I find very often. Most of the time I have one function (`a -> b`) that I want to apply to a list of values (`[a]`). That's Functor's `fmap` (as well as `(<$>)`). Or I have a list of functions to apply to a single value. For example, it could be list of predicates and I want to check if all or some are `True` for a particular value.

```hs
allPass :: [a -> Bool] -> a -> Bool

anyPass :: [a -> Bool] -> a -> Bool
```

By the way, there are similar functions [defined in Base](https://hackage.haskell.org/package/base-4.12.0.0/docs/GHC-List.html#v:and):

```hs
and :: [Bool] -> Bool -- True when all are True

or :: [Bool] -> Bool  -- True when at least one is True
```

In the case of lists, what applicative does is apply all the functions too all the values.

Last week, playing around on small side project, [till](https://github.com/gillchristian/till). I was trying to add the option to match several patterns against the same value and I found a use case for List's Applicative.

There's a `match` function that checks if a pattern matches a single line of the output.

```hs
match :: Pattern -> Line -> Bool
```

The output consists of a list of lines. When working with a single pattern, the solution is easy. Use [any](https://hackage.haskell.org/package/base-4.12.0.0/docs/Prelude.html#v:any) (from Base).

```hs
any :: Foldable t => (a -> Bool) -> t a -> Bool

any @[] :: (a -> Bool) -> [a] -> Bool

matchPattern :: Pattern -> [Line] -> Bool
matchPattern p lns = any (match p) lns
```

What about matching several patterns against the output?

```hs
matchAll :: [Pattern] -> [Line] -> Bool
matchAll ps lns = undefined -- ???
```

Applicative to the rescue 🎉

```hs
matchAll :: [Pattern] -> [Line] -> Bool
matchAll ps lns = or (match <$> ps <*> lns)
```

Let's dissect that :mag:

```hs
-- So we don't forget ;)
(<$>) @[] :: (a -> b) -> [a] -> [b]
   
(<*>) @[] :: [a -> b] -> [a] -> [b]

-- ^ notice the difference between <$> & <*> ;)

or :: [Bool] -> Bool

match :: Pattern -> Line -> Bool

-- the input
ps :: [Pattern]

lns :: [Line]

-- mapping first to partially apply the patterns to match
match <$> ps :: [Line -> Bool]

-- applying the lines
match <$> ps <*> lns :: [Bool]

-- reducing that to get our result
or (match <$> ps <*> lns) :: Bool
```

I like how elegant this looks thanks to Functor and Applicative 🎩

NOTE: I'm sure there are other ways to solve the problem, with better performance. Although in my use case both lists *should* be relatively short, usually between one and three patterns and around 100 or probably less lines of output.

**Happy and safe coding** 🦄


Originally posted on dev.to/gillchristian.



As we saw in the previous one, Applicative allows to appl...

Apply me both lists

# Why Applicative?

*Originally posted on [dev.to/gillchristian](https://dev.to/gillchristian/why-applicative-kao)*.

![Why Applicative?](https://res.cloudinary.com/practicaldev/image/fetch/s--8ADrijl8--/c_imagga_scale,f_auto,fl_progressive,h_420,q_auto,w_1000/https://thepracticaldev.s3.amazonaws.com/i/437cejvu71qhohri95x8.jpg)

When learning about the different type classes in Haskell the one I struggled the most with was, by far, [Applicative](https://en.wikipedia.org/wiki/Applicative_functor).

### Functor

[Functor](https://en.wikipedia.org/wiki/Functor) is, at least to some extent, straightforward. We take any *unary* functions and make them work on some (functor) context.

```hs
fmap :: Functor f => (a -> b) -> f a -> f b

-- or the infix version
(<$>) :: Functor f => (a -> b) -> f a -> f b
```

Say we have an increment function that works on `Int`s.

```hs
inc :: Int -> Int
```

```
λ> inc 1
2
```

By using `fmap` we can map any functor that contains an `Int`.

```
λ> fmap inc [1, 2, 3]
[2, 3, 4]
λ> fmap inc (Just 1)
Just 2
λ> fmap inc (Right 1)
Right 2
```

That becomes very clear when we align `fmap` with the function application operator.

```hs
($) ::                (a -> b) ->   a ->   b
(<$>) :: Functor f => (a -> b) -> f a -> f b

inc  $   1       --  2
inc <$> [1]      -- [2]
inc <$> (Just 1) -- Just 2
```

*fmap is just function application inside a context.*

*By the way, we'll use the infix version from now*.

### Applicative

In the case of applicative it's not clear. Or at least it took longer to click for me.

```hs
(<*>) :: Applicative f => f (a -> b) -> f a -> f b
```

Comparing with `($)` doesn't really help. Why would I want to also have the function in the context?

```hs
($) ::                      (a -> b) ->   a ->   b
(<*>) :: Applicative f => f (a -> b) -> f a -> f b
```

We said functors allow to apply a *unary* function in a context. But what happens if I want to apply a function with a higher arity?

```hs
add :: Int -> Int -> Int

add <$> (Just 1) -- ??
```

What does the repl says? 🦊

```
λ> :t add <$> (Just 1)
add <$> (Just 1) :: Maybe (Int -> Int)
```

`Maybe (Int -> Int)`? Yes, we saw that already in the `(<*>)` signature.

```hs
add <$> (Just 1) <*> (Just 2) -- Just 3
```

Let's dissect that 🔍

```hs
-- refresh these ones first :)
(<$>) :: Functor  => (a -> b) -> f a -> f b
(<*>) :: Applicative f => f (a -> b) -> f a -> f b

-- With Maybe applied (using TypeApplications extension)

(<$>) @Maybe :: (a -> b) -> Maybe a -> Maybe b

add :: Int -> Int -> Int

-- With Int applied in place of 'a'
(<$>) @Maybe @Int :: (Int -> b) -> Maybe Int -> Maybe b

-- With (Int -> Int) applied in place of 'b'
(<$>) @Maybe @Int @(Int -> Int)
--   (a   -> b)          -> Maybe a   -> Maybe b
  :: (Int -> Int -> Int) -> Maybe Int -> Maybe (Int -> Int)

add <$> (Just 1) :: Maybe (Int -> Int)
```

Here we see the first interesting thing. Since our `add` function takes two arguments (or to be more accurate one at a time). But we only provide one (the `Int` from `Maybe Int`), so it gets partially applied and returns a function (`Int -> Int`). So `b` is `Int -> Int`.

```hs
--     a  ->   b 
add :: Int -> (Int -> Int)
```

*Note that parens aren't actually needed since the arrow (`->`) is right associative.*

That was the first part of the expression. We are missing the applicative.

```hs
(<*>) @Maybe :: Maybe (c -> d) -> Maybe c -> Maybe d

-- With Int in place of 'c'
(<*>) @Maybe @Int :: Maybe (Int -> b) -> Maybe Int -> Maybe b

-- And also Int in place of 'd'
(<*>) @Maybe @Int @Int
  :: Maybe (Int -> Int) -> Maybe Int -> Maybe Int
```

*Et voilà*

```hs
add :: Int -> Int -> Int
add <$> (Just 1) :: Maybe (Int -> Int)
add <$> (Just 1) <*> (Just 2) :: Maybe  Int
```

**Functor**: apply *unary* functions in a context.

**Applicative**: apply *n-ary* functions in a context.

*This is referred as [lift](https://hackage.haskell.org/package/base-4.12.0.0/docs/Control-Applicative.html#v:liftA2) in Haskell.*

And the whole point of applying functions in such contexts is the semantics associated with them. It might be for validation, optional values (without `null` 😏), lists or trees of items, running IO actions, parsers.

When the context is Maybe:

```
λ> add <$> (Just 1) <*> (Just 2)
Just 3
λ> add <$> Nothing <*> (Just 2)
Nothing
λ> add <$> (Just 1) <*> Nothing
Nothing
λ> add <$> Nothing <*> Nothing
Nothing
```

When the context is Either:

```
λ> add <$> (Right 1) <*> (Right 2)
Right 3
λ> add <$> (Left "err 1") <*> (Right 2)
Left "err 1"
λ> add <$> (Right 1) <*> (Left "err 2")
Left "err 2"
λ> add <$> (Left "err 1") <*> (Left "err 2")
Left "err 1"
```

When the context is List:

```
λ> add <$> [1, 2, 3] <*> [1, 2, 3]
[2,3,4,3,4,5,4,5,6]
λ> (,) <$> [1, 2, 3] <*> [1, 2, 3]
[(1,1),(1,2),(1,3),(2,1),(2,2),(2,3),(3,1),(3,2),(3,3)]
```

☝️ *More on that on the next one*.

### Conclusion

When learning functional programming all these type classes might seem scary. Developing a basic intuition of their purpose and usages is a big part of the process of getting comfortable using (and understanding) them.

I know there are more implications around Functor and Applicative that I have yet to discover. But as any learning process, it takes time. I'm sure more things will become clear and start sink in as I keep going.

But that's all for today. 

**Happy and safe coding** 🎉


Originally posted on dev.to/gillchristian.



When learning about the different type classes in Haskell the o...

Why Applicative?

# Enough fp-ts to work with io-ts

*Originally posted on [dev.to/gillchristian](https://dev.to/gillchristian/enough-fp-ts-to-work-with-io-ts-20ip)*.

![Enough fp-ts to work with io-ts](https://res.cloudinary.com/practicaldev/image/fetch/s--2tU9Hejn--/c_imagga_scale,f_auto,fl_progressive,h_420,q_auto,w_1000/https://thepracticaldev.s3.amazonaws.com/i/yufd1tdiyyngyr6hhzz0.jpg)

This is a small tutorial of what one needs to know about [fp-ts](https://github.com/gcanti/fp-ts) to work with [io-ts](https://github.com/gcanti/io-ts). In other words:

> Just enough fp-ts to ~~to work with io-ts~~ be dangerous

## what-ts now ?

Let's start by introducing these two libraries and what they are.

**fp-ts**

> Typed functional programming in TypeScript
>
> ... a library containing implementations of common algebraic types in TypeScript

That seems to be clear. Ok, maybe not the [algebraic types](https://en.wikipedia.org/wiki/Algebraic_data_type) but that's not super important in practice.

**io-ts**

> Runtime type system for IO decoding/encoding

Urhg, what?!

io-ts provides safe encoding/decoding. We can say is the proper way to do `JSON.parse` with types in mind. Check the library docs to learn more about it.

## But why?

io-ts is part of the [ecosystem of typed functional programming (FP) in TypeScript](https://gcanti.github.io/fp-ts/introduction/ecosystem.html), fp-ts being the main library. So naturally io-ts does good use of fp-ts.

If you are familiar with (typed) FP, then why are you still reading? Or maybe you can finish and suggest some improvements to this post 😅

On the other hand, if you aren't familiar with (typed) FP and see the [fp-ts website](https://gcanti.github.io/fp-ts/) it might seem scary and feel like a lot of information to process. Specially the weird words. Well it is a bit scary, I agree with you. But for working with io-ts we need just a really ~~small~~ smol fraction of the library. Besides that, my advice is to approach it as you would approach any other API of a library you learning to use. I'm not gonna go full *advocate of FP* mode, just say that it's really worth to learn and a pleasure to work with.

## Either it's right or left

When decoding a type with io-ts the ~~weird~~ new thing we see is, it returns a value of type `Either<t.Errors, T>` (where `T` is the type we want to decode to).

```ts
import * as t from 'io-ts'

const result: Either<t.Errors, number> = t.number.decode(123)
```

Either is an algebraic type, in particular a [discriminated union](https://www.typescriptlang.org/docs/handbook/advanced-types.html#discriminated-unions) with two branches, `Right` and `Left`. The first is usually used to denote success and the later to denote failure. In our example `t.Errors` is the type wrapped by Left and `number` is wrapped by Right. Either is a [sum type](https://en.wikipedia.org/wiki/Tagged_union) (another term for discriminated unions) because it can be either (pun intended) Left or Right, but not both.

The purpose of Either, as you probably guessed, is to work with operations that can fail or succeed. And it provides some nice features to work with it.

### `fold`ing 📂

Although one could access the internals of an Either value to get it's contents, that's not how it's intended to work.

To get a value out of it, fp-ts provides `fold`:

```ts
declare function fold<E, A, B>(
  onLeft: (e: E) => B,
  onRight: (a: A) => B,
): (e: Either<E, A>) => B
```

As the type definition implies, it expects us to handle both cases.

There are some similarities between `fold` and `Array.reduce`, which is also a way to transform a wrapped type (`Array<A>`) into a single value (`B`).

```ts
declare function reduce<A, B>(
  f: (acc: B, current: A) => B,
  initialValue: B,
): (arr: Array<A>) => B
```

NOTE: *I changed the signature `of Array.reduce` to match the signature of Either's fold*.

We are going to use `fold` mostly as the way to consume an Either. Eg. after decoding an API response with io-ts you'll either dispatch a success action (`onRight`) or a failure one and report to Honeybadger the error (`onLeft`).

You'll see that most (if not all) of the algebraic types that fp-ts defines have their own version of `fold` 🔍

### `map`ing 🗺️

Once we have `fold` in our toolbelt we might be tempted to extract values out of Either every time we want to work with them.

What if I told you, you don't have to?

Just like `Array.map`, there's also `map` defined for Either.

```ts
// Array's map
declare function map<A, B>(f: (a: A) => B): (arr: Array<A>) => Array<B>

// Either's map
declare function map<A, B>(f: (a: A) => B): <E>(e: Either<E, A>) => Either<E, B>
```

NOTE: *I changed the signature of `Array.map` to match Either's one*.

As we can see, it allows us to transform the Right value of an Either by applying a function to its contents. If our value happens to be a Left, it won't be changed. And we can keep working happily with our wrapped value, no `fold`ing required.

What about transforming the Left value you ask? `mapLeft` to the rescue, and this time the unchanged one is the Right.

```ts
declare function mapLeft<E, G>(
  f: (e: E) => G,
): <A>(fa: Either<E, A>) => Either<G, A>
```

### Constructing Eithers 👷‍♂️

The last thing we need to know about Either is how to construct values.

```ts
import {left, right, Either} from 'fp-ts/lib/Either'

declare function left<E = never, A = never>(e: E): Either<E, A>

declare function right<E = never, A = never>(a: A): Either<E, A>

const aRight: Either<never, number> = right(123)

const aLeft: Either<string, never> = left('some error message')
```

## [Go Through The Pipes](https://www.youtube.com/watch?v=HioMxPJj59U)

Although strictly that's all we need from fp-ts to work with io-ts, we are also going to be using a few utilities it provides to work with functions. It's a FP library after all, right?

### pipe 🚿

This is one of the ways to do function composition in fp-ts. It let's us *pipe* a value through a list of functions, where the next function is called with the result of the previous one.

Take this case for example:

```ts
export const decodeWith = <A>(decoder: Decoder<unknown, A>) => (
  response: unknown,
) =>
  mapLeft((errors) => ({tag: 'decoding', errors} as const))(
    humanizeErrors(decoder.decode(response)),
  )
```

We decode a response, humanize the potential errors and then map the left to another type.

With pipe it would look like this:

```ts
import { pipe } from 'fp-ts/lib/pipeable';

export const decodeWith = <A>(decoder: Decoder<unknown, A>) => (
  response: unknown,
) =>
  pipe(
    response,
    decoder.decode,
    humanizeErrors,
    mapLeft((errors) => ({tag: 'decoding', errors} as const)),
  )
```

Now the code reads just like the description:

> decode a response, humanize the potential errors and then map the left to another type.

One good thing about pipe is, it's ready for when [the pipeline operator proposal](https://github.com/tc39/proposal-pipeline-operator) lands in JS. Sadly, judging by the pace TC39 works at, that might take years.

```diff
-import { pipe } from 'fp-ts/lib/pipeable';
-
 export const decodeWith = <A>(decoder: Decoder<unknown, A>) => (
   response: unknown,
 ) =>
-  pipe(
-    response,
-    decoder.decode,
-    humanizeErrors,
-    mapLeft((errors) => ({tag: 'decoding', errors} as const)),
-  )
+  response
+    |> decoder.decode
+    |> humanizeErrors
+    |> mapLeft(errors => ({ tag: 'decoding', errors } as const))
```

### flow ✉️

`flow` is right to left function composition. Very similar to pipe, but doesn't take the value as first argument but instead returns a function.

```diff
-import { pipe } from 'fp-ts/lib/pipeable';
+import { flow } from 'fp-ts/lib/function';
 
-export const decodeWith = <A>(decoder: Decoder<unknown, A>) => (
-  response: unknown,
-) =>
-  pipe(
+export const decodeWith = <A>(decoder: Decoder<unknown, A>) =>
+  flow(
-    response,
     decoder.decode,
     humanizeErrors,
     mapLeft((errors) => ({tag: 'decoding', errors} as const)),
   )
```

## That's it but there's more

As far as using io-ts, that's all we need to know about fp-ts (for now at least). If you are already bored, no need to keep on reading.

Although we could use fp-ts (and it's ecosystem) for many other things, this is a great start. By decoding all IO stuff (a.k.a. API responses) we make sure to remove unexpected runtime behavior and errors because we promised the compiler a `JSON.parse` returns something when in reality it doesn't.

If you see the value on it and want to learn more about (typed) FP check out the [Core Concepts](https://gcanti.github.io/fp-ts/introduction/core-concepts.html) and [Learning Resources](https://gcanti.github.io/fp-ts/introduction/learning-resources.html) sections in the fp-ts docs. And more importantly make sure to ask questions and look for other people that are in the path of learning about (typed) FP as well.

## No M word? 🌯

Somehow I managed to write about FP without using the word monad (well, now I did). That is because there was no need to do so. Even though Either is a monad, we didn't use any of it's monadic properties. We did use it as a Functor. A functor is an algebraic type that has `map` defined to it, which [has to abide some laws](https://wiki.haskell.org/Functor#Functor_Laws) to make sure every functor instance is consistent. You wouldn't want Either's map behaving differently than Array's map. Oh and yeah, Array is also a Functor.

Once again, learning these terms (monad, functor, applicative, foldable, *et al*) is not necessary. But, if you are interested, it can be really useful. For example, if you know that Array has map defined because it's a functor. And then discover a new algebraic type (like Either) that is also a functor you'll already know how to work with the map for that type.

---

Ok, now that's it.

**Happy and safe coding** 🤓


Originally posted on dev.to/gillchristian.



This is a small tutorial of what ...

Enough fp-ts to work with io-ts

# Lifting const 

*Originally posted on [dev.to/gillchristian](https://dev.to/gillchristian/lifting-const-1a3l)*.

![Lifting const ](https://res.cloudinary.com/practicaldev/image/fetch/s--YiVlidw2--/c_imagga_scale,f_auto,fl_progressive,h_420,q_auto,w_1000/https://thepracticaldev.s3.amazonaws.com/i/y9xvvsj06l36cacnoq3p.jpeg)

Yesterday I shared this gist:

[twitter https://twitter.com/gillchristian/status/1175878924926095360]

And I planned to expand on it today based on some assumptions I had:

[twitter https://twitter.com/gillchristian/status/1176126201234169860]

By playing around in GHCi I found out that my assumption was wrong.

![you are wrong meme](https://thepracticaldev.s3.amazonaws.com/i/4xth2mphqqvkptf1eir7.jpg)

So I did a bit of digging, by digging I mean [Hoogling](https://hoogle.haskell.org) the functions and checking their sources in Hackage, to understand why.

I found some interesting things.

Let's check [again](https://twitter.com/gillchristian/status/1173326782700953601?s=20) how the operator `(<*)` works.

```haskell
(<*) :: Applicative f => f a -> f b -> f a
```

As it is always the case in Haskell, the signature says a lot. It looks like it takes two applicatives and returns the first one.

```haskell
Just 1 <* Just 2 -- Just 1
```

And yes, that's right. But there's more...

It does not only return the first one discarting the second. Instead it "runs" both and returns the first one. How do we know it "runs" both? Because the semantic of such applicative (in this case Maybe) are *respected*:

```haskell
Nothing <* Just 1  -- Nothing
Just 1  <* Nothing -- Nothing
```

And that is the difference with `const`.

```haskell
Just 1  `const` Just 2  -- Just 1
Just 1  `const` Nothing -- Just 1
Nothing `const` Just 1  -- Nothing
```

When I said that `(<*)` is the "lifted" version of `const` I didn't mean *lifted* in the Haskell sence, I meant *lifted* as in the function was used in the context of an applicative. Well I guess that's kind of what *lifted* means, so let's try again. What I meant is that the signature was "the same" but in the applicative context (same semantics, always returning the first argument and discarting the second).

Turns out, `(<*)` is actually the "lifted" version of `const` (in the Haskell sense). Oh, and that's exactly the implementation in `base`.

```haskell
class Functor f => Applicative f where
    -- ...

    -- | Sequence actions, discarding the value of the second argument.
    (<*) :: f a -> f b -> f a
    (<*) = liftA2 const
```

*[See source in Hackage](https://hackage.haskell.org/package/base-4.12.0.0/docs/src/GHC.Base.html#%3C%2A)*

So what I was wrong about? 🤔

I assumed that if you *lifted* `const` it would still behave as the good ol' const.

```haskell
constA = liftA2 const

Just 1  `constA` Just 2  -- Just 1
Just 1  `constA` Nothing -- Just 1
Nothing `constA` Just 1  -- Nothing
```

Well, as we saw already, it doesn't. As I said it *respects* the semantics of the applicative.


```haskell
constA = liftA2 const

Just 1  `constA` Just 2  -- Just 1
Just 1  `constA` Nothing -- Nothing
Nothing `constA` Just 1  -- Nothing
```

Because that is the whole point of `liftA2`.

\* to be continued (whit a deeper look into `liftA2`).

*P.S. Yeah I used a "lifting" 🏋️ picture in a post about lifting. Sorry.*