gfixler

#!/usr/bin/env stack
{- stack --resolver lts-7.13 --install-ghc runghc -}

import Data.Maybe (mapMaybe)
import System.Environment (getArgs)

song :: Int -> Maybe String
song 1 = Just "A Shandy Too Far"
song 2 = Just "Adult Contemporary"
song 3 = Just "Air Guitar"

gfixler

-- Clojure -> Haskell port of: https://gist.github.com/nasser/1db446782cf7f3587283

import System.Random (getStdRandom, randomR)

pick :: [a] -> IO a
pick xs = do
    n <- getStdRandom $ randomR (0, length xs - 1)
    return $ xs !! n

adjs = ["people's", "brave", "invincible", "unstoppable", "righteous", "just", "honorable", "terrifying", "peaceful"]

gfixler

newtype MaybeIO a = MaybeIO (IO (Maybe a))

runMaybeIO :: MaybeIO a -> IO (Maybe a)
runMaybeIO (MaybeIO x) = x

hole = undefined
data Hole = Hole

instance Monad MaybeIO where
    return x = MaybeIO (return (Just x))

gfixler

data MyState s a = MyState (s -> (a, s))

get :: MyState s s
get = undefined

put :: s -> MyState s ()
put = undefined

modify :: (s -> s) -> MyState s ()
modify = undefined

gfixler

bottles :: Int -> String
bottles x | x == 0    = "No more bottles"
          | x == 1    = "1 more bottle"
          | x < 13    = show x ++ " more bottles"
          | otherwise = show x ++ " bottles"

verse :: Int -> String
verse x = line1 ++ "\n" ++ line2 ++ "\n\n"
    where line1  = bottles x ++ obotw ++ " " ++ bottles x ++ ob
          line2  = todpia ++ bottles (x-1) ++ obotw

gfixler

import Data.List (sortBy)
import Data.Ord (comparing)
import qualified Data.Map as M (Map, fromList)

data Freq a = V Int a | B Int (Freq a) (Freq a) deriving (Show)

size :: Freq a -> Int
size (V n _)   = n
size (B n _ _) = n

gfixler

import Control.Applicative ((<|>))

type Bonus = Int

data Frame = Roll Int | Frame Int Int | Spare Int | Strike deriving (Show)

badnum :: Int -> Bool
badnum n = n < 0 || n > 10

strike, spare, frame :: [Int] -> Maybe (Frame, Bonus, [Int])

gfixler

Here's a purely-functional take on collecting rolls (no scoring yet)

First a data type to represent the 4 states a frame can be in:

> data Frame = Roll Int | Open Int Int | Spare Int | Strike deriving (Show)

This just simplifies bounds-checks on input roll values:

> badnum :: Int -> Bool
> badnum n = n < 0 || n > 10

gfixler

import Data.List     ( transpose )
import Data.Monoid   ( Monoid, mempty, mappend )
import System.IO     ( BufferMode(NoBuffering)
                     , hSetBuffering, hSetEcho
                     , stdin, stdout, getChar
                     )
import Control.Monad ( forM_ )

newtype StdVal = StdVal Int deriving (Eq)
type Board a = [[a]]

gfixler

# The gitup function lets you type `gitup` from anywhere
# in a repo to upload it to your server. It also sets it
# up as an origin remote in the local repo. This is meant
# to be used in a new repo that has no server version yet.
# Note: I have the gitup function in my ~/.bashrc file.

# Modify these two 'example.com' vars as needed:
gitup_scp='example.com:git'
gitup_root='ssh://example.com/~/git/'