Programming Languages Haskell Part 1

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 help Hugs> :load 09H1 Main> To load the file “09H1.hs” from the directory in which you started hugs

Haskell Expression Number Expressions Boolean Expressions Hugs> 2 * 4 ^2 32 Hugs> 8^2 64 Hugs> (2 * 4) ^ 2 Hugs> 2 + 4 ^ 2 18 Hugs> 2 ^ 200 1606938044258990275541962092341162602522202993782792835301376 Hugs> True && False False Hugs> True || False True Hugs> 3 < 5 Hugs> 'c' < 'p' Hugs> 'c' > 'p' Hugs> "tree" < "rock" Hugs> "tree" > "rock" Number Expressions Boolean Expressions Character Expressions String Expressions

Haskell Basic Data Structures Hugs> ("dog", "cat", 5) ("dog","cat",5) Hugs> ["dog", "cat", 5] ERROR - Cannot infer instance *** Instance : Num [Char] *** Expression : ["dog","cat",5] Hugs> ["dog", "cat", "5"] ["dog","cat","5"] Hugs> 1 : [] [1] Hugs> 1 : [2,3,4] [1,2,3,4] [expression | generator] Hugs> [2 * x ^ 2 | x <- [1, 2, 3 ,4]] [2,8,18,32] Hugs> [x * y | (x, y) <- [(1, 2), (3, 4), (5, 6)]] [2,12,30] Tuples Lists List Construction List Comprehension Haskell Basic Data Structures

Haskell Basic Data Structures continued List Comprehension Cross product “<“ and “>” Relation Factors of 72 Hugs> [(x, y) | x <- [1, 3 .. 6], y <- ['a', 'b', 'c', 'd']] [(1,'a'),(1,'b'),(1,'c'),(1,'d'),(3,'a'),(3,'b'),(3,'c'),(3,'d'),(5,'a'),(5,'b'),(5,'c'),(5,'d')] Hugs> [(x, y) | x <- [1..4], y <- [1..4]] [(1,1),(1,2),(1,3),(1,4),(2,1),(2,2),(2,3),(2,4),(3,1),(3,2),(3,3),(3,4),(4,1),(4,2),(4,3),(4,4)] Hugs> [(x, y) | x <- [0..4], y <- [0..4], x < y] [(0,1),(0,2),(0,3),(0,4),(1,2),(1,3),(1,4),(2,3),(2,4),(3,4)] Hugs> [(x, y) | x <- [0..4], y <- [0..4], x > y] [(1,0),(2,0),(2,1),(3,0),(3,1),(3,2),(4,0),(4,1),(4,2),(4,3)] Hugs> [x | x <- [1..100], y <- [1..100], 72 == x * y] [1,2,3,4,6,8,9,12,18,24,36,72]

Haskell Basic Data Structures - continued List Comprehension Database Query Main> [empno | (empno, _, _, _, _, _, _) <- emp] [7839,7698,7782,7566,7788,7902,7369,7499,7521,7654,7844,7876,7900,7934] Main> [empno | (empno, _, _, _, _, sal, _) <- emp, sal > 4000] [7839] Main> [empno | (empno, _, _, _, _, sal, _) <- emp, sal > 2000] [7839,7698,7782,7566,7788,7902]

Haskell Functions Hugs> :type product product :: Num a => [a] -> a Hugs> product [ 2, 3, 4 ] 24 Hugs> product [ x | x <- [1..10]] 3628800 Hugs> :type (+) (+) :: Num a => a -> a -> a Hugs> 3 + 5 8 Hugs> (+) 3 5 Hugs> (\ x -> x ^ 2 + 4) 5 29 product Function (+) Operator – an Operator is a 2-ary Function lambdas

Haskell Operators

Haskell Pattern Matching Hugs> :type not not :: Bool -> Bool Hugs> not True False Hugs> :type head head :: [a] -> a Hugs> head [5, 4, 3, 2, 1] 5 Hugs> :type map map :: (a -> b) -> [a] -> [b] Hugs> map sqrt [ 1, 4, 9, 10 ] [1.0,2.0,3.0,3.16227766016838] Hugs> map (\ x -> x + 2) [ 1, 2, 3, 4] [3,4,5,6] not :: Bool  Bool not False = True not True = False head :: [a] -> a head (x:xs) = x map :: (a -> b) -> [a] -> [b] map _ [] = [] map f (x:xs) = f x : map f xs

= = = = = Haskell Pattern Matching product [2,3,4] 2 * product [3,4] Hugs> product [ 2, 3, 4 ] 24 product :: [Int]  Int product [] = 1 product (x:xs) = x * product xs product [2,3,4] 2 * product [3,4] = 2 * (3 * product [4]) = 2 * (3 * (4 * product [])) = 2 * (3 * (4 * 1)) = 24 =

Haskell Conditional Expressions Let Expressions (i.e., local variables) Hugs> if True then 6 else 8 6 Hugs> if False then 6 else 8 8 Hugs> 2 + let x = sqrt 9 in (x + 1) * (x - 1) 10.0 not :: Bool  Bool not False = True not True = False Let assignment assignment . in (expression)

Lazy Evaluation: v = 1/0 testLazy x = 2 + 10 testLazy1 x = 2 / x *DBQ> v Infinity *DBQ> testLazy 22 12 *DBQ> testLazy v *DBQ> testLazy1 22 9.090909090909091e-2 *DBQ> testLazy1 v 0.0 *DBQ> testLazy1 1/0 1.#INF Main> (\x -> let y = x in (2 / y)) (1/0) 0.0 Main> (\x -> let y = x in (2 / y)) (0) 1.#INF