# 程序代写代做代考 Haskell Topic Pot Pourri: Scope, Lists, and Recursion

Topic Pot Pourri: Scope, Lists, and Recursion

Topic Pot Pourri: Scope, Lists, and Recursion

Prof. Susan Older

31 January 2017

(CIS 252) Scope, Lists, and Recursion 31 January 2017 1 / 12

Another Look at Function Definitions

Consider the following definition:

simple :: Int -> Int -> Int

simple a b = a + 3*b

The formal parameters a and b are names used as placeholders for
input values that may be passed into the function.

The single equation above represents a (very large!) collection of
mathematical relationships:

simple 10 7 = 10 + 3*7

simple 5 200 = 5 + 3*200

simple (-2) 4 = -2 + 3*4

simple 30 500 = 30 + 3*500

(CIS 252) Scope, Lists, and Recursion 31 January 2017 2 / 12

Another Look at Conditional Equations

Consider the following definition:

tame :: Int -> Int -> Int

tame a b

| b < 10 = simple a (b+2) | otherwise = b + 18 The conditional equation above represents a (very large!) collection of mathematical relationships: tame 10 7 = simple 10 (7+2) tame 5 200 = 200 + 18 tame (-2) 4 = simple (-2) (4 + 2) tame 300 5 = simple 300 (5+2) ... (CIS 252) Scope, Lists, and Recursion 31 January 2017 3 / 12 Scope: Which Name is Which? Consider the following code: x, y :: Int x = 10 y = 12 thrice :: Int -> Int

thrice x = 3*x

simple :: Int -> Int

simple x = x + y

extra :: Int -> Bool

extra y = x > y

There are eight definitions of names:

Five top-level definitions: x, y,
thrice, simple, extra.

Two definitions of name x as a
formal parameter: see thrice and
simple

One definition of name y as a
formal parameter: see extra

What is a definition’s scope?

The portion of the code where references
to that name refer to that specific
definition.

(CIS 252) Scope, Lists, and Recursion 31 January 2017 4 / 12

Scope in Haskell: How Does it Work?

Consider the following code:

x, y :: Int

x = 10

y = 12

thrice :: Int -> Int

thrice x = 3*x

simple :: Int -> Int

simple x = x + y

extra :: Int -> Bool

extra y = x > y

The formal parameter x in thrice:

Has as its scope the body of thrice

“Cuts a hole in the scope” of the
top-level definition of x

The formal parameter y in extra:

Has as its scope the body of extra

“Cuts a hole in the scope” of the
top-level definition of y

Top-level definitions have the entire
program (minus any holes cut by inner
declarations) as their scope

(CIS 252) Scope, Lists, and Recursion 31 January 2017 5 / 12

Local variables are visible only inside a definition:

maxSq :: Int -> Int -> Int

maxSq x y

| sq x > sq y = sq x

| otherwise = sq y

where

sq :: Int -> Int

sq w = w*w

maxSq’ :: Int -> Int -> Int

maxSq’ x y

| sqx > sqy = sqx

| otherwise = sqy

where

sqx = x*x

sqy = y*y

The ramifications:

sq is visible/usable only within definition of maxSq

sqx and sqy are visible/usable only within definition of maxSq’

(CIS 252) Scope, Lists, and Recursion 31 January 2017 6 / 12

Local Variables: Reasons to Use Them

Enhance the legibility of your code, especially when the same
calculation is performed multiple times

An example of their use:

— convert a measurement in inches to feet-and-inches

convert :: Float -> (Float, Float)

convert meas

| meas <0 = (0,0) -- avoid negative measures | otherwise = (feet, inches) where feet = fromInteger (floor (meas / 12)) inches = meas - 12*feet (CIS 252) Scope, Lists, and Recursion 31 January 2017 7 / 12 Introducing: Lists List Types Suppose t is a type. Then [t] is a type. [Bool] [Int] [Float] [Integer] [Char] [[Bool]] [[Int]] [[Float]] List Values The values of type [t] are lists whose elements all have type t. [True,False,False,True,False] :: [Bool] [5,10,15,24] :: [Int] [6.318, -2.5, 100.079] :: [Float] [[1,2,3],[10],[76,9],[3]] :: [[Int]] [’q’,’w’,’e’,’r’,’t’,’y’] :: [Char](= String) "qwerty" :: [Char](= String) (CIS 252) Scope, Lists, and Recursion 31 January 2017 8 / 12 The Simplest List is the Empty List: [] The empty list [ ] contains no elements. What is the type of [ ]? [ ] is polymorphic (Greek for “many shapes”): [ ] :: [a] In this usage, a is a type variable. Any valid type can be plugged in for a: [ ] :: [Bool] [ ] :: [Int] [ ] :: [Float] [ ] :: [[Bool]] ... (CIS 252) Scope, Lists, and Recursion 31 January 2017 9 / 12 Building up Lists: The List Constructor : is pronounced “cons”: (:) :: a -> [a] -> [a]

30:[] [30]

5:[10,20,30] [5, 10, 20, 30]

True:[True, False] [True, True, False]

’C’:[’u’,’s’,’e’] [’C’, ’u’,’s’,’e’] (= “Cuse”)

1:2:3:[] [1, 2, 3] (cons is right-associative)

17:[True, False] Type error!

(CIS 252) Scope, Lists, and Recursion 31 January 2017 10 / 12

Coming Full Circle: What Does This Function Do?

Consider the following code:

series :: Int -> a -> [a]

series n item

| n <= 0 = [] | otherwise = item : series (n-1) item This code represents a collection of mathematical relationships: series (-2) False = [] series (-1) False = [] series 0 False = [] series 1 False = False : series 0 False series 2 False = False : series 1 False series 3 False = False : series 2 False ... (CIS 252) Scope, Lists, and Recursion 31 January 2017 11 / 12 Recursion: Simple Idea, Powerful Technique Definition Recursion is the process of defining a mathematical object (such as a set or a function) in terms of itself. How do you generate a list containing n copies of item? If n is zero (or negative), return the empty list. If n is positive, then: Generate a list with n-1 copies of item Place an extra copy of item on the front of the list. series :: Int -> a -> [a]

series n item

| n <= 0 = [] | otherwise = item : series (n-1) item (CIS 252) Scope, Lists, and Recursion 31 January 2017 12 / 12

Posted in Uncategorized