10 haskell part 2 - university of texas at austincannata/cs345/class notes/10 haskell part 2.pdfdr....

Dr. Philip Cannata 1

Programming Languages

Haskell Part 2


A programming language is a language with a well-defined syntax (lexicon and grammar), type system, and semantics that can be used to implement a set of algorithms.

Haskell


Haskell: /lusr/bin/hugs, should be in your default $PATH or for windows, download and install winhugs at http://cvs.haskell.org/Hugs/pages/downloading.htm

$ hugs__ __ __ __ ____ ___ _________________________________________|| || || || || || ||__ Hugs 98: Based on the Haskell 98 standard||___|| ||__|| ||__|| __|| Copyright (c) 1994-2005||---|| ___|| World Wide Web: http://haskell.org/hugs|| || Bugs: http://hackage.haskell.org/trac/hugs|| || Version: 20051031 _________________________________________

Haskell 98 mode: Restart with command line option -98 to enable extensions

Type :? for helpHugs> :load 10H2Main>

To load the file “10H2.hs” from the directory in which you

started hugs. Similar for 10Logic and 10Movie


Propositions:

Statements that can be either True or False

Logical Operators: • Negation: not

not :: Bool-> Boolnot True = Falsenot False = True

• Conjunction: &&(&&) :: Bool-> Bool-> BoolFalse && x = FalseTrue && x = x

• Disjunction: ||(||) :: Bool-> Bool-> BoolTrue || x = TrueFalse || x = x

Propositional Logic

Logical Operators: • Implication (if – then): ==>

Antecedent ==> Consequent(==>) :: Bool -> Bool -> Boolx ==> y = (not x) || y

• Equivalence (if, and only if): <=>(<=>) :: Bool -> Bool -> Boolx <=> y = x == y

• Not Equivalent <+> (<+>) :: Bool -> Bool -> Boolx <+> y = x /= y


Truth tables: P && QP || Qnot PP ==> QP <=> QP <+> Q

P Q P && Q

False False False

False True False

True False False

True True True

P Q P || Q

False False False

False True True

True False True

True True True

P P

False True

True False

P Q PQFalse False TrueFalse True TrueTrue False FalseTrue True True

P Q P<=>Q

False False True

False True False

True False False

True True True

P Q P <+> Q

False False False

False True True

True False True

True True False


Proposition (WFF): ((P Q)((P)Q))P Q

False False

False True

True False

True True

False

True

True

True

(P Q) (P)

True

True

False

False

((P)Q)

False

True

True

True

((PQ)((P)Q))

False

True

True

True

Some True: prop is Satisfiable*If they were all True: Valid / Tautology

All False: Contradiction(not satisfiable*)

*Satisfiability was the first known NP-complete problem

If prop is True when all variables are True:P, Q ((PQ)((P)Q))

A Truthdouble turnstile

Reasoning with Truth Tables


truthTable :: (Bool -> Bool -> Bool) -> [Bool]truthTable wff = [ (wff p q) | p <- [True,False],

q <- [True,False]]

tt = (\ p q -> not (p ==> q))

Hugs> :load 10Logic.hsLOGIC> :type tttt :: Bool -> Bool -> BoolLOGIC> truthTable tt[False,True,False,False]LOGIC> or (truthTable tt)TrueLOGIC> and (truthTable tt)False

Truth Table Application


Satisfiable:Are there well formed propositional formulas that return True for some input?

satisfiable1 :: (Bool -> Bool) -> Boolsatisfiable1 wff = (wff True) || (wff False)

satisfiable2 :: (Bool -> Bool -> Bool) -> Boolsatisfiable2 wff = or [ (wff p q) | p <- [True,False],

q <- [True,False]]

satisfiable3 :: (Bool -> Bool -> Bool -> Bool) -> Boolsatisfiable3 wff = or [ (wff p q r) | p <- [True,False],

q <- [True,False], r <- [True,False]]

( \ p -> not p)( \ p q -> (not p) || (not q) )( \ p q r -> (not p) || (not q) && (not r) )

Define these first

infix 1 ==>

(==>) :: Bool -> Bool -> Boolx ==> y = (not x) || y

infix 1 <=>

(<=>) :: Bool -> Bool -> Boolx <=> y = x == y

infixr 2 <+>

(<+>) :: Bool -> Bool -> Boolx <+> y = x /= y


Validity (Tautology): Are there well formed propositional formulas that return True no matter what their input values are?

valid1 :: (Bool -> Bool) -> Boolvalid1 wff = (wff True) && (wff False)

valid2 :: (Bool -> Bool -> Bool) -> Boolvalid2 wff = (wff True True)

&& (wff True False) && (wff False True) && (wff False False)

( \ p -> p || not p ) -- Excluded Middle( \ p -> p ==> p )( \ p q -> p ==> (q ==> p) )( \ p q -> (p ==> q) ==> p )


Contradiction (Not Satisfiable):Are there well formed propositional formulas that return False no matter what their input values are?

contradiction1 :: (Bool -> Bool) -> Boolcontradiction1 wff = not (wff True) && not (wff False)

contradiction2 :: (Bool -> Bool -> Bool) -> Boolcontradiction2 wff = and [not (wff p q) | p <- [True,False],

q <- [True,False]]

contradiction3 :: (Bool -> Bool -> Bool -> Bool) -> Boolcontradiction3 wff = and [ not (wff p q r) | p <- [True,False],

q <- [True,False], r <- [True,False]]

( \ p -> p && not p)( \ p q -> (p && not p) || (q && not q) )( \ p q r -> (p && not p) || (q && not q) && (r && not r) )


Truth:Are there well formed propositional formulas that return True when their input is True

truth1 :: (Bool -> Bool) -> Booltruth1 wff = (wff True)

truth2 :: (Bool -> Bool -> Bool) -> Booltruth2 wff = (wff True True)

( \ p -> not p)

( \ p q -> (p && q) || (not p ==> q))

( \ p q -> not p ==> q)

( \ p q -> (not p && q) && (not p ==> q) )


Equivalence:logEquiv1 :: (Bool -> Bool) -> (Bool -> Bool) -> BoollogEquiv1 bf1 bf2 =

(bf1 True <=> bf2 True) && (bf1 False <=> bf2 False)

logEquiv2 :: (Bool -> Bool -> Bool) -> (Bool -> Bool -> Bool) -> BoollogEquiv2 bf1 bf2 = and [(bf1 r s) <=> (bf2 r s) | r <- [True,False],

s <- [True,False]]

logEquiv3 :: (Bool -> Bool -> Bool -> Bool) -> (Bool -> Bool -> Bool -> Bool) -> BoollogEquiv3 bf1 bf2 = and [(bf1 r s t) <=> (bf2 r s t) | r <- [True,False],

s <- [True,False], t <- [True,False]]

formula3 p q = p formula4 p q = (p <+> q) <+> qformula5 p q = p <=> ((p <+> q) <+> q)

*Haskell> logEquiv2 formula3 formula4True*Haskell> logEquiv2 formula4 formula5False


Equivalence continued:

logEquiv1 id (\ p -> not (not p))logEquiv1 id (\ p -> p && p) logEquiv1 id (\ p -> p || p) logEquiv2 (\ p q -> p ==> q) (\ p q -> not p || q) logEquiv2 (\ p q -> not (p ==> q)) (\ p q -> p && not q) logEquiv2 (\ p q -> not p ==> not q) (\ p q -> q ==> p) logEquiv2 (\ p q -> p ==> not q) (\ p q -> q ==> not p) logEquiv2 (\ p q -> not p ==> q) (\ p q -> not q ==> p) logEquiv2 (\ p q -> p <=> q) (\ p q -> (p ==> q) && (q ==> p))logEquiv2 (\ p q -> p <=> q) (\ p q -> (p && q) || (not p && not q))logEquiv2 (\ p q -> p && q) (\ p q -> q && p) logEquiv2 (\ p q -> p || q) (\ p q -> q || p) logEquiv2 (\ p q -> not (p && q)) (\ p q -> not p || not q) logEquiv2 (\ p q -> not (p || q)) (\ p q -> not p && not q) logEquiv3 (\ p q r -> p && (q && r)) (\ p q r -> (p && q) && r) logEquiv3 (\ p q r -> p || (q || r)) (\ p q r -> (p || q) || r) logEquiv3 (\ p q r -> p && (q || r)) (\ p q r -> (p && q) || (p && r)) test9b logEquiv3 (\ p q r -> p || (q && r)) (\ p q r -> (p || q) && (p || r))

-- Idempotence-- Idempotence-- Implication-- Contrapositive-- Contrapositive-- Contrapositive-- Contrapositive

-- Commutativity-- Commutativity-- deMorgan-- deMorgan-- Associativity-- Associativity-- Distributivity-- Distributivity


Why Reasoning with Truth Tables is Infeasible

Works fine when there are 2 variables{T,F} {T,F} = set of potential values of variables2 2 lines in truth table

Three variables — starts to get tedious{T,F} {T,F} {T,F} = set of potential values2 2 2 lines in truth table

Twenty variables — definitely out of hand2 2 … 2 lines (220)You want to look at a million lines?If you did, how would you avoid making errors?

Hundreds of variables — not in a million years

A need for Predicate Logic. We’ll look at this with Prolog.


Haskell and SQL


Standard Oracle scott/tiger emp dept database


emp = [ (7839, "KING", "PRESIDENT", 0, "17-NOV-81", 5000, 10),(7698, "BLAKE", "MANAGER", 7839, "01-MAY-81", 2850, 30),(7782, "CLARK", "MANAGER", 7839, "09-JUN-81", 2450, 10),(7566, "JONES", "MANAGER", 7839, "02-APR-81", 2975, 20),(7788, "SCOTT", "ANALYST", 7566, "09-DEC-82", 3000, 20),(7902, "FORD", "ANALYST", 7566, "03-DEC-81", 3000, 20),(7369, "SMITH", "CLERK", 7902, "17-DEC-80", 800, 20),(7499, "ALLEN", "SALESMAN", 7698, "20-FEB-81", 1600, 30),(7521, "WARD", "SALESMAN", 7698, "22-FEB-81", 1250, 30),(7654, "MARTIN", "SALESMAN", 7698, "28-SEP-81", 1250, 30),(7844, "TURNER", "SALESMAN", 7698, "08-SEP-81", 1500, 30),(7876, "ADAMS", "CLERK", 7788, "12-JAN-83", 1100, 20),(7900, "JAMES", "CLERK", 7698, "03-DEC-81", 950, 30),(7934, "MILLER", "CLERK", 7782, "23-JAN-82", 1300, 10) ]

dept = [ (10, "ACCOUNTING", "NEW YORK"), (20, "RESEARCH", "DALLAS"), (30, "SALES", "CHICAGO"), (40, "OPERATIONS", "BOSTON") ]

Standard Oracle scott/tiger emp dept database in Haskell


Main>Main> [(empno, ename, job, sal, deptno) | (empno, ename, job, _, _, sal, deptno) <- emp]

[(7839,"KING","PRESIDENT",5000,10),(7698,"BLAKE","MANAGER",2850,30),(7782,"CLARK","MANAGER",2450,10),(7566,"JONES","MANAGER",2975,20),(7788,"SCOTT","ANALYST",3000,20),(7902,"FORD","ANALYST",3000,20),(7369,"SMITH","CLERK",800,20),(7499,"ALLEN","SALESMAN",1600,30),(7521,"WARD","SALESMAN",1250,30),(7654,"MARTIN","SALESMAN",1250,30),(7844,"TURNER","SALESMAN",1500,30),(7876,"ADAMS","CLERK",1100,20),(7900,"JAMES","CLERK",950,30),(7934,"MILLER","CLERK",1300,10)]Main>


Main> [(empno, ename, job, sal, deptno) | (empno, ename, job, _, _, sal, deptno) <- emp, deptno == 10]

[(7839,"KING","PRESIDENT",5000,10),(7782,"CLARK","MANAGER",2450,10),(7934,"MILLER","CLERK",1300,10)]Main>


Main> [(empno, ename, job, sal, dname) | (empno, ename, job, _, _, sal, edeptno) <- emp, (deptno, dname, loc) <- dept, edeptno == deptno ]

[(7839,"KING","PRESIDENT",5000,"ACCOUNTING"),(7698,"BLAKE","MANAGER",2850,"SALES"),(7782,"CLARK","MANAGER",2450,"ACCOUNTING"),(7566,"JONES","MANAGER",2975,"RESEARCH"),(7788,"SCOTT","ANALYST",3000,"RESEARCH"),(7902,"FORD","ANALYST",3000,"RESEARCH"),(7369,"SMITH","CLERK",800,"RESEARCH"),(7499,"ALLEN","SALESMAN",1600,"SALES"),(7521,"WARD","SALESMAN",1250,"SALES"),(7654,"MARTIN","SALESMAN",1250,"SALES"),(7844,"TURNER","SALESMAN",1500,"SALES"),(7876,"ADAMS","CLERK",1100,"RESEARCH"),(7900,"JAMES","CLERK",950,"SALES"),(7934,"MILLER","CLERK",1300,"ACCOUNTING")]Main>


Main> length [sal | (_, _, _, _, _, sal, _) <- emp]

14Main>

Main> (\y -> fromIntegral(sum y) / fromIntegral(length y)) ([sal | (_, _, _, _, _, sal, _) <- emp])

2073.21428571429Main>


Main> map sqrt (map fromIntegral [sal | (_, _, _, _, _, sal, _) <- emp])

[70.7106781186548,53.3853912601566,49.4974746830583,54.5435605731786,54.7722557505166,54.7722557505166,28.2842712474619,40.0,35.3553390593274,35.3553390593274,38.7298334620742,33.166247903554,30.8220700148449,36.0555127546399]Main>


Main> (map sqrt . map fromIntegral) [sal | (_, _, _, _, _, sal, _) <- emp]

[70.7106781186548,53.3853912601566,49.4974746830583,54.5435605731786,54.7722557505166,54.7722557505166,28.2842712474619,40.0,35.3553390593274,35.3553390593274,38.7298334620742,33.166247903554,30.8220700148449,36.0555127546399]Main>


Main> zip ([name | (_, name, _, _, _, _, _) <- emp]) (map sqrt (map fromIntegral [sal | (_, _, _, _, _, sal, _) <- emp]))

[("KING",70.7106781186548),("BLAKE",53.3853912601566),("CLARK",49.4974746830583),("JONES",54.5435605731786),("SCOTT",54.7722557505166),("FORD",54.7722557505166),("SMITH",28.2842712474619),("ALLEN",40.0),("WARD",35.3553390593274),("MARTIN",35.3553390593274),("TURNER",38.7298334620742),("ADAMS",33.166247903554),("JAMES",30.8220700148449),("MILLER",36.0555127546399)]Main>


Main> [(name, sal, dept) | (_, name, _, _, _, sal, dept) <- emp, dept `elem` [20, 30]]

[("BLAKE",2850,30),("JONES",2975,20),("SCOTT",3000,20),("FORD",3000,20),("SMITH",800,20),("ALLEN",1600,30),("WARD",1250,30),("MARTIN",1250,30),("TURNER",1500,30),("ADAMS",1100,20),("JAMES",950,30)]Main>


Main> [(name, sal, dept) | (_, name, _, _, _, sal, dept) <- emp, dept `notElem` [20, 30]]

[("KING",5000,10),("CLARK",2450,10),("MILLER",1300,10)]Main>


Main> [(name, sal, dept) | (_, name, _, _, _, sal, dept) <- emp, dept `notElem` [20, 30]] ++ [(name, sal, dept) | (_, name, _, _, _, sal, dept) <- emp, dept `elem` [20, 30]]

[("KING",5000,10),("CLARK",2450,10),("MILLER",1300,10),("BLAKE",2850,30),("JONES",2975,20),("SCOTT",3000,20),("FORD",3000,20),("SMITH",800,20),("ALLEN",1600,30),("WARD",1250,30),("MARTIN",1250,30),("TURNER",1500,30),("ADAMS",1100,20),("JAMES",950,30)]Main>


db :: DBdb = [["release", "Blade Runner", "1982"],["release", "Alien", "1979"],["release", "Aliens", "1986"],["release", "Titanic", "1997"],["release", "Good Will Hunting", "1997"],["release", "Pulp Fiction", "1994"],["release", "Reservoir Dogs", "1992"],["release", "Romeo and Juliet", "1996"],…["direct", "Brian De Palma", "The Untouchables"],["direct", "James Cameron", "Titanic"],["direct", "James Cameron", "Aliens"],["direct", "Ridley Scott", "Alien"],["direct", "Ridley Scott", "Blade Runner"],["direct", "Ridley Scott", "Thelma and Louise"],["direct", "Gus Van Sant", "Good Will Hunting"],["direct", "Quentin Tarantino", "Pulp Fiction"],…["play", "Leonardo DiCaprio", "Romeo and Juliet", "Romeo"],["play", "Leonardo DiCaprio", "Titanic", "Jack Dawson"],["play", "Robin Williams", "Good Will Hunting", "Sean McGuire"],["play", "John Travolta", "Pulp Fiction", "Vincent Vega"],["play", "Harvey Keitel", "Reservoir Dogs", "Mr White"],["play", "Harvey Keitel", "Pulp Fiction", "Winston Wolf"],["play", "Uma Thurman", "Pulp Fiction", "Mia"],["play", "Quentin Tarantino", "Pulp Fiction", "Jimmie"],["play", "Quentin Tarantino", "Reservoir Dogs", "Mr Brown"],["play", "Sigourney Weaver", "Alien", "Ellen Ripley"],…

Movie Database


We’ll need the following:

-- nub is predefined in List but here's what it looks like:-- nub :: (Eq a) => [a] -> [a]-- nub [] = []-- nub (x:xs) = x : nub (remove x xs)-- where-- remove y [] = []-- remove y (z:zs) | y == z = remove y zs-- | otherwise = z : remove y zs

*Haskell> nub "Mississippi""Misp"



characters = nub [ x | ["play",_,_,x] <- db ]actors = nub [ x | ["play",x,_,_] <- db ]directors = nub [ x | ["direct",x,_] <- db ]movies = [ x | ["release",x,_] <- db ]dates = nub [ x | ["release",_,x] <- db ]universe = nub (characters++actors++directors++

movies++dates)



direct = [ (x,y) | ["direct",x,y] <- db ]act = [ (x,y) | ["play",x,y,_] <- db ]play = [ (x,y,z) | ["play",x,y,z] <- db ]release = [ (x,y) | ["release",x,y] <- db ]



charP = \ x -> elem x characters actorP = \ x -> elem x actorsmovieP = \ x -> elem x movies directorP = \ x -> elem x directorsdateP = \ x -> elem x dates actP = \ (x,y) -> elem (x,y) actreleaseP = \ (x,y) -> elem (x,y) release directP = \ (x,y) -> elem (x,y) direct playP = \ (x,y,z) -> elem (x,y,z) play


db :: DBdb = [["release", "Blade Runner", "1982"],["release", "Alien", "1979"],["release", "Aliens", "1986"],["release", "Titanic", "1997"],["release", "Good Will Hunting", "1997"],["release", "Pulp Fiction", "1994"],["release", "Reservoir Dogs", "1992"],["release", "Romeo and Juliet", "1996"],

…["direct", "Brian De Palma", "The Untouchables"],["direct", "James Cameron", "Titanic"],["direct", "James Cameron", "Aliens"],["direct", "Ridley Scott", "Alien"],["direct", "Ridley Scott", "Blade Runner"],["direct", "Ridley Scott", "Thelma and Louise"],["direct", "Gus Van Sant", "Good Will Hunting"],["direct", "Quentin Tarantino", "Pulp Fiction"],

…["play", "Leonardo DiCaprio", "Romeo and Juliet", "Romeo"],["play", "Leonardo DiCaprio", "Titanic", "Jack Dawson"],["play", "Robin Williams", "Good Will Hunting", "Sean McGuire"],["play", "John Travolta", "Pulp Fiction", "Vincent Vega"],["play", "Harvey Keitel", "Reservoir Dogs", "Mr White"],["play", "Harvey Keitel", "Pulp Fiction", "Winston Wolf"],["play", "Uma Thurman", "Pulp Fiction", "Mia"],["play", "Quentin Tarantino", "Pulp Fiction", "Jimmie"],["play", "Quentin Tarantino", "Reservoir Dogs", "Mr Brown"],["play", "Sigourney Weaver", "Alien", "Ellen Ripley"],…

Actors that are also Directorsq1 = [ x | x <- actors, directorP x ]Actors that are also Directors and their filmsq2 = [ (x,y) | (x,y) <- act, directorP x ]Directors, their Films and Release Dates – incorrect versionq3 = [ (x,y,z) | (x,y) <- direct, (y,z) <- release ]Directors, their Films and Release Dates – correct versionq4 = [ (x,y,z) | (x,y) <- direct, (u,z) <- release, y == u ]Directors and their films released in 1995q5 = [ (x,y) | (x,y) <- direct, (u,"1995") <- release, y == u ]Directors, Films and Release Date for those released after 1995q6 = [ (x,y,z) | (x,y) <- direct, (u,z) <- release, y == u, z > "1995"]Films in which Kevin Spacey actedq7 = [ x | ("Kevin Spacey",x) <- act ]William Hurt films released after 1997q8 = [ x | (x,y) <- release, y > "1997", actP ("William Hurt",x) ]Are there any films in which the director was also the actor?q9 = q1 /= []Does the database contain films directed by Woody Allenq10 = [ x | ("Woody Allen",x) <- direct ] /= []q10' = directorP "Woody Allen"


A Different View of Relations


empno = [ (7369, 7369),(7499, 7499),(7521, 7521),(7566, 7566),(7654, 7654),(7698, 7698),(7782, 7782),(7788, 7788),(7839, 7839),(7844, 7844),(7876, 7876),(7900, 7900),(7902, 7902),(7934, 7934) ]

ename = [ (7839, "KING"), (7698, "BLAKE"), (7782, "CLARK"), (7566, "JONES"), (7788, "SCOTT"), (7902, "FORD"), (7369, "SMITH"), (7499, "ALLEN"), (7521, "WARD"), (7654, "MARTIN"), (7844, "TURNER"), (7876, "ADAMS"), (7900, "JAMES"), (7934, "MILLER") ]

job = [(7839, "PRESIDENT"),(7698, "MANAGER"),(7782, "MANAGER"),(7566, "MANAGER"),(7788, "ANALYST"),(7902, "ANALYST"),(7369, "CLERK"),(7499, "SALESMAN"),(7521, "SALESMAN"),(7654, "SALESMAN"),(7844, "SALESMAN"),(7876, "CLERK"),(7900, "CLERK"),(7934, "CLERK") ]

sal = [ (7839, 5000), (5000, 7839),(7698, 2850), (2850, 7698),(7782, 2450), (2450, 7782),(7566, 2975), (2975, 7566),(7788, 3000), (3000, 7788),(7902, 3000), (3000, 7902),(7369, 800), (800, 7369),(7499, 1600), (1600, 7499), (7521, 1250), (1250, 7521),(7654, 1250), (1250, 7654),(7844, 1500), (1500, 7844),(7876, 1100), (1100, 7876),(7900, 950), (950, 7900),(7934, 1300), (1300, 7934) ]

deptno = [ (7839, 10), (10, 7839),(7698, 30), (30, 7698),(7782, 10), (10, 7782),(7566, 20), (20, 7566),(7788, 20), (20, 7788),(7902, 20), (20, 7902),(7369, 20), (20, 7369),(7499, 30), (30, 7499),(7521, 30), (30, 7521),(7654, 30), (30, 7654),(7844, 30), (30, 7844),(7876, 20), (20, 7876),(7900, 30), (30, 7900),(7934, 10), (10, 7934) ]

mgr = [ (7839, 0),(7698, 7839),(7782, 7839),(7566, 7839),(7788, 7566),(7902, 7566),(7369, 7902),(7499, 7698),(7521, 7698),(7654, 7698),(7844, 7698),(7876, 7788),(7900, 7698),(7934, 7782) ]

I mad

e th

ese

sym

met

ric


Main> [(empno, ename, job, sal, deptno) |(x0, empno) <- empno, (x1, ename) <- ename, (x2, job) <- job,(x3, sal) <- sal, (x4, deptno) <- deptno, x0 == x1 && x1 == x2 && x2 == x3 && x3 == x4]

[(7369,"SMITH","CLERK",800,20),(7499,"ALLEN","SALESMAN",1600,30),(7521,"WARD","SALESMAN",1250,30),(7566,"JONES","MANAGER",2975,20),(7654,"MARTIN","SALESMAN",1250,30),(7698,"BLAKE","MANAGER",2850,30),(7782,"CLARK","MANAGER",2450,10),(7788,"SCOTT","ANALYST",3000,20),(7839,"KING","PRESIDENT",5000,10),(7844,"TURNER","SALESMAN",1500,30),(7876,"ADAMS","CLERK",1100,20),(7900,"JAMES","CLERK",950,30),(7902,"FORD","ANALYST",3000,20),(7934,"MILLER","CLERK",1300,10)]Main>Main> [(empno, ename, job, sal, deptno) |

(empno, ename, job, _, _, sal, deptno) <- emp][(7839,"KING","PRESIDENT",5000,10),(7698,"BLAKE","MANAGER",2850,30),(7782,"CLARK","MANAGER",2450,10),(7566,"JONES","MANAGER",2975,20),(7788,"SCOTT","ANALYST",3000,20),(7902,"FORD","ANALYST",3000,20),(7369,"SMITH","CLERK",800,20),(7499,"ALLEN","SALESMAN",1600,30),(7521,"WARD","SALESMAN",1250,30),(7654,"MARTIN","SALESMAN",1250,30),(7844,"TURNER","SALESMAN",1500,30),(7876,"ADAMS","CLERK",1100,20),(7900,"JAMES","CLERK",950,30),(7934,"MILLER","CLERK",1300,10)]Main>


r{(1,2),(2,3),(2,4),(2,5),(2,6),(6,7),(6,8)}

ComposeR r 2{(1,3),(1,4),(1,5),(1,6),(2,7),(2,8)}

ComposeR r 3{(1,7),(1,8)}

ComposeR r 4{}

{(1,2),(2,3),(2,4),(2,5),(2,6),(6,7),(6,8)} composed with{(1,2),(2,3),(2,4),(2,5),(2,6),(6,7),(6,8)}

{(1,3),(1,4),(1,5),(1,6),(2,7),(2,8)}composed with{(1,2),(2,3),(2,4),(2,5),(2,6),(6,7),(6,8)}

{(1,7),(1,8)}composed with{(1,2),(2,3),(2,4),(2,5),(2,6),(6,7),(6,8)}

Composition of Relations


{(rose,phil),(phil,nicolette),(phil,antoinette),(phil,jeanette), (phil,philJ),(philJ,philJJ),(philJ,patrick)}

{(rose,nicolette),(rose,antoinette),(rose,jeanette),(rose,philJ), (phil,philJJ),(phil,patrick)}

{(rose,philJJ),(rose,patrick)}

Grandparent Relation


If 1 is rose, 2 is phil, 3 is nicolette, 4 is antoinette, 5 is jeanette,6 is philJ, 7 is philJJ and 8 is patrick

Great Grandparent Relation

r{(1,2),(2,3),(2,4),(2,5),(2,6),(6,7),(6,8)}

ComposeR r 2{(1,3),(1,4),(1,5),(1,6),(2,7),(2,8)}

ComposeR r 3{(1,7),(1,8)}

ComposeR r 4{}


Main> relationalComposition sal deptno[(5000,10),(2850,30),(2450,10),(2975,20),(3000,20),(800,20),(1600,30),(1250,30),(1500,30),(1100,20),(950,30),(1300,10)]Main>

Main> head (relationalComposition [("BLAKE", 7698)] (relationalComposition empno sal)) : head (relationalComposition [("BLAKE", 7698)] (relationalComposition empno deptno)) : relationalComposition[("BLAKE", 7698)] (relationalComposition empno mgr)

[("BLAKE",2850),("BLAKE",30),("BLAKE",7839)]Main>


This is not the last time we’ll see something similar to Composition of Relations:

parent(hank,ben).parent(hank,denise).parent(irene,ben).parent(irene,denise).parent(alice,carl).parent(ben,carl).parent(denise,frank).parent(denise,gary).parent(earl,frank).parent(earl,gary).

grandparent(X,Z) :- parent(X,Y) , parent(Y,Z).


List Comprehension

Main> [(empno, ename, job, sal, dname) | (empno, ename, job, _, _, sal, edeptno) <- emp, (deptno, dname, loc) <- dept, edeptno == deptno ]

10 haskell part 2 - university of texas at austincannata/cs345/class notes/10 haskell part 2.pdfdr....

Documents