Mauricio Scheffer mausch

Introduction to scalaz-stream

Every application ever written can be viewed as some sort of transformation on data. Data can come from different sources, such as a network or a file or user input or the Large Hadron Collider. It can come from many sources all at once to be merged and aggregated in interesting ways, and it can be produced into many different output sinks, such as a network or files or graphical user interfaces. You might produce your output all at once, as a big data dump at the end of the world (right before your program shuts down), or you might produce it more incrementally. Every application fits into this model.

The scalaz-stream project is an attempt to make it easy to construct, test and scale programs that fit within this model (which is to say, everything). It does this by providing an abstraction around a "stream" of data, which is really just this notion of some number of data being sequentially pulled out of some unspecified data source. On top of this abstraction, sca

Extending a 3rd-party API with F# units of measure

F# units of measure are nice, but what if I'm using a 3rd-party library which doesn't support UOM? I don't want to re-implement the library, but it would be nice to add the extra safety afforded by UOM. Can I somehow annotate the APIs of the 3rd party library with units?

Yes!

How to do it

Say you have some unit-free external library like this, which you can't modify:

	using System;

	namespace SomeUnit {
	public class AssertHelper {
	public static AssertHelper Assert { get; } = new AssertHelper();
	}
	}

	namespace SomeUnit.Extensions {
	public static class AssertExtensions {

	var Class = function (name, ifaces, foldl1_acc) {
	return { name: name
	, ifaces: ifaces
	, foldl1_acc // this is my magic trick! :) but is not generic :(
	};
	};
	var Type = function ( name
	, product // Type1 x Type2 x ... x TypeN
	) {
	var type = { name: name

	// Let `Int` instancing `Eq`, `Ord` and `Show` classes, then:

	var n = function (x) { return Int.make(x) }; // alias

	// testing Int type
	console.log( n(4).equalTo(n(5)) ); // false
	console.log( n(3).equalTo(n(3)) ); // true
	console.log( n(4).compareTo(n(5)) ); // -1
	console.log( n(5).compareTo(n(3)) ); // 2
	console.log( n(2).compareTo(n(2)) ); // 0

	//==========================================
	// Working fully self-contained getting-started example for Suave Web Server scripting
	//
	// Note you don't need to have _anything_ installed before starting with this script. Nothing
	// but F# Interactive and this script.
	//
	// This script fetches the Paket.exe component which is referenced later in the script.
	// Initially the #r "paket.exe" reference is shown as unresolved. Once it has been
	// downloaded by the user (by executing the first part of the script) the reference
	// shows as resolved and can be used.

	[supervisord]
	nodaemon=true
	loglevel=debug

	[program:amon]
	command=gunicorn -c gunicorn.conf.py wsgi
	directory=/amon
	autostart=true
	autorestart=true
	redirect_stderr=true

	#Downloads latest paket.bootstrapper.exe from github
	$urlbase = "https://github.com"
	$latestPage="$urlbase/fsprojects/Paket/releases/latest"
	Write-Host "Parsing latest release page: $latestPage"
	$page=Invoke-Webrequest -uri $latestPage
	$latestBootStrapper=($page.Links \| Where-Object { $_.href -match "bootstrapper" }).href

	$dlurl="$urlbase$latestBootStrapper"
	Write-Host "Downloading paket.bootstrapper.exe from $dlurl"

	{-# LANGUAGE GADTs, MultiParamTypeClasses, FunctionalDependencies, FlexibleInstances, UndecidableInstances, FlexibleContexts, OverlappingInstances, ScopedTypeVariables #-}
	-- The goal of the code below is to emulate OO method dispatch.
	--
	-- The use-case is binding to a C++ GUI framework that is heavily OO and
	-- providing the user with a familiar experience.
	--
	-- This scheme sketched out below emulates not only OO style method dispatch
	-- but also allows users to "sub-class", "override" and even arbitrarily
	-- change the type signature of overridden methods, all without touching the
	-- original library code.

	{-# LANGUAGE FlexibleContexts #-}
	{-# LANGUAGE ScopedTypeVariables #-}
	{-# LANGUAGE UndecidableInstances #-}
	{-# LANGUAGE GeneralizedNewtypeDeriving #-}
	{-# LANGUAGE StandaloneDeriving #-}
	module Approx where
	import Data.Reflection
	import Data.Proxy
	import Foreign.Storable