===== Abstract Datatypes =====

==== Intro ====

An Abstract Datatype relies on //functions// to describe the possible values of a type. We start with a simplistic example:

<code haskell>
data Nat = Zero | Succ Nat
</code>
  * the expression ''data Nat'' introduces a new **type** in the programming language
  * after ''='', the **base constructors** of the type follow. In Haskell, **all constructors** must begin with a capital letter
  * ''Zero'' is a nullary constructor. 
  * ''Succ Nat'' designates an **internal** constructor, which expects a natural number (of type ''Nat''). A value ''(Succ x)'' **is** of type ''Nat'' (i.e. a natural number), and we may be tempted to see it as a function call, which //returns// the successor of ''x''

''Zero'' and ''Succ'' are called **data constructors** in Haskell. ''Nat'' is called a ''type'' or ''type-constructor''. We shall distinguish between the two in a later lecture.

Note that the //internal// representation of an ADT, as perceived by the programmer, is //abstract//. We may see values as //calls// of special functions - data constructors. Except for their meaning (and language-level implementation), data constructors behave exactly as functions. For instance:
  * ''Zero :: Nat''
  * ''Succ :: Nat -> Nat''

We continue the example with addition:

<code haskell>
add :: Nat -> Nat -> Nat
add Zero y = y
add (Succ x) y = Succ (add x y)
</code>

An important observation is that the **pattern matching mechanism** in Haskell relies on data constructors, and their applications. For instance, the following definition is a correct usage of the pattern matching mechanism:
<code haskell>
f (1:y:[]) = ...
</code>
I uses the data constructors ''(:)'' and ''[]'' for lists, as well as the data constructor ''1'' for integers. The pattern describes any list of integers which starts with a ''1'' and contains exactly two elements.

==== Monomorphic List implementation ====

In what follows, we give an implementation for the type //List of integers//. This type is called //monomorphic//, since our list can only contain elements of a single type (integer):

<code haskell>
data IList = Void | Cons Integer IList

app :: IList -> IList -> IList
app Void l = l
app (Cons h t) l = Cons h (app t l)

convert :: IList -> [Integer]
convert Void = []
convert (Cons h t) = h : (convert t)

mfoldl :: (b -> Integer -> b) -> b -> IList -> b
mfoldl op acc Void = acc
mfoldl op acc (Cons h t) = mfoldl op (op acc h) t

mfoldr :: (Integer -> a -> a) -> a -> IList -> a
mfoldr op acc Void = acc
mfoldr op acc (Cons h t) = op h (mfoldr op acc t)

convert2 :: IList -> [Integer]
convert2 = mfoldr (:) []

showl :: IList -> String
showl = show . convert2

</code>

In the above code, we have defined some basic list operations, such as ''app'' (list concatenation) and ''convert'', which transforms a list of type ''IList'' to a conventional Haskell list (of type ''[Integer]'').

We have also implemented the two folding procedures for ''IList''. Note the type signature of each fold. Finally, we have used folds to provide an alternative implementation for convert, as well as for converting lists to strings.


==== Propositional Logic in Haskell ====

Abstract Datatypes are a natural way to define more elaborate data-structures, such as propositional formulae. We give a possible definition below:

<code haskell>
data Formula = Var String | And Formula Formula | Or Formula Formula | Not Formula
</code>

We observe that:
  * ''Var :: String -> Formula''
  * ''And :: Formula -> Formula -> Formula''
  * ''Or :: Formula -> Formula -> Formula''
  * ''Not :: Formula -> Formula''

A good exercise consists in the implementation of a display function for formulae:
<code haskell>
fshow :: Formula -> String
fshow (Var v) = v
fshow (And f1 f2) = "("++(fshow f1)++" ^ "++(fshow f2)++")"
fshow (Or f1 f2) = "("++(fshow f1)++" V "++(fshow f2)++")"
fshow (Not f) = "~("++(fshow f)++")"
</code>

Next, we implement a function ''push'', which pushes negation //inward//:
<code haskell>
push :: Formula -> Formula
push (Var v) = (Var v)
push (Not (Var v)) = Not (Var v)
push (Not (And f1 f2)) = Or (push (Not f1)) (push (Not f2))
push (Not (Or f1 f2)) = And (push (Not f1)) (push (Not f2))
push (And f1 f2) = And (push f1) (push f2)
push (Or f1 f2) = Or (push f1) (push f2)
</code>

Notice, at lines 4,5 the implementation of deMorgan's laws.

Finally, we implement a function which computes the truth-value of a formula, under a certain interpretation. First, we define the type ''Interpretation'':
<code haskell>
type Interpretation = String -> Bool

i :: Interpretation
i "x" = True
i "y" = False
i "z" = True
</code> 

In the first line, we have defined a **type-alias**: ''Interpretation'' is a function from strings to booleans. We have also implemented a three-variable interpretation, for testing purposes. Next, we implement ''eval'':

<code haskell>
eval :: Interpretation -> Formula -> Bool
eval i (Var v) = i v
eval i (Not f) = not(eval i f)
eval i (And f1 f2) = (eval i f1) && (eval i f2)
eval i (Or f1 f2) = (eval i f1) || (eval i f2)
</code>

==== Monomorphic Trees in Haskell ====

<code haskell>
data ITree = Leaf | Node ITree Integer ITree
</code>

Note that:
  * ''Leaf :: ITree''
  * ''Node :: ITree -> Integer -> ITree -> ITree''

Next, we implement a folding operation on Trees. The key to it is to conceptually define what folding should do on Trees. To grasp an intuition, recall that: 
  * ''foldr (:) []'' is the **identity function** on lists. Hence, ''foldr (:) [] [1,2,3]'' produces ''[1,2,3]''.
  * also, recall that the map operation can be defined as: ''\f -> foldr ((:).f) []''

Similar to the list case, a fold on trees should:
  * **preserve the tree structure**, given the appropriate operator (e.g. ''Node''). 
  * hence, the call ''mtfold Node Leaf'' (where ''Leaf'' is the accumulator) should be the **identity function on trees**. 

Let us define the identity function ''tid'' for trees:
<code haskell>
tid Leaf = Leaf
tid (Node r k l) = Node (tid r) k (tid l)
</code>

As already said, ''(tid t)'' is equivalent to the call ''(mtfold Node Leaf t)'', for any arbitrary tree ''t''.
To obtain the general ''mtfold'' implementation, we simply generalise ''Node'' by an arbitrary operation ''op'':
  * if ''Node :: ITree -> Integer -> ITree -> ITree'', then
  * ''op :: b -> Integer -> b -> b''

We also generalise ''Leaf'' by an arbitrary accumulator:
  * if ''Leaf :: ITree'' then
  * ''acc :: b''

The code generalisation becomes:

<code haskell>
mtfold :: (b -> Integer -> b -> b) -> b -> ITree -> b
mtfold op acc = 
    let f (Node left key right) = f (f left) key (f right)
        f Leaf = acc
    in f
</code>

Notice that ''f'' is precisely the generalisation of ''tid'' according to our observations. We can use ''mtfold'' to implement various tree operations such as:

<code haskell>
tsum = mtfold (\k r l->k + r + l) 0 
tmirror = mtfold (\k r l -> Node l k r) Leaf 
tflatten = mtfold (\k r l -> r ++ [k] ++ l) [] 
</code>