Juan Bono juanbono

Refactoring with type classes and optics

Often when writing programs and functions, one starts off with concrete types that solve the problem at hand. At some later time, due to emerging requirements or observed patterns, or just to improve code readability and reusability, we refactor to make our code more polymorphic. The importance of not breaking your API typically ranges from nice to have (e.g. minimises rework but not essential) to paramount (e.g. in a popular, foundational library).

Existential Types in Haskell

I had always been confused by Haskell's implementation of existential types. Until now!

Existential types is the algebraic data type (ADT) equivalent to OOP's data encapsulation. It's a way of hiding a type within a type. Hiding it in such a way that any consumer of the data type won't have any knowledge on the internal property

Comprehensive Introduction to @ngrx/store

By: @BTroncone

Also check out my lesson @ngrx/store in 10 minutes on egghead.io!

Update: Non-middleware examples have been updated to ngrx/store v2. More coming soon!

Table of Contents

2016

2015

The introduction to Reactive Programming you've been missing

(by @andrestaltz)

This tutorial as a series of videos

If you prefer to watch video tutorials with live-coding, then check out this series I recorded with the same contents as in this article: Egghead.io - Introduction to Reactive Programming.

	{-# LANGUAGE TypeFamilies #-}
	{-# LANGUAGE DataKinds #-}
	{-# LANGUAGE GADTs #-}
	{-# LANGUAGE TypeOperators #-}
	{-# LANGUAGE PolyKinds #-}
	{-# LANGUAGE UndecidableInstances #-}
	{-# LANGUAGE ConstraintKinds #-}

	import Data.Constraint
	import Data.Function


	module type Monad = sig

	type 'a t
	val return: 'a -> 'a t
	val bind: 'a t -> ('a -> 'b t) -> 'b t


	end

	{-# START_FILE {{name}}.cabal #-}
	name: {{name}}
	version: 0.1.0.0
	synopsis: Initial project template from stack
	description: Please see README.md
	license: GPL-3
	license-file: LICENSE
	author: {{author-name}}{{^author-name}}Author name here{{/author-name}}
	maintainer: {{author-email}}{{^author-email}}[email protected]{{/author-email}}
	copyright: {{copyright}}{{^copyright}}{{year}}{{^year}}2017{{/year}} {{author-name}}{{^author-name}}Author name here{{/author-name}}{{/copyright}}


	(* Good morning everyone, I'm currently learning ocaml for one of my CS class and needed to implement
	an avl tree using ocaml. I thought that it would be interesting to go a step further and try
	to verify the balance property of the avl tree using the type system. Here's the resulting code
	annotated for people new to the ideas of type level programming :)
	*)

	(* the property we are going to try to verify is that at each node of our tree, the height difference between
	the left and the right sub-trees is at most of 1. *)

	(* -- mode: ocaml; -- *)

	module type FUNCTOR = sig
	type 'a t
	val map : ('a -> 'b) -> 'a t -> 'b t
	end

	type 'a monoid = {unit : 'a ; join : 'a -> 'a -> 'a}

	type var = string