Louis Pilfold lpil

I hereby claim:

To claim this, I am signing this object:

Pull Request Guidelines

Good code is tested, designed for change, easy to understand and able to cope when things go wrong.

Good pull requests are descriptive, small and short-lived.


	## DecodeBench
	benchmark name iterations average time
	decode (small) (jiffy) 500000 117.63 µs/op
	decode (small) (jsone) 200000 199.21 µs/op
	decode (small) (tiny) 200000 216.86 µs/op
	decode (small) (poison) 100000 225.53 µs/op
	decode (small) (jason) 100000 228.00 µs/op
	decode (small) (jsx) 100000 297.11 µs/op
	decode (large) (jiffy) 50 612494.88 µs/op

	var elm$core$Basics$never = function (_n0) {
	never:
	while (true) {
	// Stuff here
	}
	};

	defmodule Web do
	require Logger

	@behaviour :elli_handler

	def handle(r, _args) do
	Router.handle(:elli_request.method(r), :elli_request.path(r), r)
	rescue
	exception ->
	Logger.error(inspect(exception))

	# Given methods that return Results...

	get_params
	.and_then(method(:validate_params))
	.and_then(method(:save_record))
	.and_then(method(:send_email))
	.match(ok: method(:render_success),
	error: method(:render_failure))

	require 'result/ok'
	require 'result/error'

	#
	# A generic representation of success and failure.
	#
	# Styled after the Result monad of Elm and Rust
	# (or the Either monad of Haskell).
	#
	# The `#and_then` method can be used to chain functions that

	module Main where

	import Prelude
	import Control.Monad.Eff.Console
	import Data.Foldable (foldl)
	import Data.String as String
	import Data.Char as Char
	import Data.List as List
	import Data.List (List(Nil), (:))
	import Data.Array as Array

	export function makeAnimal({ name, size }) {
	const sayHello = () => `Hello, I'm ${name}`;

	const isBigger = (other) => size > other.size;

	return Object.freeze({
	sayHello,
	isBigger,
	size,
	});