Recursive Data Types

General Info

• Information about the written exam is now available in Canvas,
• including several old exams.

About function definitions…

• Usually when we create a function we give it a name at the same time

• square x = x*x

• But giving something a name and creating a function are two separate things

• square = \ x -> x*x

• Whether we give something a name or not is our choice

• list1 = map (\x -> x*x) [4,5,6]
  
  list2 = map sq ns
    where
      sq x = x*x
      ns = [4,5,6]
  

• But what about pattern matching and guards?

About function definitions…

Pattern matching and guards

• It may look like function definitions are a complicated part of the language

• fac 0       = 1
  fac n | n>0 = n * fac(n-1)
  

• But they can be explained as a combination of more fundamental things

• fac = \ x -> case x of
                 0       -> 1
                 n | n>0 -> n * fac(n-1)
  

  • Naming things (

    name = …

    )
  • Creating functions (lambda expressions,

    \ x -> …

    )
  • Pattern matching and guards (case expressions,

    case … of …

    )
• These things can be used and explained independently.

Types are sets of values

• Haskell

  • data Bool = False | True
    
    data Suit = Spades | Hearts | Diamonds | Clubs

• Math
  • Bool = {False, True}
  • Suit = {Spades, Hearts, Diamonds, Clubs}

Types are sets of values

• Haskell

  • data Rank = Numeric Int | Jack | Queen | King | Ace

• Math
  • Rank = {Numeric n | n ∈ Int} ∪ {Jack, Queen, King, Ace}

Types are sets of values

• Haskell

  • data Card = Card Rank Suit

• Math
  • Card = {Card r s | r ∈ Rank, s ∈ Suit}

Circular definitions

When do they make sense?

• Recursive functions. Make sense, if you follow some basic rules.

• fac 0 = 1
  fac n = n * fac(n-1)
  
  f x = f x

• Circular definitions of numbers? They can make sense when seen as as equations in math, but as programs they usually make no sense…

• x,y :: Int
  x = x
  y = 2*y

Circular definitions → When do they make sense?

• Circular definitions of lists? They can make sense.

• ha,haha :: String
  ha = "ha"++ha
  haha = take 10 ha

  • This works in Haskell because Haskell uses lazy evaluation.

  • haha == "hahahahaha"

Circular definitions of types

Do they make sense? Yes!

• data Hand = Empty | Add Card Hand
  
  data List a = Nil | Cons a (List a)
  
  data Nat = Zero | Succ Nat

• Nat

  corresponds to natural numbers as defined by Peano.

The meaning of circular definition of types

• data Nat = Zero | Succ Nat          -- Peano's natural numbers
  

• What set of values does this correspond to?
  • Nat = {Zero} ∪ {Succ n | n ∈ Nat}
• But this is still a circular definition…
• We can instead view the alternatives in data type definitions as rules that together generate the intended set.
  • Rule 1: Zero ∈ Nat
  • Rule 2: if n ∈ Nat then Succ n ∈ Nat
• Recursive data types are also called inductive data types.

Inductively defined sets

• By using induction we can define sets that contain infinitely many elements.
  • Finite sets: enumerate all the elements.
  • Infinite sets: give a finite set of rules that describe how to generate the elements.
• Recursive data type definitions create data types with infinitely many values.
  • The values can also be arbitrarily large
    • For example, there is no limit on how long lists can be.
  • We can work with data structures whose size is not known in advance.

Live demo

• RecursiveDataTypes.hs

Recursive data types

A second look at the types we have seen

• data Hand = Empty | Add Card Hand
  
  data List a = Nil | Cons a (List a)
  
  data Nat = Zero | Succ Nat   -- Peano's natural numbers
  

• Example values of these types:

• hand = Add c1 (Add c2 (Add c3 Empty)
  list = Cons 1 (Cons 2 (Cons 3 (Cons 4 Nil)))
  number = Succ (Succ (Succ Zero))
  

• The values in these types are all linear sequences of things.

Branching data structures

• How would we create a data type for flowcharts (action diagrams)?

  

• More examples of flowcharts.

Live demo

• RecursiveDataTypes.hs (continued)

A simpler tree-shaped data type

Binary trees

A simpler tree-shaped data type → Binary trees

• Binary trees are trees where nodes have two subtrees.

• data BTree = Leaf | Node BTree Int Btree

• 

Next week

Arithmetic quiz

• Imagine a program to help school children learn arithmetic:
• Welcome to the arithmetic quiz! What is 1+2*3? 9 Wrong! The correct answer is 7. What is 4*(5+1)+3? 27 Yes! That is correct!
• We need to generate a random expressions and show it to the user,
• then we need to compute the value of the expression and compare it to the user's answer.

Next week → Arithmetic quiz

• We need a data type that models the logical structure of an arithmetic expression, like (1+2)*3

• data Expr = Const Integer
            | Add Expr Expr
            | Mul Expr Expr

• Another example of a tree-shaped recursive data type!

Summary

• Recursive data types are useful.
  • We can create types for linear sequences of things.
  • We can create types for branching data structure (tree-shaped things).
• Recursive data types can be seen as inductively defined sets.
  • But with lazy evaluation we can go a little bit beyond what inductively defined sets allow, e.g. infinite lists and diagrams with cycles.