hellertime

mux :: [a] -> [a] -> [a]
mux = muxl

muxl :: [a] -> [a] -> [a]
muxl [] [] = []
muxl xs [] = xs
muxl [] ys = ys
muxl (x:xs) ys = x : muxr xs ys

muxr :: [a] -> [a] -> [a]

hellertime

newtype Degree = Degree Float
newtype Radian = Radian Float

toRadian :: Degree -> Radian
toRadian deg = Radian $ (fromDegree deg) * (pi / 180)

fromRadian :: Radian -> Float
fromRadian (Radian x) = x

toDegree :: Radian -> Degree

hellertime

http://bostinno.com/channels/how-to-write-a-startup-marketing-plan/:

A startup Marketing Plan “Moltke-style” starts with defining 6 terms that are too often conflated by young marketers:

• goal – what we hope to achieve.
• objective – how we will measure success in reaching our goal.
• strategy – an approach we think will meet our objective.
• tactic – execution to convert our strategy into action.
• program – a collection of related tactics.
• plan – what needs to be done when, given the above.

hellertime

import itertools

def ngrams(xs, f = None, n = 3):
    ts = itertools.tee(xs, n)
    for i, t in enumerate(ts[1:]):
        for _ in xrange(i + 1):
            next(t, None)
    return map(f, itertools.izip(*ts))

hellertime

AH_VERBATIM([PORTABLE_BYTE_SWAP_FUNCTIONS],
[/* Standardize on a byte-swap function naming */
#if defined(__linux__)
#  include <endian.h>
#elif defined(__FreeBSD__) || defined(__NetBSD__)
#  include <sys/endian.h>
#elif defined(__OpenBSD__)
#  include <sys/types.h>
#  define be16toh(x) betoh16(x)
#  define be32toh(x) betoh32(x)

hellertime

#!/bin/sh
# Needed to rename a directory chock full o' files (don't ask).
# First thought?

find . -type f -exec rename 's/(\d+).(foo|bar|baz).(\d+).txt/$1.$3.$2.txt/' +

# Result? Horrible! 
# Not sure what was going on, but between find batching the arguments to rename, 
# and rename pausing after each batch, run-time was approaching 4 hours+!
#

hellertime

intervals :: (Eq a, Enum a) => [a] -> [(a, Maybe a)]
intervals []     = []
intervals (x:[]) = [(x, Nothing)]
intervals (x:xs) = (x, lastSuccessor x x xs) : intervals (dropSuccessors x xs)
  where
    lastSuccessor :: (Eq a, Enum a) => a -> a -> [a] -> Maybe a
    lastSuccessor l x []
        | l == x                  = Nothing
        | otherwise               = Just x
    lastSuccessor l x (y:ys)

hellertime

import sys
# requires Python 2.5
assert sys.version_info[1] >= 5, "Requires Python Coroutines. See PEP 0342"

def pushbackiter(iterator):
    """converts 'iterator' into a coroutine, with limited pushback

    >>> it = pushbackiter([1,2,3,4,5])
    >>> it.next()
    1

hellertime

> import Control.Exception ( handle, IOException )

here is a specialize handle which deals with IOExceptions

> handleIO :: (IOException -> IO a) -> IO a -> IO a
> handleIO = handle

Without this added signature you will get type-check errors like this:

    Ambiguous type variable `e' in the constraint:

hellertime

> import Distribution.Simple

This is an example Setup.hs for a haskell program making use of HaskellDB.

> import System.Directory ( removeFile, removeDirectoryRecursive )

HaskellDB needs to have the structure of all database tables laid out as data. 

> import Database.HaskellDB
> import Database.HaskellDB.DBSpec