Vitor Capela dodecaphonic

Generating collections of random numbers in PureScript

A problem that I've seen beginners run into in Haskell or PureScript a couple of times now is how to generate a List of random numbers. It's a common requirement for little games (which make for great first projects) to generate these, and it definitely seems to be a stumbling block.

Why are random numbers hard?

Randomness is considered a side effect in purely functional languages, which means that to generate them you usually need access to Eff/IO, which in turn means we need to deal with Monads. And while generating a single random number is usually pretty easy with do-notation, the typical intuition beginners have built when going from single values to a collection is to use map, but that fails.

Type-Directed-Search to the rescue

The original code (~7.2s on my laptop).

import System.Random
import System.CPUTime

rainfall :: [Int] -> Int
rainfall xs = sum (zipWith (-) mins xs)

Make it real

Ideas are cheap. Make a prototype, sketch a CLI session, draw a wireframe. Discuss around concrete examples, not hand-waving abstractions. Don't say you did something, provide a URL that proves it.

Ship it

Nothing is real until it's being used by a real user. This doesn't mean you make a prototype in the morning and blog about it in the evening. It means you find one person you believe your product will help and try to get them to use it.

	// Faster solution for:
	// http://www.boyter.org/2017/03/golang-solution-faster-equivalent-java-solution/
	// With threading.
	// g++ -std=c++11 -Wall -Wextra -O3 -pthread

	// On my computer (i5-6600K 3.50 GHz 4 cores), takes about ~160 ms after the CPU
	// has warmed up, or ~80 ms if the CPU is cold (due to Turbo Boost).

	// How it works: Start by generating a list of losing states -- states where the
	// game can end in one turn. Generate a new list of states by running the game

	#!/usr/bin/env zsh

	# in fino veritas

	# Borrowing shamelessly from these oh-my-zsh themes:
	# fino-time
	# pure
	# https://gist.github.com/smileart/3750104

	# Set required options

	// In real life, it's great that stuff gets restarted when it fails.
	// In testing, we'd rather know that it failed.

	import akka.actor._
	class DyingActor extends Actor {
	def receive = { case "die" => throw new Exception("poo") }
	}

	// Default config, everything restarts automatically
	val system = ActorSystem("ordinary")

	// Run this with scala <filename>

	/**
	* A Two-phase commit Monad
	*/
	trait Transaction[+T] {
	def map[U](fn: T => U): Transaction[U] = flatMap { t => Constant(fn(t)) }
	def flatMap[U](fn: T => Transaction[U]): Transaction[U] =
	FlatMapped(this, fn)

	;; HipChat

	(setq ssl-program-name "gnutls-cli"
	ssl-program-arguments '("--insecure" "-p" service host)
	ssl-certificate-verification-policy 1)

	;; Connect using jabber.el
	;; M-x jabber-connect <RET>

	;; Config

	$stack, $draws = [], {}

	def method_missing *args
	return if args[0][/^to_/]
	$stack << args.map { \|a\| a or $stack.pop }
	$draws[$stack.pop(2)[0][0]] = args[1] if args[0] == :<
	end

	class Array
	def +@