Håkon Rossebø hakonrossebo

Railway Oriented Programming and F# Result

Full source: https://gist.github.com/mrange/aa9e0898492b6d384dd839bc4a2f96a1

Option<_> is great for ROP (Railway Oriented Programming) but we get no info on what went wrong (the failure value is None which carries no info).

With the introduction F# 4.1 we got Result<_, _> a "smarter" Option<_> as it allows us to pass a failure value.

However, when one inspects the signature of Result.bind one sees a potential issue for ROP:

Functional Track talks from NDC London 2017

Also, here is the list of all videos from NDC London 2017:

Wednesday 2017-01-18

Elm best practices

Style guide

Applied Functional Programming with Scala - Notes

1. Mastering Functions

A function is a mapping from one set, called a domain, to another set, called the codomain. A function associates every element in the domain with exactly one element in the codomain. In Scala, both domain and codomain are types.

val square : Int => Int = x => x * x

Star this gist to see the talk at ReactiveConf 2016.
Retweet to spread the word.
Have a look at this blog post to see other proposals.
Try elm-search to see what this is all about.

An API search engine in Elm for Elm

Elm is a statically typed functional language that compiles to JavaScript. It's well-known for its developer experience: the compiler provides nice error messages, the package system enforces semantic versioning for all published packages and makes sure every exposed value or type has some documentation and type annotations.

	from ubuntu:latest

	run apt-get update && \
	apt-get install -y emacs agda-mode agda-stdlib && \
	apt-get install -y coq coqide && \
	apt-get install -y openssh-server && \
	apt-get install -y iproute2 wget curl && \
	apt-get install -y bzip2 tmux git vim libgmp-dev python3 gcc libtinfo-dev zlib1g-dev xz-utils make && \
	git config --global core.editor vim && \
	git config --global alias.co checkout && \

	module Editable exposing (..)


	type Editable ofType
	= NotEditing { value : ofType }
	\| Editing { originalValue : ofType, buffer : ofType }


	value : Editable ofType -> ofType
	value editable =

	-- ## An Elm-entary visualisation
	-- by _Tom Harding_

	module Main exposing (..)

	-- This project uses a few dependencies. To anyone who's written any
	-- amount of Elm before, the only stranger is `AnimationFrame`, from
	-- the `elm-lang/animation-frame` package. This lets us subscribe to
	-- the browser's RAF API. Everything else should be fairly obvious:
	-- `Html` / `Svg` for our view, `Http` / `Json.Decode` for the AJAX

	module Flow exposing (Flow(..), map, withDefault, mapDefault, view, update)

	import Html


	type Flow state
	= NotRunning
	\| Running state

	(*
	Example of domain-driven design for Checkers
	Rules from here: https://www.itsyourturn.com/t_helptopic2030.html

	A SERIES OF SCRATCH DESIGNS
	*)

	// As we go through the rules, and learn things, we create a series of designs

	module Version1 =