Homework 2

Type classes

This homework is written in literate Haskell; you can download the raw source to fill in yourself. You’re welcome to submit literate Haskell yourself, or to start fresh in a new file, literate or not.

Please submit homeworks via the new submission page.

This will be our first of three “pair programming” homeworks, where I expect you and your partner to do the work together, submitting a single file listing both collaborators. It doesn’t matter who initiaties the upload as long as everyone is on the list.

In this homework, we’re going to use Haskell more earnestly. We’ll start using some of its standard library’s functions and datatypes—we’ll even try defining our own datatypes.

Unless I say otherwise, you’re free to use any functions from the Prelude.

module Hw02 where

Problem 1: arithmetic expressions

Our first language will be a simple one: arithmetic expressions using +, *, and negation.

data ArithExp =
    Num Int
  | Plus ArithExp ArithExp
  | Times ArithExp ArithExp
  | Neg ArithExp

(a) 5 points

Write a Show instance for ArithExp, which amounts to a function show :: ArithExp -> String. You do not need to write type signatures for functions in type class instances.

Your function should print a parseable expression, i.e., one that you could copy and paste back in to Haskell to regenerate the original term. For example, show (Num 5) should yield the string "Num 5", while show (Neg (Plus (Num 1) (Num 1))) should yield the string "Neg (Plus (Num 1) (Num 1))".

instance Show ArithExp where
  show = undefined

(b) 5 points

Write an Eq instance for ArithExp, defining a function (==) :: ArithExp -> ArithExp -> Bool; use the standard “equal structures are equal” interpretation.

instance Eq ArithExp where
  e1 == e2 = undefined

(c) 10 points

We’re going to write an interpreter, which takes an arithmetic expression and evaluates it to a number. The general strategy here is the same as when we wrote naturally recursive functions over lists: break down each case of the datatype definition and use recursion on subparts.

For example, eval (Plus (Num 42) (Neg (Num 42))) should yield 0.

-- | Tests for arithmetic evaluation. Write your own!
-- >>> eval (Plus (Num 42) (Neg (Num 42)))
-- 0
eval :: ArithExp -> Int
eval = undefined

(d) 10 points

Let’s extend our language to support subtraction—now we’re really cooking! Note that we let Haskell derive a “parseable” show instance for us.

data ArithExp' =
    Num' Int
  | Plus' ArithExp' ArithExp'
  | Sub' ArithExp' ArithExp'
  | Times' ArithExp' ArithExp'
  | Neg' ArithExp'
  deriving Show

But wait: we should be able to encode subtraction using what we have, giving us a very nice evaluation function.

eval' :: ArithExp' -> Int
eval' = eval . translate

Write a function that will translate this extended language to our original language—make sure that eval' does the right thing.

translate :: ArithExp' -> ArithExp
translate = undefined

(e) 5 points

Write a non-standard Eq instance for ArithExp', where e1 == e2 iff they evaluate to the same number, e.g., (Num' 2) == (Plus' (Num' 1) (Num' 1)) should return `True.

instance Eq ArithExp' where
  e1 == e2 = undefined

Write a non-standard Ord instance for ArithExp' that goes with the Eq instance, i.e., e1 < e2 iff e1 evaluates to a lower number than e2, etc.

instance Ord ArithExp' where
  compare e1 e2 = undefined

Problem 2: Setlike (10pts)

Here is a type class Setlike. A given type constructor f, of kind * -> *, is Setlike if we can implement the following methods for it. (See Listlike in the notes for lecture.)

class Setlike f where
  emp :: f a

  singleton :: a -> f a

  union :: Ord a => f a -> f a -> f a
  union = fold insert

  insert :: Ord a => a -> f a -> f a
  insert = union . singleton

  delete :: Ord a => a -> f a -> f a
  delete x s = fold (\y s' -> if x == y then s' else insert y s') emp s

  isEmpty :: f a -> Bool
  isEmpty = (==0) . size

  size :: f a -> Int
  size = fold (\_ count -> count + 1) 0

  isIn :: Ord a => a -> f a -> Bool
  isIn x s = maybe False (const True) $ getElem x s

  getElem :: Ord a => a -> f a -> Maybe a

  fold :: (a -> b -> b) -> b -> f a -> b

  toAscList :: f a -> [a] -- must return the list sorted ascending
  toAscList = fold (:) []

In the rest of this problem, you’ll define some instances for Setlike and write some code using the Setlike interface. Please write the best code you can. Setlike has some default definitions, but sometimes you can write a function that’s more efficient than the default. Do it. Write good code.

Hint: look carefully at the types, and notice that sometimes we have an Ord constraint and sometimes we don’t. I did that deliberately… what am I trying to tell you about how your code should work?

Define an instance of Setlike for lists. Here’s an example that should work when you’re done—it should be the set {0,2,4,6,8} (note that I’m using math notation for sets—yours will probably print out as a list)..

-- |
-- >>> 6 `isIn` evensUpToTen
-- True
-- >>> 42 `isIn` evensUpToTen
-- False
evensUpToTen :: [Int]
evensUpToTen = foldr insert emp [0,2,4,6,8]

Here’s a type of binary trees. Define a Setlike for BSTs, using binary search algorithms. Write good code. I expect insertion, lookup, and deletion to all be O(log n). No need to do any balancing, though.

data BST a = Empty | Node (BST a) a (BST a)

Write Eq and Show instances for BSTs. These might be easier to write using the functions below. Keep in mind what a programmer might expect out of these definitions: if BSTs are being used for sets (and maps, below), what notion of equality might we want for them?

instance Ord a => Eq (BST a) where
  s1 == s2 = undefined
instance Show a => Show (BST a) where
  show = undefined

Write the following set functions. You’ll have to use the Setlike interface, since you won’t know which implementation you get.

fromList should convert a list to a set.

fromList :: (Setlike f, Ord a) => [a] -> f a
fromList = undefined

difference should compute the set difference: X - Y = { x in X | x not in Y }.

difference :: (Setlike f, Ord a) => f a -> f a -> f a
difference xs ys = undefined

subset should determine whether the first set is a subset of the other one. X ⊆ Y iff ∀ x. x ∈ X implies x ∈ Y.

subset :: (Setlike f, Ord a) => f a -> f a -> Bool
subset xs ys = undefined

Problem 3: maps from sets (10pts)

Finally, let’s use sets to define maps—a classic data structure approach.

We’ll define a special notion of key-value pairs, KV k v, with instances to force comparisons just on the key part.

newtype KV k v = KV { kv :: (k,v) }

instance Eq k => Eq (KV k v) where
  (KV kv1) == (KV kv2) = fst kv1 == fst kv2

instance Ord k => Ord (KV k v) where
  compare (KV kv1) (KV kv2) = compare (fst kv1) (fst kv2)

instance (Show k, Show v) => Show (KV k v) where
  show (KV (k,v)) = show k ++ " |-> " ++ show v
type Map f k v = f (KV k v)
type ListMap k v = Map [] k v
type TreeMap k v = Map BST k v

Now define the following map functions that work with Setlike.

-- |
-- >>> find 5 (emptyMap :: TreeMap Int Bool)
-- Nothing
-- >>> find 5 (extend 5 True (emptyMap :: TreeMap Int Bool))
-- Just True
-- >>> find 5 (extend 5 True (extend 5 False (emptyMap :: TreeMap Int Bool)))
-- Just True

emptyMap :: Setlike f => Map f k v
emptyMap = undefined

find :: (Setlike f, Ord k) => k -> Map f k v -> Maybe v
find k m = undefined

extend :: (Setlike f, Ord k) => k -> v -> Map f k v -> Map f k v
extend k v m = undefined

remove :: (Setlike f, Ord k) => k -> Map f k v -> Map f k v
remove k m = undefined

toAssocList :: Setlike f => Map f k v -> [(k,v)]
toAssocList = undefined

You’ll have to think hard about what to do for find and remove… what should v be?

Problem 4: functors (15pts)

(a) 5pts

The n-ary tree, trie, or rose tree data structure is a tree with an arbitrary number of children at each node. We can define it simply in Haskell:

data RoseTree a = Leaf a | Branch [RoseTree a] deriving (Eq, Show)

(Note that this definition subtly disagrees with the Wikipedia definition of rose trees by (a) having values at the leaves and (b) not having values at the nodes.)

Define a Functor instance for RoseTree.

instance Functor RoseTree where
  fmap = undefined

(b) 5pts

Define a Functor instance for BST.

Give an example of a buggy behavior for your instance: this can either be a violation of the Functor laws, or something else. Explain what the issue is.

(c) 5pts

What does the following function do? Explain it as best you can. Does it have a name in the Prelude?

mystery :: Functor f => b -> f a -> f b
mystery = fmap . const

Now rewrite it to use variable names, without any partial application.

mystery_rewrite :: Functor f => b -> f a -> f b
mystery_rewrite = undefined