formal models of computationhomepages.abdn.ac.uk/.../cs4026/abdn.only/haskell6.pdf · 2. modules in...
TRANSCRIPT
![Page 1: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/1.jpg)
Formal Models of ComputationLecture I(8) Algebraic Types, Modules and Abstract Data
Types
Kees van Deemter (based on materials by Wamberto Vasconcelos and Chris Mellish)
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.1/18
![Page 2: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/2.jpg)
Plan of Lecture
1. Algebraic Types in Haskell
2. Modules in Haskell
3. Abstract Data Types in Haskell
4. Summary of the Properties of Haskell
5. Assorted Info
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.2/18
![Page 3: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/3.jpg)
1 Algebraic Types in Haskell (1)
• The Haskell type system supports all the complex types provided by other,
more traditional, languages:
Conventional Type Haskell Type
named types type synonyms
arrays lists
strings list of char
records tuples or algebraic types
enumerated types algebraic types
variant records algebraic types
pointer-based structures algebraic types
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.3/18
![Page 4: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/4.jpg)
1 Algebraic Types in Haskell (1)
• The Haskell type system supports all the complex types provided by other,
more traditional, languages:
Conventional Type Haskell Type
named types type synonyms
arrays lists
strings list of char
records tuples or algebraic types
enumerated types algebraic types
variant records algebraic types
pointer-based structures algebraic types
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.3/18
![Page 5: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/5.jpg)
1 Algebraic Types in Haskell (2)
• An algebraic type definition is:
data TypeName = Constr1 | Constr2 | . . . | Constrn
• Type names and constructors must begin with capital letters.
• The simplest form of algebraic type consists of a set of alternative
constructors. This defines an enumerated type, e.g.,
data Temp = Cold | Hot
data Season = Spring | Summer | Autumn | Winter
• To define functions over such types we use pattern matching. For example:
weather :: Season -> Temp
weather Summer = Hot
weather = Cold -- don’t care pattern
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.4/18
![Page 6: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/6.jpg)
1 Algebraic Types in Haskell (2)
• An algebraic type definition is:
data TypeName = Constr1 | Constr2 | . . . | Constrn
• Type names and constructors must begin with capital letters.
• The simplest form of algebraic type consists of a set of alternative
constructors. This defines an enumerated type, e.g.,
data Temp = Cold | Hot
data Season = Spring | Summer | Autumn | Winter
• To define functions over such types we use pattern matching. For example:
weather :: Season -> Temp
weather Summer = Hot
weather = Cold -- don’t care pattern
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.4/18
![Page 7: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/7.jpg)
1 Algebraic Types in Haskell (2)
• An algebraic type definition is:
data TypeName = Constr1 | Constr2 | . . . | Constrn
• Type names and constructors must begin with capital letters.
• The simplest form of algebraic type consists of a set of alternative
constructors. This defines an enumerated type, e.g.,
data Temp = Cold | Hot
data Season = Spring | Summer | Autumn | Winter
• To define functions over such types we use pattern matching. For example:
weather :: Season -> Temp
weather Summer = Hot
weather = Cold -- don’t care pattern
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.4/18
![Page 8: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/8.jpg)
1 Algebraic Types in Haskell (2)
• An algebraic type definition is:
data TypeName = Constr1 | Constr2 | . . . | Constrn
• Type names and constructors must begin with capital letters.
• The simplest form of algebraic type consists of a set of alternative
constructors. This defines an enumerated type, e.g.,
data Temp = Cold | Hot
data Season = Spring | Summer | Autumn | Winter
• To define functions over such types we use pattern matching. For example:
weather :: Season -> Temp
weather Summer = Hot
weather = Cold -- don’t care pattern
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.4/18
![Page 9: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/9.jpg)
1 Algebraic Types in Haskell (2)
• An algebraic type definition is:
data TypeName = Constr1 | Constr2 | . . . | Constrn
• Type names and constructors must begin with capital letters.
• The simplest form of algebraic type consists of a set of alternative
constructors. This defines an enumerated type, e.g.,
data Temp = Cold | Hot
data Season = Spring | Summer | Autumn | Winter
• To define functions over such types we use pattern matching. For example:
weather :: Season -> Temp
weather Summer = Hot
weather = Cold -- don’t care pattern
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.4/18
![Page 10: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/10.jpg)
1 Algebraic Types in Haskell (2)
• An algebraic type definition is:
data TypeName = Constr1 | Constr2 | . . . | Constrn
• Type names and constructors must begin with capital letters.
• The simplest form of algebraic type consists of a set of alternative
constructors. This defines an enumerated type, e.g.,
data Temp = Cold | Hot
data Season = Spring | Summer | Autumn | Winter
• To define functions over such types we use pattern matching. For example:
weather :: Season -> Temp
weather Summer = Hot
weather = Cold -- don’t care pattern
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.4/18
![Page 11: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/11.jpg)
1 Algebraic Types in Haskell (2)
• An algebraic type definition is:
data TypeName = Constr1 | Constr2 | . . . | Constrn
• Type names and constructors must begin with capital letters.
• The simplest form of algebraic type consists of a set of alternative
constructors. This defines an enumerated type, e.g.,
data Temp = Cold | Hot
data Season = Spring | Summer | Autumn | Winter
• To define functions over such types we use pattern matching. For example:
weather :: Season -> Temp
weather Summer = Hot
weather = Cold -- don’t care pattern
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.4/18
![Page 12: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/12.jpg)
1 Algebraic Types in Haskell (3)
• Each base type Int, Float, Bool and Char has its own equality,
ordering, enumeration and show/read functionalities (classes).
• When we introduce a new type we might expect these classes.
• These classes can be supplied by the system if we ask for them.
• To inform Haskell, we introduce deriving:
data Season = Spring | Summer | Autumn | Winter
deriving (Eq,Ord,Enum,Show,Read)
• The order is that in which constructors were listed in the definition. For
example, Spring < Summer < Autumn < Winter
• We can then use expression of the form [Spring..Autumn]
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.5/18
![Page 13: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/13.jpg)
1 Algebraic Types in Haskell (3)
• Each base type Int, Float, Bool and Char has its own equality,
ordering, enumeration and show/read functionalities (classes).
• When we introduce a new type we might expect these classes.
• These classes can be supplied by the system if we ask for them.
• To inform Haskell, we introduce deriving:
data Season = Spring | Summer | Autumn | Winter
deriving (Eq,Ord,Enum,Show,Read)
• The order is that in which constructors were listed in the definition. For
example, Spring < Summer < Autumn < Winter
• We can then use expression of the form [Spring..Autumn]
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.5/18
![Page 14: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/14.jpg)
1 Algebraic Types in Haskell (3)
• Each base type Int, Float, Bool and Char has its own equality,
ordering, enumeration and show/read functionalities (classes).
• When we introduce a new type we might expect these classes.
• These classes can be supplied by the system if we ask for them.
• To inform Haskell, we introduce deriving:
data Season = Spring | Summer | Autumn | Winter
deriving (Eq,Ord,Enum,Show,Read)
• The order is that in which constructors were listed in the definition. For
example, Spring < Summer < Autumn < Winter
• We can then use expression of the form [Spring..Autumn]
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.5/18
![Page 15: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/15.jpg)
1 Algebraic Types in Haskell (3)
• Each base type Int, Float, Bool and Char has its own equality,
ordering, enumeration and show/read functionalities (classes).
• When we introduce a new type we might expect these classes.
• These classes can be supplied by the system if we ask for them.
• To inform Haskell, we introduce deriving:
data Season = Spring | Summer | Autumn | Winter
deriving (Eq,Ord,Enum,Show,Read)
• The order is that in which constructors were listed in the definition. For
example, Spring < Summer < Autumn < Winter
• We can then use expression of the form [Spring..Autumn]
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.5/18
![Page 16: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/16.jpg)
1 Algebraic Types in Haskell (3)
• Each base type Int, Float, Bool and Char has its own equality,
ordering, enumeration and show/read functionalities (classes).
• When we introduce a new type we might expect these classes.
• These classes can be supplied by the system if we ask for them.
• To inform Haskell, we introduce deriving:
data Season = Spring | Summer | Autumn | Winter
deriving (Eq,Ord,Enum,Show,Read)
• The order is that in which constructors were listed in the definition. For
example, Spring < Summer < Autumn < Winter
• We can then use expression of the form [Spring..Autumn]
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.5/18
![Page 17: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/17.jpg)
1 Algebraic Types in Haskell (3)
• Each base type Int, Float, Bool and Char has its own equality,
ordering, enumeration and show/read functionalities (classes).
• When we introduce a new type we might expect these classes.
• These classes can be supplied by the system if we ask for them.
• To inform Haskell, we introduce deriving:
data Season = Spring | Summer | Autumn | Winter
deriving (Eq,Ord,Enum,Show,Read)
• The order is that in which constructors were listed in the definition. For
example, Spring < Summer < Autumn < Winter
• We can then use expression of the form [Spring..Autumn]
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.5/18
![Page 18: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/18.jpg)
1 Algebraic Types in Haskell (3)
• Each base type Int, Float, Bool and Char has its own equality,
ordering, enumeration and show/read functionalities (classes).
• When we introduce a new type we might expect these classes.
• These classes can be supplied by the system if we ask for them.
• To inform Haskell, we introduce deriving:
data Season = Spring | Summer | Autumn | Winter
deriving (Eq,Ord,Enum,Show,Read)
• The order is that in which constructors were listed in the definition. For
example, Spring < Summer < Autumn < Winter
• We can then use expression of the form [Spring..Autumn]
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.5/18
![Page 19: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/19.jpg)
1 Algebraic Types in Haskell (4)
• Constructors also provide an explicit label for elements of the type.
• We can also use other existing types, such as Int, Bool, etc:
data People = Person Name Age
type Name = [Char]
type Age = Int
• Some example of elements of type People are:
Person "Mary Poppins" 34
Person "Sommerset Maughan" 54
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.6/18
![Page 20: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/20.jpg)
1 Algebraic Types in Haskell (4)
• Constructors also provide an explicit label for elements of the type.
• We can also use other existing types, such as Int, Bool, etc:
data People = Person Name Age
type Name = [Char]
type Age = Int
• Some example of elements of type People are:
Person "Mary Poppins" 34
Person "Sommerset Maughan" 54
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.6/18
![Page 21: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/21.jpg)
1 Algebraic Types in Haskell (4)
• Constructors also provide an explicit label for elements of the type.
• We can also use other existing types, such as Int, Bool, etc:
data People = Person Name Age
type Name = [Char]
type Age = Int
• Some example of elements of type People are:
Person "Mary Poppins" 34
Person "Sommerset Maughan" 54
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.6/18
![Page 22: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/22.jpg)
1 Algebraic Types in Haskell (4)
• Constructors also provide an explicit label for elements of the type.
• We can also use other existing types, such as Int, Bool, etc:
data People = Person Name Age
type Name = [Char]
type Age = Int
• Some example of elements of type People are:
Person "Mary Poppins" 34
Person "Sommerset Maughan" 54
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.6/18
![Page 23: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/23.jpg)
1 Algebraic Types in Haskell (4)
• Constructors also provide an explicit label for elements of the type.
• We can also use other existing types, such as Int, Bool, etc:
data People = Person Name Age
type Name = [Char]
type Age = Int
• Some example of elements of type People are:
Person "Mary Poppins" 34
Person "Sommerset Maughan" 54
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.6/18
![Page 24: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/24.jpg)
1 Algebraic Types in Haskell (5)
• Functions over algebraic types are defined using pattern matching. For
instance,
showPerson :: People -> String
showPerson (Person st n) =
st ++ " age: " ++ show n
• Given the definition above, then we have:
showPerson (Person "Dillbert" 34)
"Dillbert age: 34"
• N.B.: When defining functions over algebraic types, it is important to ensure
that cases for all constructors have been defined.
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.7/18
![Page 25: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/25.jpg)
1 Algebraic Types in Haskell (5)
• Functions over algebraic types are defined using pattern matching. For
instance,
showPerson :: People -> String
showPerson (Person st n) =
st ++ " age: " ++ show n
• Given the definition above, then we have:
showPerson (Person "Dillbert" 34)
"Dillbert age: 34"
• N.B.: When defining functions over algebraic types, it is important to ensure
that cases for all constructors have been defined.
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.7/18
![Page 26: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/26.jpg)
1 Algebraic Types in Haskell (5)
• Functions over algebraic types are defined using pattern matching. For
instance,
showPerson :: People -> String
showPerson (Person st n) =
st ++ " age: " ++ show n
• Given the definition above, then we have:
showPerson (Person "Dillbert" 34)
"Dillbert age: 34"
• N.B.: When defining functions over algebraic types, it is important to ensure
that cases for all constructors have been defined.
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.7/18
![Page 27: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/27.jpg)
1 Algebraic Types in Haskell (5)
• Functions over algebraic types are defined using pattern matching. For
instance,
showPerson :: People -> String
showPerson (Person st n) =
st ++ " age: " ++ show n
• Given the definition above, then we have:
showPerson (Person "Dillbert" 34)
"Dillbert age: 34"
• N.B.: When defining functions over algebraic types, it is important to ensure
that cases for all constructors have been defined.
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.7/18
![Page 28: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/28.jpg)
1 Algebraic Types in Haskell (5)
• Functions over algebraic types are defined using pattern matching. For
instance,
showPerson :: People -> String
showPerson (Person st n) =
st ++ " age: " ++ show n
• Given the definition above, then we have:
showPerson (Person "Dillbert" 34)
"Dillbert age: 34"
• N.B.: When defining functions over algebraic types, it is important to ensure
that cases for all constructors have been defined.
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.7/18
![Page 29: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/29.jpg)
1 Algebraic Types in Haskell (6)
• The general form of the algebraic type definitions is:
data TypeName =
Constructor1 Type[1,0] ... Type[1,k1] |
Constructor2 Type[2,0] ... Type[2,k2] |
Constructorn Type[n,0] ... Type[1,kn]
• Algebraic types are more than “fancy types”!!
• Algebraic types can be used recursively to define more complex data
structures such as trees.
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.8/18
![Page 30: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/30.jpg)
1 Algebraic Types in Haskell (6)
• The general form of the algebraic type definitions is:
data TypeName =
Constructor1 Type[1,0] ... Type[1,k1] |
Constructor2 Type[2,0] ... Type[2,k2] |
Constructorn Type[n,0] ... Type[1,kn]
• Algebraic types are more than “fancy types”!!
• Algebraic types can be used recursively to define more complex data
structures such as trees.
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.8/18
![Page 31: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/31.jpg)
1 Algebraic Types in Haskell (6)
• The general form of the algebraic type definitions is:
data TypeName =
Constructor1 Type[1,0] ... Type[1,k1] |
Constructor2 Type[2,0] ... Type[2,k2] |
Constructorn Type[n,0] ... Type[1,kn]
• Algebraic types are more than “fancy types”!!
• Algebraic types can be used recursively to define more complex data
structures such as trees.
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.8/18
![Page 32: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/32.jpg)
1 Algebraic Types in Haskell (6)
• The general form of the algebraic type definitions is:
data TypeName =
Constructor1 Type[1,0] ... Type[1,k1] |
Constructor2 Type[2,0] ... Type[2,k2] |
Constructorn Type[n,0] ... Type[1,kn]
• Algebraic types are more than “fancy types”!!
• Algebraic types can be used recursively to define more complex data
structures such as trees.
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.8/18
![Page 33: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/33.jpg)
1 Algebraic Types in Haskell (7)
• For instance, an algebraic type for mathematical expressions:
data Expr =
Value Int | Add Expr Expr | Sub Expr Expr
• The expression (2 + 3) - 4 is represented in type Expr as:
Sub (Add (Value 2) (Value 3)) (Value 4)
• Again, we use pattern matching to manipulate values of this type.
• A simple evaluator for the expressions above is:
eval :: Expr -> Int
eval (Value v) = v
eval (Add e1 e2) = (eval e1) + (eval e2)
eval (Sub e1 e2) = (eval e1) - (eval e2)
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.9/18
![Page 34: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/34.jpg)
1 Algebraic Types in Haskell (7)
• For instance, an algebraic type for mathematical expressions:
data Expr =
Value Int | Add Expr Expr | Sub Expr Expr
• The expression (2 + 3) - 4 is represented in type Expr as:
Sub (Add (Value 2) (Value 3)) (Value 4)
• Again, we use pattern matching to manipulate values of this type.
• A simple evaluator for the expressions above is:
eval :: Expr -> Int
eval (Value v) = v
eval (Add e1 e2) = (eval e1) + (eval e2)
eval (Sub e1 e2) = (eval e1) - (eval e2)
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.9/18
![Page 35: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/35.jpg)
1 Algebraic Types in Haskell (7)
• For instance, an algebraic type for mathematical expressions:
data Expr =
Value Int | Add Expr Expr | Sub Expr Expr
• The expression (2 + 3) - 4 is represented in type Expr as:
Sub (Add (Value 2) (Value 3)) (Value 4)
• Again, we use pattern matching to manipulate values of this type.
• A simple evaluator for the expressions above is:
eval :: Expr -> Int
eval (Value v) = v
eval (Add e1 e2) = (eval e1) + (eval e2)
eval (Sub e1 e2) = (eval e1) - (eval e2)
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.9/18
![Page 36: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/36.jpg)
1 Algebraic Types in Haskell (7)
• For instance, an algebraic type for mathematical expressions:
data Expr =
Value Int | Add Expr Expr | Sub Expr Expr
• The expression (2 + 3) - 4 is represented in type Expr as:
Sub (Add (Value 2) (Value 3)) (Value 4)
• Again, we use pattern matching to manipulate values of this type.
• A simple evaluator for the expressions above is:
eval :: Expr -> Int
eval (Value v) = v
eval (Add e1 e2) = (eval e1) + (eval e2)
eval (Sub e1 e2) = (eval e1) - (eval e2)
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.9/18
![Page 37: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/37.jpg)
1 Algebraic Types in Haskell (7)
• For instance, an algebraic type for mathematical expressions:
data Expr =
Value Int | Add Expr Expr | Sub Expr Expr
• The expression (2 + 3) - 4 is represented in type Expr as:
Sub (Add (Value 2) (Value 3)) (Value 4)
• Again, we use pattern matching to manipulate values of this type.
• A simple evaluator for the expressions above is:
eval :: Expr -> Int
eval (Value v) = v
eval (Add e1 e2) = (eval e1) + (eval e2)
eval (Sub e1 e2) = (eval e1) - (eval e2)
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.9/18
![Page 38: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/38.jpg)
1 Algebraic Types in Haskell (7)
• For instance, an algebraic type for mathematical expressions:
data Expr =
Value Int | Add Expr Expr | Sub Expr Expr
• The expression (2 + 3) - 4 is represented in type Expr as:
Sub (Add (Value 2) (Value 3)) (Value 4)
• Again, we use pattern matching to manipulate values of this type.
• A simple evaluator for the expressions above is:
eval :: Expr -> Int
eval (Value v) = v
eval (Add e1 e2) = (eval e1) + (eval e2)
eval (Sub e1 e2) = (eval e1) - (eval e2)
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.9/18
![Page 39: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/39.jpg)
1 Algebraic Types in Haskell (7)
• For instance, an algebraic type for mathematical expressions:
data Expr =
Value Int | Add Expr Expr | Sub Expr Expr
• The expression (2 + 3) - 4 is represented in type Expr as:
Sub (Add (Value 2) (Value 3)) (Value 4)
• Again, we use pattern matching to manipulate values of this type.
• A simple evaluator for the expressions above is:
eval :: Expr -> Int
eval (Value v) = v
eval (Add e1 e2) = (eval e1) + (eval e2)
eval (Sub e1 e2) = (eval e1) - (eval e2)
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.9/18
![Page 40: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/40.jpg)
1 Algebraic Types in Haskell (8)
• Algebraic types become even more powerful when combined with
polymorphic type variables. Example – different binary trees:
data Tree a = Nil | Node a (Tree a) (Tree a)
deriving (Eq,Ord,Show)
type IntTree = Tree Int
type MyTree = Tree ([Char], Int)
• We can then use pattern matching to define general functions over these
structures:
countNodes :: Tree a -> Int
countNodes Nil = 0
countNodes (Node left right)
= (countNodes left) + (countNodes right) + 1
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.10/18
![Page 41: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/41.jpg)
1 Algebraic Types in Haskell (8)
• Algebraic types become even more powerful when combined with
polymorphic type variables. Example – different binary trees:
data Tree a = Nil | Node a (Tree a) (Tree a)
deriving (Eq,Ord,Show)
type IntTree = Tree Int
type MyTree = Tree ([Char], Int)
• We can then use pattern matching to define general functions over these
structures:
countNodes :: Tree a -> Int
countNodes Nil = 0
countNodes (Node left right)
= (countNodes left) + (countNodes right) + 1
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.10/18
![Page 42: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/42.jpg)
1 Algebraic Types in Haskell (8)
• Algebraic types become even more powerful when combined with
polymorphic type variables. Example – different binary trees:
data Tree a = Nil | Node a (Tree a) (Tree a)
deriving (Eq,Ord,Show)
type IntTree = Tree Int
type MyTree = Tree ([Char], Int)
• We can then use pattern matching to define general functions over these
structures:
countNodes :: Tree a -> Int
countNodes Nil = 0
countNodes (Node left right)
= (countNodes left) + (countNodes right) + 1
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.10/18
![Page 43: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/43.jpg)
1 Algebraic Types in Haskell (8)
• Algebraic types become even more powerful when combined with
polymorphic type variables. Example – different binary trees:
data Tree a = Nil | Node a (Tree a) (Tree a)
deriving (Eq,Ord,Show)
type IntTree = Tree Int
type MyTree = Tree ([Char], Int)
• We can then use pattern matching to define general functions over these
structures:
countNodes :: Tree a -> Int
countNodes Nil = 0
countNodes (Node left right)
= (countNodes left) + (countNodes right) + 1
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.10/18
![Page 44: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/44.jpg)
2 Modules in Haskell (1)
• A module consists on a number of definitions (types, functions, etc.).
• A module has a precisely defined interface, describing what it exports (that
is, offers to users).
• Other modules import definitions that are on offer.
• Advantages:
– A large system can be broken up and developed independently;
– The system can be compiled separately (more efficient);
– Encourages reuse;
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.11/18
![Page 45: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/45.jpg)
2 Modules in Haskell (1)
• A module consists on a number of definitions (types, functions, etc.).
• A module has a precisely defined interface, describing what it exports (that
is, offers to users).
• Other modules import definitions that are on offer.
• Advantages:
– A large system can be broken up and developed independently;
– The system can be compiled separately (more efficient);
– Encourages reuse;
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.11/18
![Page 46: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/46.jpg)
2 Modules in Haskell (1)
• A module consists on a number of definitions (types, functions, etc.).
• A module has a precisely defined interface, describing what it exports (that
is, offers to users).
• Other modules import definitions that are on offer.
• Advantages:
– A large system can be broken up and developed independently;
– The system can be compiled separately (more efficient);
– Encourages reuse;
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.11/18
![Page 47: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/47.jpg)
2 Modules in Haskell (1)
• A module consists on a number of definitions (types, functions, etc.).
• A module has a precisely defined interface, describing what it exports (that
is, offers to users).
• Other modules import definitions that are on offer.
• Advantages:
– A large system can be broken up and developed independently;
– The system can be compiled separately (more efficient);
– Encourages reuse;
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.11/18
![Page 48: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/48.jpg)
2 Modules in Haskell (1)
• A module consists on a number of definitions (types, functions, etc.).
• A module has a precisely defined interface, describing what it exports (that
is, offers to users).
• Other modules import definitions that are on offer.
• Advantages:
– A large system can be broken up and developed independently;
– The system can be compiled separately (more efficient);
– Encourages reuse;
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.11/18
![Page 49: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/49.jpg)
2 Modules in Haskell (1)
• A module consists on a number of definitions (types, functions, etc.).
• A module has a precisely defined interface, describing what it exports (that
is, offers to users).
• Other modules import definitions that are on offer.
• Advantages:
– A large system can be broken up and developed independently;
– The system can be compiled separately (more efficient);
– Encourages reuse;
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.11/18
![Page 50: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/50.jpg)
2 Modules in Haskell (1)
• A module consists on a number of definitions (types, functions, etc.).
• A module has a precisely defined interface, describing what it exports (that
is, offers to users).
• Other modules import definitions that are on offer.
• Advantages:
– A large system can be broken up and developed independently;
– The system can be compiled separately (more efficient);
– Encourages reuse;
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.11/18
![Page 51: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/51.jpg)
2 Modules in Haskell (2)
• Each module is named via a header:
module Ant where
data Ants = ...
anteater x = ...
• To import a module:
module Bee where
import Ant
beeKeeper = ...
• All visible definitions from module Ant can be used in Bee.
• We can control what is to be exported, though:
module Bee (beeKeeper, anteater) where ...
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.12/18
![Page 52: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/52.jpg)
2 Modules in Haskell (2)
• Each module is named via a header:
module Ant where
data Ants = ...
anteater x = ...
• To import a module:
module Bee where
import Ant
beeKeeper = ...
• All visible definitions from module Ant can be used in Bee.
• We can control what is to be exported, though:
module Bee (beeKeeper, anteater) where ...
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.12/18
![Page 53: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/53.jpg)
2 Modules in Haskell (2)
• Each module is named via a header:
module Ant where
data Ants = ...
anteater x = ...
• To import a module:
module Bee where
import Ant
beeKeeper = ...
• All visible definitions from module Ant can be used in Bee.
• We can control what is to be exported, though:
module Bee (beeKeeper, anteater) where ...
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.12/18
![Page 54: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/54.jpg)
2 Modules in Haskell (2)
• Each module is named via a header:
module Ant where
data Ants = ...
anteater x = ...
• To import a module:
module Bee where
import Ant
beeKeeper = ...
• All visible definitions from module Ant can be used in Bee.
• We can control what is to be exported, though:
module Bee (beeKeeper, anteater) where ...
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.12/18
![Page 55: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/55.jpg)
2 Modules in Haskell (2)
• Each module is named via a header:
module Ant where
data Ants = ...
anteater x = ...
• To import a module:
module Bee where
import Ant
beeKeeper = ...
• All visible definitions from module Ant can be used in Bee.
• We can control what is to be exported, though:
module Bee (beeKeeper, anteater) where ...
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.12/18
![Page 56: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/56.jpg)
2 Modules in Haskell (2)
• Each module is named via a header:
module Ant where
data Ants = ...
anteater x = ...
• To import a module:
module Bee where
import Ant
beeKeeper = ...
• All visible definitions from module Ant can be used in Bee.
• We can control what is to be exported, though:
module Bee (beeKeeper, anteater) where ...
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.12/18
![Page 57: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/57.jpg)
2 Modules in Haskell (2)
• Each module is named via a header:
module Ant where
data Ants = ...
anteater x = ...
• To import a module:
module Bee where
import Ant
beeKeeper = ...
• All visible definitions from module Ant can be used in Bee.
• We can control what is to be exported, though:
module Bee (beeKeeper, anteater) where ...
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.12/18
![Page 58: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/58.jpg)
3 Abstract Data Types in Haskell (1)
• Abstract Data Types (ADT’s) are well known in software engineering as a
mechanism for hiding the implementation of complex data types.
• For example, suppose we wish to implement a stack data type. We would
need to support the following operations:
– create a new (empty) stack;
– add a new item to the top of a stack (push);
– remove the top element from the stack (pop);
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.13/18
![Page 59: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/59.jpg)
3 Abstract Data Types in Haskell (1)
• Abstract Data Types (ADT’s) are well known in software engineering as a
mechanism for hiding the implementation of complex data types.
• For example, suppose we wish to implement a stack data type. We would
need to support the following operations:
– create a new (empty) stack;
– add a new item to the top of a stack (push);
– remove the top element from the stack (pop);
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.13/18
![Page 60: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/60.jpg)
3 Abstract Data Types in Haskell (1)
• Abstract Data Types (ADT’s) are well known in software engineering as a
mechanism for hiding the implementation of complex data types.
• For example, suppose we wish to implement a stack data type. We would
need to support the following operations:
– create a new (empty) stack;
– add a new item to the top of a stack (push);
– remove the top element from the stack (pop);
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.13/18
![Page 61: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/61.jpg)
3 Abstract Data Types in Haskell (1)
• Abstract Data Types (ADT’s) are well known in software engineering as a
mechanism for hiding the implementation of complex data types.
• For example, suppose we wish to implement a stack data type. We would
need to support the following operations:
– create a new (empty) stack;
– add a new item to the top of a stack (push);
– remove the top element from the stack (pop);
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.13/18
![Page 62: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/62.jpg)
3 Abstract Data Types in Haskell (1)
• Abstract Data Types (ADT’s) are well known in software engineering as a
mechanism for hiding the implementation of complex data types.
• For example, suppose we wish to implement a stack data type. We would
need to support the following operations:
– create a new (empty) stack;
– add a new item to the top of a stack (push);
– remove the top element from the stack (pop);
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.13/18
![Page 63: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/63.jpg)
3 Abstract Data Types in Haskell (2)
• Users of ADTs do not need to know how operations are implemented.
• All that they need to know is the name of the operations and the argument
values that they require, that is, the interface or signature of the data type.
• In Haskell ADT’s are defined as modules:
module Stack
( Stack,
emptyStack, -- Stack
push, -- Int -> Stack -> Stack
pop, -- Stack -> Stack
) where ...
• Only the items in brackets are visible.
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.14/18
![Page 64: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/64.jpg)
3 Abstract Data Types in Haskell (2)
• Users of ADTs do not need to know how operations are implemented.
• All that they need to know is the name of the operations and the argument
values that they require, that is, the interface or signature of the data type.
• In Haskell ADT’s are defined as modules:
module Stack
( Stack,
emptyStack, -- Stack
push, -- Int -> Stack -> Stack
pop, -- Stack -> Stack
) where ...
• Only the items in brackets are visible.
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.14/18
![Page 65: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/65.jpg)
3 Abstract Data Types in Haskell (2)
• Users of ADTs do not need to know how operations are implemented.
• All that they need to know is the name of the operations and the argument
values that they require, that is, the interface or signature of the data type.
• In Haskell ADT’s are defined as modules:
module Stack
( Stack,
emptyStack, -- Stack
push, -- Int -> Stack -> Stack
pop, -- Stack -> Stack
) where ...
• Only the items in brackets are visible.
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.14/18
![Page 66: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/66.jpg)
3 Abstract Data Types in Haskell (2)
• Users of ADTs do not need to know how operations are implemented.
• All that they need to know is the name of the operations and the argument
values that they require, that is, the interface or signature of the data type.
• In Haskell ADT’s are defined as modules:
module Stack
( Stack,
emptyStack, -- Stack
push, -- Int -> Stack -> Stack
pop, -- Stack -> Stack
) where ...
• Only the items in brackets are visible.
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.14/18
![Page 67: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/67.jpg)
3 Abstract Data Types in Haskell (2)
• Users of ADTs do not need to know how operations are implemented.
• All that they need to know is the name of the operations and the argument
values that they require, that is, the interface or signature of the data type.
• In Haskell ADT’s are defined as modules:
module Stack
( Stack,
emptyStack, -- Stack
push, -- Int -> Stack -> Stack
pop, -- Stack -> Stack
) where ...
• Only the items in brackets are visible.
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.14/18
![Page 68: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/68.jpg)
3 Abstract Data Types in Haskell (3)
• This is all that any user of the ADT Stack need be told.
• However, the implementor of the ADT must next state how the stack will be
represented and manipulated:
module Stack (Stack,emptyStack,push,pop) where
data Stack = MyStack [Int]
emptyStack :: Stack
emptyStack = MyStack []
push :: Int -> Stack -> Stack
push x (MyStack xs) = (MyStack xs++[x])
pop :: Stack -> Stack
pop (MyStack []) = (MyStack [])
pop (MyStack (x:xs)) = (MyStack xs)
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.15/18
![Page 69: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/69.jpg)
3 Abstract Data Types in Haskell (3)
• This is all that any user of the ADT Stack need be told.
• However, the implementor of the ADT must next state how the stack will be
represented and manipulated:
module Stack (Stack,emptyStack,push,pop) where
data Stack = MyStack [Int]
emptyStack :: Stack
emptyStack = MyStack []
push :: Int -> Stack -> Stack
push x (MyStack xs) = (MyStack xs++[x])
pop :: Stack -> Stack
pop (MyStack []) = (MyStack [])
pop (MyStack (x:xs)) = (MyStack xs)
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.15/18
![Page 70: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/70.jpg)
3 Abstract Data Types in Haskell (3)
• This is all that any user of the ADT Stack need be told.
• However, the implementor of the ADT must next state how the stack will be
represented and manipulated:
module Stack (Stack,emptyStack,push,pop) where
data Stack = MyStack [Int]
emptyStack :: Stack
emptyStack = MyStack []
push :: Int -> Stack -> Stack
push x (MyStack xs) = (MyStack xs++[x])
pop :: Stack -> Stack
pop (MyStack []) = (MyStack [])
pop (MyStack (x:xs)) = (MyStack xs)
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.15/18
![Page 71: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/71.jpg)
3 Abstract Data Types in Haskell (4)
• As implementors of the ADT, we are free to change the definitions of these
functions, or even the underlying representation of the data type, without
affecting the other programs which make use of it...
• providing we keep the same signature and meaning for each function!!
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.16/18
![Page 72: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/72.jpg)
3 Abstract Data Types in Haskell (4)
• As implementors of the ADT, we are free to change the definitions of these
functions, or even the underlying representation of the data type, without
affecting the other programs which make use of it...
• providing we keep the same signature and meaning for each function!!
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.16/18
![Page 73: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/73.jpg)
3 Abstract Data Types in Haskell (4)
• As implementors of the ADT, we are free to change the definitions of these
functions, or even the underlying representation of the data type, without
affecting the other programs which make use of it...
• providing we keep the same signature and meaning for each function!!
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.16/18
![Page 74: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/74.jpg)
4 Summary of the Properties of Haskell
• Haskell is a declarative, high-level language.
• Haskell is lazily evaluated – we can compute with infinite data structures in
finite time and space.
• Haskell provides a rich, but high-level, set of data types. This separates
computation over complex structures from the dangers of direct pointer
manipulation and memory management.
• Haskell supports polymorphic functions. This results in highly generic and
reusable programs.
• Haskell supports higher-order programming. This means that we can capture
commonly used idioms and abstractions for easy reuse, and more concise
programs.
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.17/18
![Page 75: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/75.jpg)
4 Summary of the Properties of Haskell
• Haskell is a declarative, high-level language.
• Haskell is lazily evaluated – we can compute with infinite data structures in
finite time and space.
• Haskell provides a rich, but high-level, set of data types. This separates
computation over complex structures from the dangers of direct pointer
manipulation and memory management.
• Haskell supports polymorphic functions. This results in highly generic and
reusable programs.
• Haskell supports higher-order programming. This means that we can capture
commonly used idioms and abstractions for easy reuse, and more concise
programs.
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.17/18
![Page 76: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/76.jpg)
4 Summary of the Properties of Haskell
• Haskell is a declarative, high-level language.
• Haskell is lazily evaluated – we can compute with infinite data structures in
finite time and space.
• Haskell provides a rich, but high-level, set of data types. This separates
computation over complex structures from the dangers of direct pointer
manipulation and memory management.
• Haskell supports polymorphic functions. This results in highly generic and
reusable programs.
• Haskell supports higher-order programming. This means that we can capture
commonly used idioms and abstractions for easy reuse, and more concise
programs.
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.17/18
![Page 77: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/77.jpg)
4 Summary of the Properties of Haskell
• Haskell is a declarative, high-level language.
• Haskell is lazily evaluated – we can compute with infinite data structures in
finite time and space.
• Haskell provides a rich, but high-level, set of data types. This separates
computation over complex structures from the dangers of direct pointer
manipulation and memory management.
• Haskell supports polymorphic functions. This results in highly generic and
reusable programs.
• Haskell supports higher-order programming. This means that we can capture
commonly used idioms and abstractions for easy reuse, and more concise
programs.
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.17/18
![Page 78: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/78.jpg)
4 Summary of the Properties of Haskell
• Haskell is a declarative, high-level language.
• Haskell is lazily evaluated – we can compute with infinite data structures in
finite time and space.
• Haskell provides a rich, but high-level, set of data types. This separates
computation over complex structures from the dangers of direct pointer
manipulation and memory management.
• Haskell supports polymorphic functions. This results in highly generic and
reusable programs.
• Haskell supports higher-order programming. This means that we can capture
commonly used idioms and abstractions for easy reuse, and more concise
programs.
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.17/18
![Page 79: Formal Models of Computationhomepages.abdn.ac.uk/.../CS4026/abdn.only/haskell6.pdf · 2. Modules in Haskell 3. Abstract Data Types in Haskell 4. Summary of the Properties of Haskell](https://reader034.vdocuments.net/reader034/viewer/2022042811/5fa027582bed19535a083d25/html5/thumbnails/79.jpg)
5 Assorted Info
Check out the online articles and asorted links in the module’s web-site:
http://www.csd.abdn.ac.uk/˜cmellish/teaching/CS4026/
CS4026-I(8) (Algebraic Types, Modules and Abstract Data Types), Dept. of Computing Science, Univ. of Aberdeen, 2006–2007 – p.18/18