Com S 541 Lecture -*- Outline -*-
> module BuiltInTypes where
> import Prelude hiding (fst, snd, head, tail, filter, zip)
* Built-in types of Haskell
ad: these are needed for all programming in Haskell
also similar to the types used in semantics
effect: understand built-in types and their operations
go quickly, however
** Fundamental classification of objects
*** simple (atomic) types (Thompson 3.1-2, 3.5-6, Davie 2.7)
Bool, Char, and Integer
also types Int (machine ints), Float, Double, ...
Tell them to read about the following,
skip to next section
------------------------------------------
HASKELL BOOLEANS
Bool
Values:
+ abstract values: true and false
+ printed: True, False
Operations:
+ constructors: True, False
+ functions: &&, ||, not, ==, /=
+ syntax: if _ then _ else _
HASKELL CHARACTERS
Char
Values:
+ abstract values: a, b, c, d, ...
+ printed: 'a', 'b', 'c', ...
Operations:
+ constructors: 'a', 'b', ...,
'\n', ...
+ functions: ord, chr, isSpace, ..
==, /=, <, <=, ...
------------------------------------------
&& and || are short-circuit
Bool is of the class Eq, hence it has == and /=
(actually it's also a member of many other classes,
e.g., Ord, so False < True)
look in the Prelude.hs file to see the definition;
search for "Boolean type"
also the syntax
if _ then _ else
is special for Bool
use C style escapes for chars
Char is a member of the classes Eq and Ord
------------------------------------------
HASKELL INTEGERS
Integer
Values:
+ abstract values: 0, 1, -1, ...
+ printed: 0, 1, -1, ...
Operations:
+ constructors: 0, 1, 2, 3, ...
+ functions: +, -, *, negate,
abs, signum,
quot, rem, div, mod,
==, /=, <, <=, ...
------------------------------------------
Integer is a member of the classes Eq, Ord, Num, Real, Integral,
and a bunch of others
Float literals must have digits on both sides of the decimal point
*** structured types (Thompson 5, Davie 2.8, 3.11, 2.10)
make a table as discuss the following:
type constructors
____________________
(a,b) (,)
[a] [], :
a -> b \ ->
**** pairs, tuples, and unit (Thompson 5.2, Davie 2.10)
------------------------------------------
TUPLES IN HASKELL
(a,b), (a,b,c), ..., and ()
Values:
+ abstract values: pairs of a & b,
triples of a & b & c, ...
an empty tuple
+ printed: (1,True), (3, 4, 5), ()
Operations:
+ constructor (,), (,,), ...
+ fst, snd
EXAMPLE FUNCTIONS OVER TUPLES
> fst :: (a,b) -> a
> fst (a,_) = a
> snd :: (a,b) -> b
> snd (_,b) = b
------------------------------------------
there is a way to define record-like types in Haskell also...
------------------------------------------
CONSTRUCTING TUPLES
Prelude> (1,True)
Prelude> (1,2,3)
Prelude> (1,(2,3))
Prelude> (1,(True,2.8))
Prelude> ((1,True),2.8 + 4)
Prelude> (1)
Prelude> ()
Prelude> ("zero tuple:",())
------------------------------------------
Q: What is the type of each?
so ( , ) makes pairs, (,,) makes triples, etc.
Why this notation?
idea is that in a functional language want only 1 argument
and result for functions
f(x,y) is interpreted as f applied to the pair (x,y)
**** functions (Thompson 10)
------------------------------------------
FUNCTIONS
a -> b
Values:
+ abstract values:
partial functions from a to b
Operations:
+ constructor: \ var -> expression
+ syntax:
f x y = expression
means roughly
f = \x -> \y -> expession
+ functions: (.), flip,
curry, uncurry
Examples:
id :: a -> a
id = \x -> x
(.) :: (b -> c) -> (a -> b) -> (a -> c)
(f . g) x = f (g x)
flip :: (a -> b -> c) -> b -> a -> c
flip f x y = f y x
------------------------------------------
Note: id x = x is shorthand for the above definition
\x -> x is just like Smalltalk's [:x | x]
** binding, pattern matching, simple functions
(Thompson p. 74, chapter 7, Davie 2.9, 3.5)
Generally, use pattern matching to extract parts of (algebraic) types
------------------------------------------
PATTERN MATCHING AND BINDING
Prelude> let (x,y,z) = (1,2,3) in x
Prelude> let (x,y,z) = (1,2,3) in z
Prelude> let (_,y,_) = (1,2,3) in y
Prelude> let (a:as) = 1:2:3:[] in a
1
Prelude> let (a:as) = [1,2,3] in as
[2,3]
------------------------------------------
Q: What's the general rule for this kind of pattern matching?
------------------------------------------
PATTERNS IN FUNCTION DEFINITION
Suppose we define
> yodaize (subject, verb, adjective) =
> (adjective, subject, verb)
Then we have
Prelude> yodaize ("food", "is", "good")
Prelude> yodaize ("study", "you", "will")
Another example:
Problem: write a function to take max
of 3 arguments
------------------------------------------
... ("good","food","is") :: ([Char],[Char],[Char])
... ("will","study","you") :: ([Char],[Char],[Char])
> max3 :: Ord a => (a, a, a) -> a
> max3 (x,y,z) = (max x (max y z))
Can omit the following if they're getting it...
------------------------------------------
FOR YOU TO DO
1. Define functions
fst3 :: (a, b, c) -> a
snd3 :: (a, b, c) -> b
thd3 :: (a, b, c) -> c
such that for all t :: (a, b, c)
t = (fst3 t, snd3 t, thd3 t)
2. Define a function
average :: (Float, Float) -> Float
such that, for example
average (1.0, 3.0) = 2.0
average (3.0, 50.0) = 26.5
------------------------------------------