tonymorris

;; Pure functional I/O using clojure
;; =================================
;;
;; Defines a grammar of three operations in `defrecord Operation` using the free monad technique
;; 1. read file
;; 2. write file
;; 3. print to standard output
;;
;; Defines I/O operations by combining the Operation grammar in `defrecord IO`
;;

tonymorris

skipRight ::  
  (a -> [a] -> ([a] -> b) -> b)
  -> b
  -> [a]
  -> b
skipRight _ z [] =
  z
skipRight f z (h:t) =
  f h t (skipRight f z)

tonymorris

import Control.Applicative(Alternative(..), liftA2)

newtype ValidationT f a b =
  ValidationT (f (Either a b))

instance Functor f => Functor (ValidationT f a) where
  fmap f (ValidationT x) =
    ValidationT (fmap (fmap f) x)

instance Applicative f => Applicative (ValidationT f a) where

tonymorris

#!/usr/bin/env runhaskell

module Main where

import Text.Printf(printf)
import Data.List(intercalate)
import Data.Bool (bool)

kg2lb =
  (*2.2)

tonymorris

import Data.Monoid

-- This code doesn't work... 
-- How can you make a multi-parameter data type be Foldable?

-- foldMap over `a` so it can be converted to a Monoid
data BinaryTree3 a v
  = Node3 a (BinaryTree3 a v) (BinaryTree3 a v)
  | Leaf3 a v
  deriving (Show)

tonymorris

#!/usr/bin/env runhaskell

import Text.Printf

fromRadian a = a / pi * 180
toRadian a = a / 180 * pi
showDiff :: Int -> String
showDiff x =
  let x' = toRadian (fromIntegral x)
      diff = fromRadian (x' - sin x')

tonymorris

#!/usr/bin/env runhaskell

{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE DeriveFoldable #-}

import Data.Foldable
import Text.Printf

data Point a =
  Point {

tonymorris

data LSystem a b =
  LSystem
    [a]
    (a -> [b])

type LSystem' a =
  LSystem a a

instance Functor (LSystem a) where
  fmap k (LSystem a f) =

tonymorris

f :: Store a b -> Store a (Store a b)
f s =
  let (set, get) = runStore s
  in  store (store set) get

tonymorris

{-# OPTIONS_GHC -Wall #-}
{-# LANGUAGE TemplateHaskell #-}

import Control.Lens

data These a b =
  This a
  | That b
  | Both a b
  deriving (Eq, Show)