Chris A. bitemyapp

Probabilistic Data Structures for Web Analytics and Data Mining : A great overview of the space of probabilistic data structures and how they are used in approximation algorithm implementation.
Models and Issues in Data Stream Systems
Philippe Flajolet’s contribution to streaming algorithms : A presentation by Jérémie Lumbroso that visits some of the hostorical perspectives and how it all began with Flajolet
Approximate Frequency Counts over Data Streams by Gurmeet Singh Manku & Rajeev Motwani : One of the early papers on the subject.
[Methods for Finding Frequent Items in Data Streams](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.187.9800&rep

Don't use partial functions (head, read, tail, fromJust, fail (in IO), error, undefined ... )
Functions are your friend, use lots of them and keep them small.
Serialization errors are the most common error in our codebase. When you are creating a JSON, Binary or Serialize instance try and avoid the standard "generator" functions.

	module Main

	data Free : (f : Type -> Type) -> (a : Type) -> Type where
	Pure : a -> Free f a
	Bind : f (Free f a) -> Free f a

	instance Functor f => Functor (Free f) where
	map f (Pure x) = Pure (f x)
	map f (Bind x) = assert_total (Bind (map (map f) x))

	<!DOCTYPE html>
	<html>
	<head>

	<!-- Add leaflet css -->
	<link
	rel="stylesheet" href="https://unpkg.com/leaflet@1.5.1/dist/leaflet.css"
	integrity="sha512-xwE/Az9zrjBIphAcBb3F6JVqxf46+CDLwfLMHloNu6KEQCAWi6HcDUbeOfBIptF7tcCzusKFjFw2yuvEpDL9wQ=="
	crossorigin=""
	/>

	{-# LANGUAGE MultiWayIf #-}

	module Main where

	import Control.Monad.IO.Class (liftIO)
	import Data.Conduit (($$), (=$=), (=$)
	, Conduit, Sink, Source
	, await, yield)
	import qualified Data.Conduit.List as CL
	import Data.Sequence

	{-
	DPLL from the textbook:

	function DPLL(clauses, symbols, model ) returns true or false
	if every clause in clauses is true in model then return true
	if some clause in clauses is false in model then return false
	P , value ← FIND-PURE-SYMBOL (symbols, clauses, model )
	if P is non-null then return DPLL(clauses, symbols – P , model ∪ {P =value})
	P, value ← FIND-UNIT-CLAUSE (clauses, model)
	if P is non-null then return DPLL(clauses, symbols – P , model ∪ {P =value})

	-- This file is a parsing experiment
	-- Copyright (C) 2015 Fraser Tweedale
	--
	-- This software is free software: you can redistribute it and/or modify
	-- it under the terms of the GNU Affero General Public License as published by
	-- the Free Software Foundation, either version 3 of the License, or
	-- (at your option) any later version.
	--
	-- This program is distributed in the hope that it will be useful,
	-- but WITHOUT ANY WARRANTY; without even the implied warranty of

	{-# LANGUAGE NoMonomorphismRestriction #-}
	{-# LANGUAGE OverloadedStrings #-}
	module Data.Yaml.Extended (module Data.Yaml.Extended, lift) where

	import Data.Aeson.Types
	import qualified Data.Text as T
	import Control.Monad.State.Strict (StateT, runStateT, unless, lift, get, modify)
	import qualified Data.HashMap.Strict as HM (null, delete, keys)
	import Data.List (intercalate)


	--
	import Data.Map.Lazy
	import Control.Lens

	-- We wanted to traverse a structure, but not recompute the function for duplicate keys. And then we also needed cache.
	-- It's probably tricky to unlens this.

	traverseMemoOf :: (Ord a, Monad f) => Traversal s t a b -> (a -> f b) -> s -> f (t, ML.Map a b)
	traverseMemoOf l f z =

	{-# LANGUAGE LambdaCase #-}
	module Main where

	import Control.Applicative (liftA2)
	import Control.Monad.Reader

	type Varname = String
	type Env = [(Varname, Dom)]

	data Dom