ts tr - - PDF document

❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡

❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ❚r✐♣♦s P❛rt ■❆

▲❛✇r❡♥❝❡ ❈ P❛✉❧s♦♥ ❈♦♠♣✉t❡r ▲❛❜♦r❛t♦r② ❯♥✐✈❡rs✐t② ♦❢ ❈❛♠❜r✐❞❣❡ ❧♣✶✺❅❝❛♠✳❛❝✳✉❦ ❈♦♣②r✐❣❤t ❝ ✷✵✵✺ ❜② ▲❛✇r❡♥❝❡ ❈✳ P❛✉❧s♦♥

❈♦♥t❡♥ts

✶ ■♥tr♦❞✉❝t✐♦♥ ✶ ✷ ❘❡❝✉rs✐✈❡ ❋✉♥❝t✐♦♥s ✶✹ ✸ O ◆♦t❛t✐♦♥✿ ❊st✐♠❛t✐♥❣ ❈♦sts ✐♥ t❤❡ ▲✐♠✐t ✷✺ ✹ ▲✐sts ✸✻ ✺ ▼♦r❡ ♦♥ ▲✐sts ✹✻ ✻ ❙♦rt✐♥❣ ✺✻ ✼ ❉❛t❛t②♣❡s ❛♥❞ ❚r❡❡s ✻✺ ✽ ❉✐❝t✐♦♥❛r✐❡s ❛♥❞ ❋✉♥❝t✐♦♥❛❧ ❆rr❛②s ✼✽ ✾ ◗✉❡✉❡s ❛♥❞ ❙❡❛r❝❤ ❙tr❛t❡❣✐❡s ✽✼ ✶✵ ❋✉♥❝t✐♦♥s ❛s ❱❛❧✉❡s ✾✼ ✶✶ ▲✐st ❋✉♥❝t✐♦♥❛❧s ✶✵✽ ✶✷ P♦❧②♥♦♠✐❛❧ ❆r✐t❤♠❡t✐❝ ✶✶✽ ✶✸ ❙❡q✉❡♥❝❡s✱ ♦r ▲❛③② ▲✐sts ✶✷✽ ✶✹ ❊❧❡♠❡♥ts ♦❢ Pr♦❝❡❞✉r❛❧ Pr♦❣r❛♠♠✐♥❣ ✶✸✽ ✶✺ ▲✐♥❦❡❞ ❉❛t❛ ❙tr✉❝t✉r❡s ✶✹✾

■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶ ❚❤✐s ❝♦✉rs❡ ❤❛s t✇♦ ♦❜❥❡❝t✐✈❡s✳ ❋✐rst ✭❛♥❞ ♦❜✈✐♦✉s✮ ✐s t♦ t❡❛❝❤ ♣r♦❣r❛♠✲ ♠✐♥❣✳ ❙❡❝♦♥❞ ✐s t♦ ♣r❡s❡♥t s♦♠❡ ❢✉♥❞❛♠❡♥t❛❧ ♣r✐♥❝✐♣❧❡s ♦❢ ❝♦♠♣✉t❡r s❝✐❡♥❝❡✱ ❡s♣❡❝✐❛❧❧② ❛❧❣♦r✐t❤♠ ❞❡s✐❣♥✳ ▼♦st st✉❞❡♥ts ✇✐❧❧ ❤❛✈❡ s♦♠❡ ♣r♦❣r❛♠♠✐♥❣ ❡①✲ ♣❡r✐❡♥❝❡ ❛❧r❡❛❞②✱ ❜✉t t❤❡r❡ ❛r❡ ❢❡✇ ♣❡♦♣❧❡ ✇❤♦s❡ ♣r♦❣r❛♠♠✐♥❣ ❝❛♥♥♦t ❜❡ ✐♠♣r♦✈❡❞ t❤r♦✉❣❤ ❣r❡❛t❡r ❦♥♦✇❧❡❞❣❡ ♦❢ ❜❛s✐❝ ♣r✐♥❝✐♣❧❡s✳ P❧❡❛s❡ ❜❡❛r t❤✐s ♣♦✐♥t ✐♥ ♠✐♥❞ ✐❢ ②♦✉ ❤❛✈❡ ❡①t❡♥s✐✈❡ ❡①♣❡r✐❡♥❝❡ ❛♥❞ ✜♥❞ ♣❛rts ♦❢ t❤❡ ❝♦✉rs❡ r❛t❤❡r s❧♦✇✳ ❚❤❡ ♣r♦❣r❛♠♠✐♥❣ ✐♥ t❤✐s ❝♦✉rs❡ ✐s ❜❛s❡❞ ♦♥ t❤❡ ❧❛♥❣✉❛❣❡ ▼▲ ❛♥❞ ♠♦st❧② ❝♦♥❝❡r♥s t❤❡ ❢✉♥❝t✐♦♥❛❧ ♣r♦❣r❛♠♠✐♥❣ st②❧❡✳ ❋✉♥❝t✐♦♥❛❧ ♣r♦❣r❛♠s t❡♥❞ t♦ ❜❡ s❤♦rt❡r ❛♥❞ ❡❛s✐❡r t♦ ✉♥❞❡rst❛♥❞ t❤❛♥ t❤❡✐r ❝♦✉♥t❡r♣❛rts ✐♥ ❝♦♥✈❡♥t✐♦♥❛❧ ❧❛♥❣✉❛❣❡s s✉❝❤ ❛s ❈✳ ■♥ t❤❡ s♣❛❝❡ ♦❢ ❛ ❢❡✇ ✇❡❡❦s✱ ✇❡ s❤❛❧❧ ❜❡ ❛❜❧❡ t♦ ❝♦✈❡r ♠♦st ♦❢ t❤❡ ❢♦r♠s ♦❢ ❞❛t❛ str✉❝t✉r❡s s❡❡♥ ✐♥ ♣r♦❣r❛♠♠✐♥❣✳ ❚❤❡ ❝♦✉rs❡ ❛❧s♦ ❝♦✈❡rs ❜❛s✐❝ ♠❡t❤♦❞s ❢♦r ❡st✐♠❛t✐♥❣ ❡✣❝✐❡♥❝②✳ ▲❡❛r♥✐♥❣ ●✉✐❞❡✳ ❙✉❣❣❡st✐♦♥s ❢♦r ❢✉rt❤❡r r❡❛❞✐♥❣✱ ❞✐s❝✉ss✐♦♥ t♦♣✐❝s✱ ❡①✲ ❡r❝✐s❡s ❛♥❞ ♣❛st ❡①❛♠ q✉❡st✐♦♥s ❛♣♣❡❛r ❛t t❤❡ ❡♥❞ ♦❢ ❡❛❝❤ ❧❡❝t✉r❡✳ ❊①tr❛ r❡❛❞✐♥❣ ✐s ♠♦st❧② ❞r❛✇♥ ❢r♦♠ ♠② ❜♦♦❦ ▼▲ ❢♦r t❤❡ ❲♦r❦✐♥❣ Pr♦❣r❛♠♠❡r ✭s❡❝♦♥❞ ❡❞✐t✐♦♥✮✱ ✇❤✐❝❤ ❛❧s♦ ❝♦♥t❛✐♥s ♠❛♥② ❡①❡r❝✐s❡s✳ ❨♦✉ ❝❛♥ ✜♥❞ r❡❧❡✈❛♥t ❡①❛♠ q✉❡st✐♦♥s ✐♥ t❤❡ P❛rt ■❆ ♣❛♣❡rs ❢r♦♠ ✶✾✾✽ ♦♥✇❛r❞s✳ ✭❊❛r❧✐❡r ♣❛♣❡rs ♣❡rt❛✐♥ t♦ ❛ ♣r❡❞❡❝❡ss♦r ♦❢ t❤✐s ❝♦✉rs❡✳✮ ❚❤❛♥❦s t♦ ❉❛✈✐❞ ❆❧❧s♦♣♣✱ ❙t✉❛rt ❇❡❝❦❡r✱ ●❛✈✐♥ ❇✐❡r♠❛♥✱ ❙✐❧❛s ❇r♦✇♥✱ ❉❛✈✐❞ ❈♦tt✐♥❣❤❛♠✱ ❉❛♥✐❡❧ ❍✉❧♠❡✱ ❋r❛♥❦ ❑✐♥❣✱ ❏♦s❡♣❤ ▲♦r❞✱ ❏❛♠❡s ▼❛r✲ ❣❡ts♦♥✱ ❉❛✈✐❞ ▼♦r❣❛♥ ❛♥❞ ❋r❛♥❦ ❙t❛❥❛♥♦ ❢♦r ♣♦✐♥t✐♥❣ ♦✉t ❡rr♦rs ✐♥ t❤❡s❡ ♥♦t❡s✳ P❧❡❛s❡ ✐♥❢♦r♠ ♠❡ ♦❢ ❢✉rt❤❡r ❡rr♦rs ❛♥❞ ♦❢ ♣❛ss❛❣❡s t❤❛t ❛r❡ ♣❛rt✐❝✉✲ ❧❛r❧② ❤❛r❞ t♦ ✉♥❞❡rst❛♥❞✳ ■❢ ■ ✉s❡ ②♦✉r s✉❣❣❡st✐♦♥✱ ■✬❧❧ ❛❝❦♥♦✇❧❡❞❣❡ ✐t ✐♥ t❤❡ ♥❡①t ♣r✐♥t✐♥❣✳ ❘❡❛❞✐♥❣ ▲✐st ▼② ♦✇♥ ❜♦♦❦ ✐s ♥♦t ❜❛s❡❞ ♦♥ t❤❡s❡ ♥♦t❡s✱ ❜✉t t❤❡r❡ ✐s s♦♠❡ ♦✈❡r❧❛♣✳ ❚❤❡ ❍❛♥s❡♥✴❘✐s❝❤❡❧ ❛♥❞ ❯❧❧♠❛♥ ❜♦♦❦s ❛r❡ ❣♦♦❞ ❛❧t❡r♥❛t✐✈❡s✳ ❚❤❡ ▲✐tt❧❡ ▼▲❡r ✐s ❛ r❛t❤❡r q✉✐r❦② t✉t♦r✐❛❧ ♦♥ r❡❝✉rs✐♦♥ ❛♥❞ t②♣❡s✳ ❙❡❡ ■♥tr♦❞✉❝t✐♦♥ t♦ ❆❧❣♦✲ r✐t❤♠s ❢♦r O✲♥♦t❛t✐♦♥✳

• P❛✉❧s♦♥✱ ▲❛✇r❡♥❝❡ ❈✳ ✭✶✾✾✻✮✳ ▼▲ ❢♦r t❤❡ ❲♦r❦✐♥❣ Pr♦❣r❛♠♠❡r✳ ❈❛♠✲

❜r✐❞❣❡ ❯♥✐✈❡rs✐t② Pr❡ss ✭✷♥❞ ❡❞✳✮✳

• ❍❛♥s❡♥✱ ▼✐❝❤❛❡❧ ❛♥❞ ❘✐s❝❤❡❧✱ ❍❛♥s ✭✶✾✾✾✮ ■♥tr♦❞✉❝t✐♦♥ t♦ Pr♦❣r❛♠✲

♠✐♥❣ ❯s✐♥❣ ❙▼▲✳ ❆❞❞✐s♦♥✲❲❡s❧❡②✳

• ❯❧❧♠❛♥✱ ❏❡✛r❡② ❉✳ ✭✶✾✾✽✮ ❊❧❡♠❡♥ts ♦❢ ▼▲✾✼ Pr♦❣r❛♠♠✐♥❣✳ Pr❡♥t✐❝❡

❍❛❧❧✳

• ▼❛tt✐❛s ❋❡❧❧❡✐s❡♥ ❛♥❞ ❉❛♥✐❡❧ P✳ ❋r✐❡❞♠❛♥ ✭✶✾✾✽✮✳

❚❤❡ ▲✐tt❧❡ ▼▲❡r✳ ▼■❚ Pr❡ss✳

• ❚❤♦♠❛s ❍✳ ❈♦r♠❡♥✱ ❈❤❛r❧❡s ❊✳ ▲❡✐s❡rs♦♥ ❛♥❞ ❘♦♥❛❧❞ ▲✳ ❘✐✈❡st ✭✶✾✾✵✮✳

■♥tr♦❞✉❝t✐♦♥ t♦ ❆❧❣♦r✐t❤♠s✳ ▼■❚ Pr❡ss✳

■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✷

Slide 101 Computers: a child can use them; NOBODY can fully understand them! We can master complexity through levels of abstraction. Focus on 2 or 3 levels at most! Recurring issues:

• what services to provide at each level
• how to implement them using lower-level services
• the interface: how the two levels should communicate

❆ ❜❛s✐❝ ❝♦♥❝❡♣t ✐♥ ❝♦♠♣✉t❡r s❝✐❡♥❝❡ ✐s t❤❛t ❧❛r❣❡ s②st❡♠s ❝❛♥ ♦♥❧② ❜❡ ✉♥❞❡rst♦♦❞ ✐♥ ❧❡✈❡❧s✱ ✇✐t❤ ❡❛❝❤ ❧❡✈❡❧ ❢✉rt❤❡r s✉❜❞✐✈✐❞❡❞ ✐♥t♦ ❢✉♥❝t✐♦♥s ♦r s❡r✈✐❝❡s ♦❢ s♦♠❡ s♦rt✳ ❚❤❡ ✐♥t❡r❢❛❝❡ t♦ t❤❡ ❤✐❣❤❡r ❧❡✈❡❧ s❤♦✉❧❞ s✉♣♣❧② t❤❡ ❛❞✈❡rt✐s❡❞ s❡r✈✐❝❡s✳ ❏✉st ❛s ✐♠♣♦rt❛♥t✱ ✐t s❤♦✉❧❞ ❜❧♦❝❦ ❛❝❝❡ss t♦ t❤❡ ♠❡❛♥s ❜② ✇❤✐❝❤ t❤♦s❡ s❡r✈✐❝❡s ❛r❡ ✐♠♣❧❡♠❡♥t❡❞✳ ❚❤✐s ❛❜str❛❝t✐♦♥ ❜❛rr✐❡r ❛❧❧♦✇s ♦♥❡ ❧❡✈❡❧ t♦ ❜❡ ❝❤❛♥❣❡❞ ✇✐t❤♦✉t ❛✛❡❝t✐♥❣ ❧❡✈❡❧s ❛❜♦✈❡✳ ❋♦r ❡①❛♠♣❧❡✱ ✇❤❡♥ ❛ ♠❛♥✉❢❛❝t✉r❡r ❞❡s✐❣♥s ❛ ❢❛st❡r ✈❡rs✐♦♥ ♦❢ ❛ ♣r♦❝❡ss♦r✱ ✐t ✐s ❡ss❡♥t✐❛❧ t❤❛t ❡①✐st✐♥❣ ♣r♦❣r❛♠s ❝♦♥t✐♥✉❡ t♦ r✉♥ ♦♥ ✐t✳ ❆♥② ❞✐✛❡r❡♥❝❡s ❜❡t✇❡❡♥ t❤❡ ♦❧❞ ❛♥❞ ♥❡✇ ♣r♦❝❡ss♦rs s❤♦✉❧❞ ❜❡ ✐♥✈✐s✐❜❧❡ t♦ t❤❡ ♣r♦❣r❛♠✳ ▼♦❞❡r♥ ♣r♦❝❡ss♦rs ❤❛✈❡ ❡❧❛❜♦r❛t❡ s♣❡❝✐✜❝❛t✐♦♥s✱ ✇❤✐❝❤ st✐❧❧ s♦♠❡t✐♠❡s ❧❡❛✈❡ ♦✉t ✐♠♣♦rt❛♥t ❞❡t❛✐❧s✳ ■♥ t❤❡ ♦❧❞ ❞❛②s✱ ②♦✉ t❤❡♥ ❤❛❞ t♦ ❝♦♥s✉❧t t❤❡ ❝✐r❝✉✐t ❞✐❛❣r❛♠s✳

■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✸

Slide 102

Example I: Dates

Abstract level: names for dates over a certain range Concrete level: typically 6 characters: YYMMDD Date crises caused by INADEQUATE internal formats:

• Digital’s PDP-10: using 12-bit dates (good for at most 11 years)
• 2000 crisis: 48 bits could be good for lifetime of universe!

Lessons:

• Information can be represented in many ways.
• Get it wrong, and you will be sorry!

❉✐❣✐t❛❧ ❊q✉✐♣♠❡♥t ❈♦r♣♦r❛t✐♦♥✬s ❞❛t❡ ❝r✐s✐s ♦❝❝✉rr❡❞ ✐♥ ✶✾✼✺✳ ❚❤❡ P❉P✲ ✶✵ ✇❛s ❛ ✸✻✲❜✐t ♠❛✐♥❢r❛♠❡ ❝♦♠♣✉t❡r✳ ■t r❡♣r❡s❡♥t❡❞ ❞❛t❡s ✉s✐♥❣ ❛ ✶✷✲❜✐t ❢♦r♠❛t ❞❡s✐❣♥❡❞ ❢♦r t❤❡ t✐♥② P❉P✲✽✳ ❲✐t❤ ✶✷ ❜✐ts✱ ♦♥❡ ❝❛♥ ❞✐st✐♥❣✉✐s❤ 212 = 4096 ❞❛②s ♦r ✶✶ ②❡❛rs✳ ❚❤❡ ♠♦st ❝♦♠♠♦♥ ✐♥❞✉str② ❢♦r♠❛t ❢♦r ❞❛t❡s ✉s❡s s✐① ❝❤❛r❛❝t❡rs✿ t✇♦ ❢♦r t❤❡ ②❡❛r✱ t✇♦ ❢♦r t❤❡ ♠♦♥t❤ ❛♥❞ t✇♦ ❢♦r t❤❡ ❞❛②✳ ❚❤❡ ♠♦st ❝♦♠♠♦♥ ✏s♦❧✉t✐♦♥✑ t♦ t❤❡ ②❡❛r ✷✵✵✵ ❝r✐s✐s ✐s t♦ ❛❞❞ t✇♦ ❢✉rt❤❡r ❝❤❛r❛❝t❡rs✱ t❤❡r❡❜② ❛❧t❡r✐♥❣ ✜❧❡ s✐③❡s✳ ❖t❤❡rs ❤❛✈❡ ♥♦t✐❝❡❞ t❤❛t t❤❡ ❡①✐st✐♥❣ s✐① ❝❤❛r❛❝t❡rs ❝♦♥s✐st ♦❢ ✹✽ ❜✐ts✱ ❛❧r❡❛❞② s✉✣❝✐❡♥t t♦ r❡♣r❡s❡♥t ❛❧❧ ❞❛t❡s ♦✈❡r t❤❡ ♣r♦❥❡❝t❡❞ ❧✐❢❡t✐♠❡ ♦❢ t❤❡ ✉♥✐✈❡rs❡✿ 248 = 2.8 × 1014 ❞❛②s = 7.7 × 1011 ②❡❛rs✦ ▼❛t❤❡♠❛t✐❝✐❛♥s t❤✐♥❦ ✐♥ t❡r♠s ♦❢ ✉♥❜♦✉♥❞❡❞ r❛♥❣❡s✱ ❜✉t t❤❡ r❡♣r❡s❡♥✲ t❛t✐♦♥ ✇❡ ❝❤♦♦s❡ ❢♦r t❤❡ ❝♦♠♣✉t❡r ✉s✉❛❧❧② ✐♠♣♦s❡s ❤❛r❞ ❧✐♠✐ts✳ ❆ ❣♦♦❞ ♣r♦✲ ❣r❛♠♠✐♥❣ ❧❛♥❣✉❛❣❡ ❧✐❦❡ ▼▲ ❧❡ts ♦♥❡ ❡❛s✐❧② ❝❤❛♥❣❡ t❤❡ r❡♣r❡s❡♥t❛t✐♦♥ ✉s❡❞ ✐♥ t❤❡ ♣r♦❣r❛♠✳ ❇✉t ✐❢ ✜❧❡s ✐♥ t❤❡ ♦❧❞ r❡♣r❡s❡♥t❛t✐♦♥ ❡①✐st ❛❧❧ ♦✈❡r t❤❡ ♣❧❛❝❡✱ t❤❡r❡ ✇✐❧❧ st✐❧❧ ❜❡ ❝♦♥✈❡rs✐♦♥ ♣r♦❜❧❡♠s✳ ❚❤❡ ♥❡❡❞ ❢♦r ❝♦♠♣❛t✐❜✐❧✐t② ✇✐t❤ ♦❧❞❡r s②st❡♠s ❝❛✉s❡s ♣r♦❜❧❡♠s ❛❝r♦ss t❤❡ ❝♦♠♣✉t❡r ✐♥❞✉str②✳

■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✹

Slide 103

Example II: Floating-Point Numbers

Computers have integers like 1066 and reals like 1.066 × 103. A floating-point number is represented by two integers. Both types come in different precisions: their range and accuracy. The concept of DATA TYPE comprises

• how a value is represented inside the computer, and
• the suite of operations given to programmers.

❋❧♦❛t✐♥❣ ♣♦✐♥t ♥✉♠❜❡rs ❛r❡ ✇❤❛t ②♦✉ ❣❡t ♦♥ ❛♥② ♣♦❝❦❡t ❝❛❧❝✉❧❛t♦r✳ ■♥✲ t❡r♥❛❧❧②✱ ❛ ✢♦❛t ❝♦♥s✐sts ♦❢ t✇♦ ✐♥t❡❣❡rs✿ t❤❡ ♠❛♥t✐ss❛ ✭❢r❛❝t✐♦♥❛❧ ♣❛rt✮ ❛♥❞ t❤❡ ❡①♣♦♥❡♥t✳ ❈♦♠♣❧❡① ♥✉♠❜❡rs✱ ❝♦♥s✐st✐♥❣ ♦❢ t✇♦ r❡❛❧s✱ ♠✐❣❤t ❜❡ ♣r♦✈✐❞❡❞✳ ❲❡ ❤❛✈❡ t❤r❡❡ ❧❡✈❡❧s ♦❢ ♥✉♠❜❡rs ❛❧r❡❛❞②✦ ▼♦st ❝♦♠♣✉t❡rs ❣✐✈❡ ✉s ❛ ❝❤♦✐❝❡ ♦❢ ♣r❡❝✐s✐♦♥s✱ t♦♦✳ ■♥ ✸✷✲❜✐t ♣r❡❝✐s✐♦♥✱ ✐♥t❡❣❡rs t②♣✐❝❛❧❧② r❛♥❣❡ ❢r♦♠ 231 − 1 ✭♥❛♠❡❧② ✷✱✶✹✼✱✹✽✸✱✻✹✼✮ t♦ −231❀ r❡❛❧s ❛r❡ ❛❝❝✉r❛t❡ t♦ ❛❜♦✉t s✐① ❞❡❝✐♠❛❧ ♣❧❛❝❡s ❛♥❞ ❝❛♥ ❣❡t ❛s ❧❛r❣❡ ❛s 1035 ♦r s♦✳ ❋♦r r❡❛❧s✱ ✻✹✲❜✐t ♣r❡❝✐s✐♦♥ ✐s ♦❢t❡♥ ♣r❡❢❡rr❡❞✳ ❍♦✇ ❞♦ ✇❡ ❦❡❡♣ tr❛❝❦ ♦❢ s♦ ♠❛♥② ❦✐♥❞s ♦❢ ♥✉♠❜❡rs❄ ■❢ ✇❡ ❛♣♣❧② ✢♦❛t✐♥❣✲♣♦✐♥t ❛r✐t❤♠❡t✐❝ t♦ ❛♥ ✐♥t❡❣❡r✱ t❤❡ r❡s✉❧t ✐s ✉♥❞❡✜♥❡❞ ❛♥❞ ♠✐❣❤t ❡✈❡♥ ✈❛r② ❢r♦♠ ♦♥❡ ✈❡rs✐♦♥ ♦❢ ❛ ❝❤✐♣ t♦ ❛♥♦t❤❡r✳ ❊❛r❧② ❧❛♥❣✉❛❣❡s ❧✐❦❡ ❋♦rtr❛♥ r❡q✉✐r❡❞ ✈❛r✐❛❜❧❡s t♦ ❜❡ ❞❡❝❧❛r❡❞ ❛s ✐♥t❡❣❡r ♦r r❡❛❧ ❛♥❞ ♣r❡✈❡♥t❡❞ ♣r♦❣r❛♠♠❡rs ❢r♦♠ ♠✐①✐♥❣ ❜♦t❤ ❦✐♥❞s ♦❢ ♥✉♠❜❡r ✐♥ ❛ ❝♦♠♣✉t❛t✐♦♥✳ ◆♦✇❛❞❛②s✱ ♣r♦❣r❛♠s ❤❛♥❞❧❡ ♠❛♥② ❞✐✛❡r❡♥t ❦✐♥❞s ♦❢ ❞❛t❛✱ ✐♥❝❧✉❞✐♥❣ t❡①t ❛♥❞ s②♠❜♦❧s✳ ▼♦❞❡r♥ ❧❛♥❣✉❛❣❡s ✉s❡ t❤❡ ❝♦♥❝❡♣t ♦❢ ❞❛t❛ t②♣❡ t♦ ❡♥s✉r❡ t❤❛t ❛ ❞❛t✉♠ ✉♥❞❡r❣♦❡s ♦♥❧② t❤♦s❡ ♦♣❡r❛t✐♦♥s t❤❛t ❛r❡ ♠❡❛♥✐♥❣❢✉❧ ❢♦r ✐t✳ ■♥s✐❞❡ t❤❡ ❝♦♠♣✉t❡r✱ ❛❧❧ ❞❛t❛ ❛r❡ st♦r❡❞ ❛s ❜✐ts✳ ❉❡t❡r♠✐♥✐♥❣ ✇❤✐❝❤ t②♣❡ ❛ ♣❛rt✐❝✉❧❛r ❜✐t ♣❛tt❡r♥ ❜❡❧♦♥❣s t♦ ✐s ✐♠♣♦ss✐❜❧❡ ✉♥❧❡ss s♦♠❡ ❜✐ts ❤❛✈❡ ❜❡❡♥ s❡t ❛s✐❞❡ ❢♦r t❤❛t ✈❡r② ♣✉r♣♦s❡ ✭❛s ✐♥ ❧❛♥❣✉❛❣❡s ❧✐❦❡ ▲✐s♣ ❛♥❞ Pr♦❧♦❣✮✳ ■♥ ♠♦st ❧❛♥❣✉❛❣❡s✱ t❤❡ ❝♦♠♣✐❧❡r ✉s❡s t②♣❡s t♦ ❣❡♥❡r❛t❡ ❝♦rr❡❝t ♠❛❝❤✐♥❡ ❝♦❞❡✱ ❛♥❞ t②♣❡s ❛r❡ ♥♦t st♦r❡❞ ❞✉r✐♥❣ ♣r♦❣r❛♠ ❡①❡❝✉t✐♦♥✳

■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✺

Slide 104

Some Abstraction Levels in a Computer

programmer high-level language

• perating system

device drivers, . . . machine language registers & processors gates silicon

❚❤❡s❡ ❛r❡ ❥✉st s♦♠❡ ♦❢ t❤❡ ❧❡✈❡❧s t❤❛t ♠✐❣❤t ❜❡ ✐❞❡♥t✐✜❡❞ ✐♥ ❛ ❝♦♠♣✉t❡r✳ ▼♦st ❧❛r❣❡✲s❝❛❧❡ s②st❡♠s ❛r❡ t❤❡♠s❡❧✈❡s ❞✐✈✐❞❡❞ ✐♥t♦ ❧❡✈❡❧s✳ ❋♦r ❡①❛♠♣❧❡✱ ❛ ♠❛♥❛❣❡♠❡♥t ✐♥❢♦r♠❛t✐♦♥ s②st❡♠ ♠❛② ❝♦♥s✐st ♦❢ s❡✈❡r❛❧ ❞❛t❛❜❛s❡ s②st❡♠s ❜♦❧t❡❞ t♦❣❡t❤❡r ♠♦r❡✲♦r✲❧❡ss ❡❧❡❣❛♥t❧②✳ ❚❤✐s ✐s t❤❡ ♣r♦❣r❛♠♠❡r✬s ✈✐❡✇✳ ❚❤❡ ✉s❡r s❡❡s ❛ ❞✐✛❡r❡♥t ❤✐❡r❛r❝❤②✱ ❞❡✲ t❡r♠✐♥❡❞ ❜② t❤❡ s❡♣❛r❛t❡ ❛♣♣❧✐❝❛t✐♦♥ ♣r♦❣r❛♠s✱ t❤❡ ♦♣❡r❛t✐♥❣ s②st❡♠✱ ❛♥❞ t❤❡ ✈✐s✐❜❧❡ ❤❛r❞✇❛r❡ s✉❝❤ ❛s t❤❡ s❝r❡❡♥ ❛♥❞ ❉❱❉✲✇r✐t❡r✳ ❍♦♠❡ ❝♦♠♣✉t✲ ❡rs ❛r❡ ♣♦ss✐❜❧❡ ❜❡❝❛✉s❡ t❤❡ ✉s❡r✬s ✈✐❡✇ ❝❛♥ ❜❡ s♦ ♠✉❝❤ s✐♠♣❧❡r t❤❛♥ t❤❡ ♣r♦❣r❛♠♠❡r✬s✳ ❈♦♠♠✉♥✐❝❛t✐♦♥s ♣r♦t♦❝♦❧s ✉s❡❞ ♦♥ t❤❡ ■♥t❡r♥❡t ❡♥❝♦♠♣❛ss s❡✈❡r❛❧ ❧❛②❡rs✳ ❊❛❝❤ ❧❛②❡r ❤❛s ❛ ❞✐✛❡r❡♥t t❛s❦✱ s✉❝❤ ❛s ♠❛❦✐♥❣ ✉♥r❡❧✐❛❜❧❡ ❧✐♥❦s r❡❧✐❛❜❧❡ ✭❜② tr②✐♥❣ ❛❣❛✐♥ ✐❢ ❛ tr❛♥s♠✐ss✐♦♥ ✐s ♥♦t ❛❝❦♥♦✇❧❡❞❣❡❞✮ ❛♥❞ ♠❛❦✐♥❣ ✐♥s❡❝✉r❡ ❧✐♥❦s s❡❝✉r❡ ✭✉s✐♥❣ ❝r②♣t♦❣r❛♣❤②✮✳ ■t s♦✉♥❞s ❝♦♠♣❧✐❝❛t❡❞✱ ❜✉t t❤❡ ♥❡❝❡ss❛r② s♦❢t✇❛r❡ ❝❛♥ ❜❡ ❢♦✉♥❞ ♦♥ ♠❛♥② ♣❡rs♦♥❛❧ ❝♦♠♣✉t❡rs✳ ■♥ t❤✐s ❝♦✉rs❡✱ ✇❡ ❢♦❝✉s ❛❧♠♦st ❡♥t✐r❡❧② ♦♥ ♣r♦❣r❛♠♠✐♥❣ ✐♥ ❛ ❤✐❣❤✲❧❡✈❡❧ ❧❛♥❣✉❛❣❡✿ ▼▲✳

■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✻

Slide 105

What is Programming?

• to describe a computation so that it can be done mechanically:

—Expressions compute values. —Commands cause effects.

• to do so efficiently, in both coding & execution
• to do so CORRECTLY, solving the right problem
• to allow easy modification as needs change
• to give LARGE programs a rational structure that others can

comprehend and extend

Pr♦❣r❛♠♠✐♥❣ ✐♥✲t❤❡✲s♠❛❧❧ ❝♦♥❝❡r♥s t❤❡ ✇r✐t✐♥❣ ♦❢ ❝♦❞❡ t♦ ❞♦ s✐♠♣❧❡✱ ❝❧❡❛r❧② ❞❡✜♥❡❞ t❛s❦s✳ Pr♦❣r❛♠s ♣r♦✈✐❞❡ ❡①♣r❡ss✐♦♥s ❢♦r ❞❡s❝r✐❜✐♥❣ ♠❛t❤❡✲ ♠❛t✐❝❛❧ ❢♦r♠✉❧❛❡ ❛♥❞ s♦ ❢♦rt❤✳ ✭❚❤✐s ✇❛s t❤❡ ♦r✐❣✐♥❛❧ ❝♦♥tr✐❜✉t✐♦♥ ♦❢ ❋♦r✲ tr❛♥✱ t❤❡ ❢♦r♠✉❧❛ tr❛♥s❧❛t♦r✳ ❈♦♠♠❛♥❞s ❞❡s❝r✐❜❡ ❤♦✇ ❝♦♥tr♦❧ s❤♦✉❧❞ ✢♦✇ ❢r♦♠ ♦♥❡ ♣❛rt ♦❢ t❤❡ ♣r♦❣r❛♠ t♦ t❤❡ ♥❡①t✳ ❆s ✇❡ ❝♦❞❡ ❧❛②❡r ✉♣♦♥ ❧❛②❡r ✐♥ t❤❡ ✉s✉❛❧ ✇❛②✱ ✇❡ ❡✈❡♥t✉❛❧❧② ✜♥❞ ♦✉rs❡❧✈❡s ♣r♦❣r❛♠♠✐♥❣ ✐♥✲t❤❡✲❧❛r❣❡✿ ❥♦✐♥✐♥❣ ❧❛r❣❡ ♠♦❞✉❧❡s t♦ s♦❧✈❡ s♦♠❡ ♣♦ss✐❜❧② ✐❧❧✲ ❞❡✜♥❡❞ t❛s❦✳ ■t ❜❡❝♦♠❡s ❛ ❝❤❛❧❧❡♥❣❡ ✐❢ t❤❡ ♠♦❞✉❧❡s ✇❡r❡ ♥❡✈❡r ✐♥t❡♥❞❡❞ t♦ ✇♦r❦ t♦❣❡t❤❡r ✐♥ t❤❡ ✜rst ♣❧❛❝❡✳ Pr♦❣r❛♠♠❡rs ♥❡❡❞ ❛ ✈❛r✐❡t② ♦❢ s❦✐❧❧s✿

• t♦ ❝♦♠♠✉♥✐❝❛t❡ r❡q✉✐r❡♠❡♥ts✱ s♦ t❤❡② s♦❧✈❡ t❤❡ r✐❣❤t ♣r♦❜❧❡♠
• t♦ ❛♥❛❧②③❡ ♣r♦❜❧❡♠s✱ ❜r❡❛❦✐♥❣ t❤❡♠ ❞♦✇♥ ✐♥t♦ s♠❛❧❧❡r ♣❛rts
• t♦ ♦r❣❛♥✐③❡ s♦❧✉t✐♦♥s s❡♥s✐❜❧②✱ s♦ t❤❛t t❤❡② ❝❛♥ ❜❡ ✉♥❞❡rst♦♦❞ ❛♥❞

♠♦❞✐✜❡❞

• t♦ ❡st✐♠❛t❡ ❝♦sts✱ ❦♥♦✇✐♥❣ ✐♥ ❛❞✈❛♥❝❡ ✇❤❡t❤❡r ❛ ❣✐✈❡♥ ❛♣♣r♦❛❝❤ ✐s

❢❡❛s✐❜❧❡

• t♦ ✉s❡ ♠❛t❤❡♠❛t✐❝s t♦ ❛rr✐✈❡ ❛t ❝♦rr❡❝t ❛♥❞ s✐♠♣❧❡ s♦❧✉t✐♦♥s

❲❡ s❤❛❧❧ ❧♦♦❦ ❛t ❛❧❧ t❤❡s❡ ♣♦✐♥ts ❞✉r✐♥❣ t❤❡ ❝♦✉rs❡✱ t❤♦✉❣❤ ♣r♦❣r❛♠s ✇✐❧❧ ❜❡ t♦♦ s✐♠♣❧❡ t♦ ❤❛✈❡ ♠✉❝❤ r✐s❦ ♦❢ ❣❡tt✐♥❣ t❤❡ r❡q✉✐r❡♠❡♥ts ✇r♦♥❣✳

■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✼

Slide 106

Abstraction in Programming

• Application Programming Interfaces, or APIs (Windows, Mac):

—controlled access to operating systems facilities, etc.

• Modules (ML and many post-1980 languages):

—controlled access to a body of code

• Abstract Data Types, or ADTs (various early languages):

—controlled access to a hidden data structure

• Classes and objects: (Java, C++, Smalltalk, . . . )

—intermixed data structures and code —built into elaborate hierarchies

❊❛❝❤ ♦❢ t❤❡s❡ ♠❡❝❤❛♥✐s♠s ❤❛s ❛ ❝♦♠♠♦♥ ♣✉r♣♦s❡✿ t♦ ♣r♦✈✐❞❡ s❡r✈✐❝❡s t♦ ♣r♦❣r❛♠♠❡rs ✇❤✐❧❡ ❤✐❞✐♥❣ t❤❡ ❞❡t❛✐❧s ♦❢ ❤♦✇ t❤♦s❡ s❡r✈✐❝❡s ❛r❡ ✐♠♣❧❡♠❡♥t❡❞✳ ❋♦r❝✐♥❣ ♣r♦❣r❛♠♠❡rs t♦ ✉s❡ ❛ st❛♥❞❛r❞ ✐♥t❡r❢❛❝❡ ❤❡❧♣s t♦ ❡♥s✉r❡ t❤❛t t❤❡ s②st❡♠ ✇✐❧❧ st✐❧❧ ✇♦r❦ ✐❢ t❤❡ ✐♠♣❧❡♠❡♥t❛t✐♦♥ ❝❤❛♥❣❡s✳ ❙♦❢t✇❛r❡ t❤❛t r❡❢❡rs t♦ t❤❡ ❲✐♥❞♦✇s ❆P■s ❝❛♥ ❜❡ ❡①♣❡❝t❡❞ t♦ r✉♥ ♦♥ ♠❛♥② ❞✐✛❡r❡♥t ✈❡rs✐♦♥s ♦❢ ❲✐♥❞♦✇s t❤❛t ❤❛✈❡ ♠❛❥♦r ✐♥t❡r♥❛❧ ❞✐✛❡r❡♥❝❡s✳ ❆♥ ❆P■ ♠✐❣❤t ♣r♦✈✐❞❡ r♦✉t✐♥❡s t♦ ❞❡❧❡t❡ ❛ ✜❧❡ ♦r t♦ ❞r❛✇ ❛ ♠❡♥✉✳ Pr♦❣r❛♠♠✐♥❣ ❧❛♥❣✉❛❣❡s ❤❛✈❡ ✉s❡❞ ✈❛r✐♦✉s ♠❡❝❤❛♥✐s♠s t♦ ❛❧❧♦✇ ♦♥❡ ♣❛rt ♦❢ t❤❡ ♣r♦❣r❛♠ t♦ ♣r♦✈✐❞❡ ❆P■s t♦ ♦t❤❡r ♣❛rts✳ ▼♦❞✉❧❡s ❡♥❝❛♣s✉❧❛t❡ ❛ ❜♦❞② ♦❢ ❝♦❞❡✱ ❛❧❧♦✇✐♥❣ ♦✉ts✐❞❡ ❛❝❝❡ss ♦♥❧② t❤r♦✉❣❤ ❛ ♣r♦❣r❛♠♠❡r✲❞❡✜♥❡❞ ✐♥t❡r❢❛❝❡✳ ❆❜str❛❝t ❉❛t❛ ❚②♣❡s ❛r❡ ❛ s✐♠♣❧❡r ✈❡rs✐♦♥ ♦❢ t❤✐s ❝♦♥❝❡♣t✱ ✇❤✐❝❤ ✐♠♣❧❡♠❡♥t ❛ s✐♥❣❧❡ ❝♦♥❝❡♣t s✉❝❤ ❛s ❞❛t❡s ♦r ✢♦❛t✐♥❣✲♣♦✐♥t ♥✉♠❜❡rs✳ ❖❜❥❡❝t✲♦r✐❡♥t❡❞ ♣r♦❣r❛♠♠✐♥❣ ✐s t❤❡ ❧❛t❡st ❛♥❞ ♠♦st ❝♦♠♣❧✐❝❛t❡❞ ❛♣♣r♦❛❝❤ t♦ ♠♦❞✉❧❛r✐t②✳ ❈❧❛ss❡s ❞❡✜♥❡ ❝♦♥❝❡♣ts✱ ❛♥❞ t❤❡② ❝❛♥ ❜❡ ❜✉✐❧t ✉♣♦♥ ♦t❤❡r ❝❧❛ss❡s✳ ❖♣❡r❛t✐♦♥s ❝❛♥ ❜❡ ❞❡✜♥❡❞ t❤❛t ✇♦r❦ ✐♥ ❛♣♣r♦♣r✐❛t❡❧② s♣❡❝✐❛❧✐③❡❞ ✇❛②s ♦♥ ❛ ❢❛♠✐❧② ♦❢ r❡❧❛t❡❞ ❝❧❛ss❡s✳ ❖❜❥❡❝ts ❛r❡ ✐♥st❛♥❝❡s ♦❢ ❝❧❛ss❡s ❛♥❞ ❤♦❧❞ t❤❡ ❞❛t❛ t❤❛t ✐s ❜❡✐♥❣ ♠❛♥✐♣✉❧❛t❡❞✳ ❚❤✐s ❝♦✉rs❡ ❞♦❡s ♥♦t ❝♦✈❡r ❙t❛♥❞❛r❞ ▼▲✬s s♦♣❤✐st✐❝❛t❡❞ ♠♦❞✉❧❡ s②st❡♠✱ ✇❤✐❝❤ ❝❛♥ ❞♦ ♠❛♥② ♦❢ t❤❡ s❛♠❡ t❤✐♥❣s ❛s ❝❧❛ss❡s✳ ❨♦✉ ✇✐❧❧ ❧❡❛r♥ ❛❧❧ ❛❜♦✉t ♦❜❥❡❝ts ✐♥ t❤❡ ❏❛✈❛ ❝♦✉rs❡✳

■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✽

Slide 107

Floating-Point, Revisited

Results are ALWAYS wrong—do we know how wrong? Von Neumann doubted whether its benefits outweighed its COSTS! Lessons:

• Innovations are often derided as luxuries for lazy people.
• Their HIDDEN COSTS can be worse than the obvious ones.
• luxuries often become necessities.

❋❧♦❛t✐♥❣✲♣♦✐♥t ✐s t❤❡ ❜❛s✐s ❢♦r ♥✉♠❡r✐❝❛❧ ❝♦♠♣✉t❛t✐♦♥✿ ✐♥❞✐s♣❡♥s❛❜❧❡ ❢♦r s❝✐❡♥❝❡ ❛♥❞ ❡♥❣✐♥❡❡r✐♥❣✳ ◆♦✇ r❡❛❞ t❤✐s ❬✹✱ ♣❛❣❡ ✾✼❪

■t ✇♦✉❧❞ t❤❡r❡❢♦r❡ s❡❡♠ t♦ ✉s ♥♦t ❛t ❛❧❧ ❝❧❡❛r ✇❤❡t❤❡r t❤❡ ♠♦❞❡st ❛❞✈❛♥t❛❣❡s ♦❢ ❛ ✢♦❛t✐♥❣ ❜✐♥❛r② ♣♦✐♥t ♦✛s❡t t❤❡ ❧♦ss ♦❢ ♠❡♠♦r② ❝❛♣❛❝✐t② ❛♥❞ t❤❡ ✐♥❝r❡❛s❡❞ ❝♦♠♣❧❡①✐t② ♦❢ t❤❡ ❛r✐t❤♠❡t✐❝ ❛♥❞ ❝♦♥tr♦❧ ❝✐r❝✉✐ts✳

❱♦♥ ◆❡✉♠❛♥♥ ✇❛s ♦♥❡ ♦❢ t❤❡ ❣r❡❛t❡st ✜❣✉r❡s ✐♥ t❤❡ ❡❛r❧② ❞❛②s ♦❢ ❝♦♠♣✉t✐♥❣✳ ❍♦✇ ❝♦✉❧❞ ❤❡ ❣❡t ✐t s♦ ✇r♦♥❣❄ ■t ❤❛♣♣❡♥s ❛❣❛✐♥ ❛♥❞ ❛❣❛✐♥✿

• ❚✐♠❡✲s❤❛r✐♥❣ ✭s✉♣♣♦rt✐♥❣ ♠✉❧t✐♣❧❡ ✐♥t❡r❛❝t✐✈❡ s❡ss✐♦♥s✱ ❛s ♦♥ t❤♦r✮ ✇❛s

❢♦r ♣❡♦♣❧❡ t♦♦ ❧❛③② t♦ q✉❡✉❡ ✉♣ ❤♦❧❞✐♥❣ ❞❡❝❦s ♦❢ ♣✉♥❝❤❡❞ ❝❛r❞s✳

• ❆✉t♦♠❛t✐❝ st♦r❛❣❡ ♠❛♥❛❣❡♠❡♥t ✭✉s✉❛❧❧② ❝❛❧❧❡❞ ❣❛r❜❛❣❡ ❝♦❧❧❡❝t✐♦♥✮ ✇❛s

❢♦r ♣❡♦♣❧❡ t♦♦ ❧❛③② t♦ ❞♦ t❤❡ ❥♦❜ t❤❡♠s❡❧✈❡s✳

• ❙❝r❡❡♥ ❡❞✐t♦rs ✇❡r❡ ❢♦r ♣❡♦♣❧❡ t♦♦ ❧❛③② t♦ ✉s❡ ❧✐♥❡✲♦r✐❡♥t❡❞ ❡❞✐t♦rs✳

❚♦ ❜❡ ❢❛✐r✱ s♦♠❡ ✐♥♥♦✈❛t✐♦♥s ❜❡❝❛♠❡ ❡st❛❜❧✐s❤❡❞ ♦♥❧② ❛❢t❡r ❤❛r❞✇❛r❡ ❛❞✈❛♥❝❡s r❡❞✉❝❡❞ t❤❡✐r ❝♦sts✳ ❋❧♦❛t✐♥❣✲♣♦✐♥t ❛r✐t❤♠❡t✐❝ ✐s ✉s❡❞✱ ❢♦r ❡①❛♠♣❧❡✱ t♦ ❞❡s✐❣♥ ❛✐r❝r❛❢t✖❜✉t ✇♦✉❧❞ ②♦✉ ✢② ✐♥ ♦♥❡❄ ❈♦❞❡ ❝❛♥ ❜❡ ❝♦rr❡❝t ❛ss✉♠✐♥❣ ❡①❛❝t ❛r✐t❤♠❡t✐❝ ❜✉t ❞❡❧✐✈❡r✱ ✉♥❞❡r ✢♦❛t✐♥❣✲♣♦✐♥t✱ ✇✐❧❞❧② ✐♥❛❝❝✉r❛t❡ r❡s✉❧ts✳ ❚❤❡ r✐s❦ ♦❢ ❡rr♦r ♦✉t✇❡✐❣❤s t❤❡ ✐♥❝r❡❛s❡❞ ❝♦♠♣❧❡①✐t② ♦❢ t❤❡ ❝✐r❝✉✐ts✿ ❛ ❤✐❞❞❡♥ ❝♦st✦ ❆s ✐t ❤❛♣♣❡♥s✱ t❤❡r❡ ❛r❡ ♠❡t❤♦❞s ❢♦r ❞❡t❡r♠✐♥✐♥❣ ❤♦✇ ❛❝❝✉r❛t❡ ♦✉r ❛♥✲ s✇❡rs ❛r❡✳ ❆ ♣r♦❢❡ss✐♦♥❛❧ ♣r♦❣r❛♠♠❡r ✇✐❧❧ ✉s❡ t❤❡♠✳

■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✾

Slide 108

Why Program in ML?

It is interactive. It has a flexible notion of data type. It hides the underlying hardware: no crashes. Programs can easily be understood mathematically. It distinguishes naming something from UPDATING MEMORY. It manages storage for us.

▼▲ ✐s t❤❡ ♦✉t❝♦♠❡ ♦❢ ②❡❛rs ♦❢ r❡s❡❛r❝❤ ✐♥t♦ ♣r♦❣r❛♠♠✐♥❣ ❧❛♥❣✉❛❣❡s✳ ■t ✐s ✉♥✐q✉❡ ❛♠♦♥❣ ❧❛♥❣✉❛❣❡s t♦ ❜❡ ❞❡✜♥❡❞ ✉s✐♥❣ ❛ ♠❛t❤❡♠❛t✐❝❛❧ ❢♦r♠❛❧✐s♠ ✭❛♥ ♦♣❡r❛t✐♦♥❛❧ s❡♠❛♥t✐❝s✮ t❤❛t ✐s ❜♦t❤ ♣r❡❝✐s❡ ❛♥❞ ❝♦♠♣r❡❤❡♥s✐❜❧❡✳ ❙❡✈❡r❛❧ ❝♦♠♠❡r❝✐❛❧❧② s✉♣♣♦rt❡❞ ❝♦♠♣✐❧❡rs ❛r❡ ❛✈❛✐❧❛❜❧❡✱ ❛♥❞ t❤❛♥❦s t♦ t❤❡ ❢♦r♠❛❧ ❞❡✜♥✐t✐♦♥✱ t❤❡r❡ ❛r❡ r❡♠❛r❦❛❜❧② ❢❡✇ ✐♥❝♦♠♣❛t✐❜✐❧✐t✐❡s ❛♠♦♥❣ t❤❡♠✳ ❇❡❝❛✉s❡ ♦❢ ✐ts ❝♦♥♥❡❝t✐♦♥ t♦ ♠❛t❤❡♠❛t✐❝s✱ ▼▲ ♣r♦❣r❛♠s ❝❛♥ ❜❡ ❞❡s✐❣♥❡❞ ❛♥❞ ✉♥❞❡rst♦♦❞ ✇✐t❤♦✉t t❤✐♥❦✐♥❣ ✐♥ ❞❡t❛✐❧ ❛❜♦✉t ❤♦✇ t❤❡ ❝♦♠♣✉t❡r ✇✐❧❧ r✉♥ t❤❡♠✳ ❆❧t❤♦✉❣❤ ❛ ♣r♦❣r❛♠ ❝❛♥ ❛❜♦rt✱ ✐t ❝❛♥♥♦t ❝r❛s❤✿ ✐t r❡♠❛✐♥s ✉♥❞❡r t❤❡ ❝♦♥tr♦❧ ♦❢ t❤❡ ▼▲ s②st❡♠✳ ■t st✐❧❧ ❛❝❤✐❡✈❡s r❡s♣❡❝t❛❜❧❡ ❡✣❝✐❡♥❝② ❛♥❞ ♣r♦✲ ✈✐❞❡s ❧♦✇❡r✲❧❡✈❡❧ ♣r✐♠✐t✐✈❡s ❢♦r t❤♦s❡ ✇❤♦ ♥❡❡❞ t❤❡♠✳ ▼♦st ♦t❤❡r ❧❛♥❣✉❛❣❡s ❛❧❧♦✇ ❞✐r❡❝t ❛❝❝❡ss t♦ t❤❡ ✉♥❞❡r❧②✐♥❣ ♠❛❝❤✐♥❡ ❛♥❞ ❡✈❡♥ tr② t♦ ❡①❡❝✉t❡ ✐❧❧❡❣❛❧ ♦♣❡r❛t✐♦♥s✱ ❝❛✉s✐♥❣ ❝r❛s❤❡s✳ ❚❤❡ ♦♥❧② ✇❛② t♦ ❧❡❛r♥ ♣r♦❣r❛♠♠✐♥❣ ✐s ❜② ✇r✐t✐♥❣ ❛♥❞ r✉♥♥✐♥❣ ♣r♦❣r❛♠s✳ ■❢ ②♦✉ ❤❛✈❡ ❛ ❝♦♠♣✉t❡r✱ ✐♥st❛❧❧ ▼▲ ♦♥ ✐t✳ ■ r❡❝♦♠♠❡♥❞ ▼♦s❝♦✇ ▼▲✱✶ ✇❤✐❝❤ r✉♥s ♦♥ P❈s✱ ▼❛❝✐♥t♦s❤❡s ❛♥❞ ❯♥✐① ❛♥❞ ✐s ❢❛st ❛♥❞ s♠❛❧❧✳ ■t ❝♦♠❡s ✇✐t❤ ❡①t❡♥s✐✈❡ ❧✐❜r❛r✐❡s ❛♥❞ s✉♣♣♦rts t❤❡ ❢✉❧❧ ❧❛♥❣✉❛❣❡ ❡①❝❡♣t ❢♦r s♦♠❡ ❛s♣❡❝ts ♦❢ ♠♦❞✉❧❡s✱ ✇❤✐❝❤ ❛r❡ ♥♦t ❝♦✈❡r❡❞ ✐♥ t❤✐s ❝♦✉rs❡✳ ▼♦s❝♦✇ ▼▲ ✐s ❛❧s♦ ❛✈❛✐❧❛❜❧❡ ✉♥❞❡r P❲❋✳ ❈❛♠❜r✐❞❣❡ ▼▲ ✐s ❛♥ ❛❧t❡r♥❛t✐✈❡✳ ■t ♣r♦✈✐❞❡s ❛ ❲✐♥❞♦✇s✲❜❛s❡❞ ✐♥t❡r❢❛❝❡ ✭❞✉❡ t♦ ❆rt❤✉r ◆♦r♠❛♥✮✱ ❜✉t t❤❡ ❝♦♠♣✐❧❡r ✐ts❡❧❢ ✐s t❤❡ ♦❧❞ ❊❞✐♥❜✉r❣❤ ▼▲✱ ✇❤✐❝❤ ✐s s❧♦✇ ❛♥❞ ❜✉❣❣②✳ ■t s✉♣♣♦rts ❛♥ ♦✉t✲♦❢✲❞❛t❡ ✈❡rs✐♦♥ ♦❢ ▼▲✿ ♠❛♥② ♦❢ t❤❡ ❡①❛♠♣❧❡s ✐♥ ♠② ❜♦♦❦ ❬✶✸❪ ✇✐❧❧ ♥♦t ✇♦r❦✳

✶❤tt♣✿✴✴✇✇✇✳❞✐♥❛✳❦✈❧✳❞❦✴⑦s❡st♦❢t✴♠♦s♠❧✳❤t♠❧

■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✵

Slide 109

The Area of a Circle: A = πr2

val pi = 3.14159; > val pi = 3.14159 : real pi * 1.5 * 1.5; > val it = 7.0685775 : real fun area (r) = pi*r*r; > val area = fn : real -> real area 2.0; > val it = 12.56636 : real

❚❤❡ ✜rst ❧✐♥❡ ♦❢ t❤✐s s✐♠♣❧❡ ▼▲ s❡ss✐♦♥ ✐s ❛ ✈❛❧✉❡ ❞❡❝❧❛r❛t✐♦♥✳ ■t ♠❛❦❡s t❤❡ ♥❛♠❡ ♣✐ st❛♥❞ ❢♦r t❤❡ r❡❛❧ ♥✉♠❜❡r ✸✳✶✹✶✺✾✳ ✭❙✉❝❤ ♥❛♠❡s ❛r❡ ❝❛❧❧❡❞ ✐❞❡♥✲ t✐✜❡rs✳✮ ▼▲ ❡❝❤♦❡s t❤❡ ♥❛♠❡ ✭♣✐✮ ❛♥❞ t②♣❡ ✭r❡❛❧✮ ♦❢ t❤❡ ❞❡❝❧❛r❡❞ ✐❞❡♥t✐✜❡r✳ ❚❤❡ s❡❝♦♥❞ ❧✐♥❡ ❝♦♠♣✉t❡s t❤❡ ❛r❡❛ ♦❢ t❤❡ ❝✐r❝❧❡ ✇✐t❤ r❛❞✐✉s ✶✳✺ ✉s✐♥❣ t❤❡ ❢♦r♠✉❧❛ A = πr2✳ ❲❡ ✉s❡ ♣✐ ❛s ❛♥ ❛❜❜r❡✈✐❛t✐♦♥ ❢♦r ✸✳✶✹✶✺✾✳ ▼✉❧t✐♣❧✐❝❛t✐♦♥ ✐s ❡①♣r❡ss❡❞ ✉s✐♥❣ ✯✱ ✇❤✐❝❤ ✐s ❝❛❧❧❡❞ ❛♥ ✐♥✜① ♦♣❡r❛t♦r ❜❡❝❛✉s❡ ✐t ✐s ✇r✐tt❡♥ ❜❡t✇❡❡♥ ✐ts t✇♦ ♦♣❡r❛♥❞s✳ ▼▲ r❡♣❧✐❡s ✇✐t❤ t❤❡ ❝♦♠♣✉t❡❞ ✈❛❧✉❡ ✭❛❜♦✉t ✼✳✵✼✮ ❛♥❞ ✐ts t②♣❡ ✭❛❣❛✐♥ r❡❛❧✮✳ ❙tr✐❝t❧② s♣❡❛❦✐♥❣✱ ✇❡ ❤❛✈❡ ❞❡❝❧❛r❡❞ t❤❡ ✐❞❡♥t✐✜❡r ✐t✱ ✇❤✐❝❤ ▼▲ ♣r♦✲ ✈✐❞❡s t♦ ❧❡t ✉s r❡❢❡r t♦ t❤❡ ✈❛❧✉❡ ♦❢ t❤❡ ❧❛st ❡①♣r❡ss✐♦♥ ❡♥t❡r❡❞ ❛t t♦♣ ❧❡✈❡❧✳ ❚♦ ✇♦r❦ ❛❜str❛❝t❧②✱ ✇❡ s❤♦✉❧❞ ♣r♦✈✐❞❡ t❤❡ s❡r✈✐❝❡ ✏❝♦♠♣✉t❡ t❤❡ ❛r❡❛ ♦❢ ❛ ❝✐r❝❧❡✱✑ s♦ t❤❛t ✇❡ ♥♦ ❧♦♥❣❡r ♥❡❡❞ t♦ r❡♠❡♠❜❡r t❤❡ ❢♦r♠✉❧❛✳ ❙♦✱ t❤❡ t❤✐r❞ ❧✐♥❡ ❞❡❝❧❛r❡s t❤❡ ❢✉♥❝t✐♦♥ ❛r❡❛✳ ●✐✈❡♥ ❛♥② r❡❛❧ ♥✉♠❜❡r r✱ ✐t r❡t✉r♥s ❛♥♦t❤❡r r❡❛❧ ♥✉♠❜❡r✱ ❝♦♠♣✉t❡❞ ✉s✐♥❣ t❤❡ ❛r❡❛ ❢♦r♠✉❧❛❀ ♥♦t❡ t❤❛t t❤❡ ❢✉♥❝t✐♦♥ ❤❛s t②♣❡ r❡❛❧✲❃r❡❛❧✳ ❚❤❡ ❢♦✉rt❤ ❧✐♥❡ ❝❛❧❧s ❢✉♥❝t✐♦♥ ❛r❡❛ s✉♣♣❧②✐♥❣ ✷✳✵ ❛s t❤❡ ❛r❣✉♠❡♥t✳ ❆ ❝✐r❝❧❡ ♦❢ r❛❞✐✉s ✷ ❤❛s ❛♥ ❛r❡❛ ♦❢ ❛❜♦✉t ✶✷✳✻✳ ◆♦t❡ t❤❛t t❤❡ ❜r❛❝❦❡ts ❛r♦✉♥❞ ❛ ❢✉♥❝t✐♦♥✬s ❛r❣✉♠❡♥t ❛r❡ ♦♣t✐♦♥❛❧✱ ❜♦t❤ ✐♥ ❞❡❝❧❛r❛t✐♦♥ ❛♥❞ ✐♥ ✉s❡✳ ❚❤❡ ❢✉♥❝t✐♦♥ ✉s❡s ♣✐ t♦ st❛♥❞ ❢♦r ✸✳✶✹✶✺✾✳ ❯♥❧✐❦❡ ✇❤❛t ②♦✉ ♠❛② ❤❛✈❡ s❡❡♥ ✐♥ ♦t❤❡r ♣r♦❣r❛♠♠✐♥❣ ❧❛♥❣✉❛❣❡s✱ ♣✐ ❝❛♥♥♦t ❜❡ ✏❛ss✐❣♥❡❞ t♦✑ ♦r ♦t❤❡r✇✐s❡ ✉♣❞❛t❡❞✳ ■ts ♠❡❛♥✐♥❣ ✇✐t❤✐♥ ❛r❡❛ ✇✐❧❧ ♣❡rs✐st ❡✈❡♥ ✐❢ ✇❡ ✐ss✉❡ ❛ ♥❡✇ ✈❛❧ ❞❡❝❧❛r❛t✐♦♥ ❢♦r ♣✐ ❛❢t❡r✇❛r❞s✳

■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✶

Slide 110

Integers; Multiple Arguments & Results

fun toSeconds (mins, secs) = secs + 60*mins; > val toSeconds = fn : int * int -> int fun fromSeconds s = (s div 60, s mod 60); > val fromSeconds = fn : int -> int * int toSeconds (5,7); > val it = 307 : int fromSeconds it; > val it = (5, 7) : int * int

• ✐✈❡♥ t❤❛t t❤❡r❡ ❛r❡ ✻✵ s❡❝♦♥❞s ✐♥ ❛ ♠✐♥✉t❡✱ ❤♦✇ ♠❛♥② s❡❝♦♥❞s ❛r❡

t❤❡r❡ ✐♥ m ♠✐♥✉t❡s ❛♥❞ s s❡❝♦♥❞s❄ ❋✉♥❝t✐♦♥ t♦❙❡❝♦♥❞s ♣❡r❢♦r♠s t❤❡ tr✐✈✐❛❧ ❝❛❧❝✉❧❛t✐♦♥✳ ■t t❛❦❡s ❛ ♣❛✐r ♦❢ ❛r❣✉♠❡♥ts✱ ❡♥❝❧♦s❡❞ ✐♥ ❜r❛❝❦❡ts✳ ❲❡ ❛r❡ ♥♦✇ ✉s✐♥❣ ✐♥t❡❣❡rs✳ ❚❤❡ ✐♥t❡❣❡r s✐①t② ✐s ✇r✐tt❡♥ ✻✵❀ t❤❡ r❡❛❧ s✐①t② ✇♦✉❧❞ ❜❡ ✇r✐tt❡♥ ✻✵✳✵✳ ❚❤❡ ♠✉❧t✐♣❧✐❝❛t✐♦♥ ♦♣❡r❛t♦r✱ ✯✱ ✐s ✉s❡❞ ❢♦r t②♣❡ ✐♥t ❛s ✇❡❧❧ ❛s r❡❛❧✿ ✐t ✐s ♦✈❡r❧♦❛❞❡❞✳ ❚❤❡ ❛❞❞✐t✐♦♥ ♦♣❡r❛t♦r✱ ✰✱ ✐s ❛❧s♦ ♦✈❡r❧♦❛❞❡❞✳ ❆s ✐♥ ♠♦st ♣r♦❣r❛♠♠✐♥❣ ❧❛♥❣✉❛❣❡s✱ ♠✉❧t✐♣❧✐❝❛t✐♦♥ ✭❛♥❞ ❞✐✈✐s✐♦♥✮ ❤❛✈❡ ♣r❡❝❡❞❡♥❝❡ ♦✈❡r ❛❞❞✐t✐♦♥ ✭❛♥❞ s✉❜tr❛❝t✐♦♥✮✿ ✇❡ ♠❛② ✇r✐t❡

s❡❝s✰✻✵✯♠✐♥s ✐♥st❡❛❞ ♦❢ s❡❝s✰✭✻✵✯♠✐♥s✮

❚❤❡ ✐♥✈❡rs❡ ♦❢ t♦❙❡❝♦♥❞s ❞❡♠♦♥str❛t❡s t❤❡ ✐♥✜① ♦♣❡r❛t♦rs ❞✐✈ ❛♥❞ ♠♦❞✱ ✇❤✐❝❤ ❡①♣r❡ss ✐♥t❡❣❡r ❞✐✈✐s✐♦♥ ❛♥❞ r❡♠❛✐♥❞❡r✳ ❋✉♥❝t✐♦♥ ❢r♦♠❙❡❝♦♥❞s r❡t✉r♥s ❛ ♣❛✐r ♦❢ r❡s✉❧ts✱ ❛❣❛✐♥ ❡♥❝❧♦s❡❞ ✐♥ ❜r❛❝❦❡ts✳ ❈❛r❡❢✉❧❧② ♦❜s❡r✈❡ t❤❡ t②♣❡s ♦❢ t❤❡ t✇♦ ❢✉♥❝t✐♦♥s✿

t♦❙❡❝♦♥❞s ✿ ✐♥t ✯ ✐♥t ✲❃ ✐♥t ❢r♦♠❙❡❝♦♥❞s ✿ ✐♥t ✲❃ ✐♥t ✯ ✐♥t

❚❤❡② t❡❧❧ ✉s t❤❛t t♦❙❡❝♦♥❞s ♠❛♣s ❛ ♣❛✐r ♦❢ ✐♥t❡❣❡rs t♦ ❛♥ ✐♥t❡❣❡r✱ ✇❤✐❧❡ ❢r♦♠❙❡❝♦♥❞s ♠❛♣s ❛♥ ✐♥t❡❣❡r t♦ ❛ ♣❛✐r ♦❢ ✐♥t❡❣❡rs✳ ■♥ ❛ s✐♠✐❧❛r ❢❛s❤✐♦♥✱ ❛♥ ▼▲ ❢✉♥❝t✐♦♥ ♠❛② t❛❦❡ ❛♥② ♥✉♠❜❡r ♦❢ ❛r❣✉♠❡♥ts ❛♥❞ r❡t✉r♥ ❛♥② ♥✉♠❜❡r ♦❢ r❡s✉❧ts✱ ♣♦ss✐❜❧② ♦❢ ❞✐✛❡r❡♥t t②♣❡s✳

■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✷

Slide 111

Summary of ML’s numeric types int: the integers

• constants

1 ~1 2 ~2 0032 . . .

• infixes

+

• *

div mod real: the floating-point numbers

• constants

0.0 ~1.414 3.94e~7 . . .

• infixes

+

• *

/

• functions

Math.sqrt Math.sin Math.ln . . . ❚❤❡ ✉♥❞❡r❧✐♥❡❞ s②♠❜♦❧s ✈❛❧ ❛♥❞ ❢✉♥ ❛r❡ ❦❡②✇♦r❞s✿ t❤❡② ♠❛② ♥♦t ❜❡ ✉s❡❞ ❛s ✐❞❡♥t✐✜❡rs✳ ❍❡r❡ ✐s ❛ ❝♦♠♣❧❡t❡ ❧✐st ♦❢ ▼▲✬s ❦❡②✇♦r❞s✳

❛❜st②♣❡ ❛♥❞ ❛♥❞❛❧s♦ ❛s ❝❛s❡ ❞❛t❛t②♣❡ ❞♦ ❡❧s❡ ❡♥❞ ❡qt②♣❡ ❡①❝❡♣t✐♦♥ ❢♥ ❢✉♥ ❢✉♥❝t♦r ❤❛♥❞❧❡ ✐❢ ✐♥ ✐♥❝❧✉❞❡ ✐♥❢✐① ✐♥❢✐①r ❧❡t ❧♦❝❛❧ ♥♦♥❢✐① ♦❢ ♦♣ ♦♣❡♥ ♦r❡❧s❡ r❛✐s❡ r❡❝ s❤❛r✐♥❣ s✐❣ s✐❣♥❛t✉r❡ str✉❝t str✉❝t✉r❡ t❤❡♥ t②♣❡ ✈❛❧ ✇❤❡r❡ ✇❤✐❧❡ ✇✐t❤ ✇✐t❤t②♣❡

❚❤❡ ♥❡❣❛t✐♦♥ ♦❢ ① ✐s ✇r✐tt❡♥ ⑦① r❛t❤❡r t❤❛♥ ✲①✱ ♣❧❡❛s❡ ♥♦t❡✳ ▼♦st ❧❛♥✲ ❣✉❛❣❡s ✉s❡ t❤❡ s❛♠❡ s②♠❜♦❧ ❢♦r ♠✐♥✉s ❛♥❞ s✉❜tr❛❝t✐♦♥✱ ❜✉t ▼▲ r❡❣❛r❞s ❛❧❧ ♦♣❡r❛t♦rs✱ ✇❤❡t❤❡r ✐♥✜① ♦r ♥♦t✱ ❛s ❢✉♥❝t✐♦♥s✳ ❙✉❜tr❛❝t✐♦♥ t❛❦❡s ❛ ♣❛✐r ♦❢ ♥✉♠❜❡rs✱ ❜✉t ♠✐♥✉s t❛❦❡s ❛ s✐♥❣❧❡ ♥✉♠❜❡r❀ t❤❡② ❛r❡ ❞✐st✐♥❝t ❢✉♥❝t✐♦♥s ❛♥❞ ♠✉st ❤❛✈❡ ❞✐st✐♥❝t ♥❛♠❡s✳ ❙✐♠✐❧❛r❧②✱ ✇❡ ♠❛② ♥♦t ✇r✐t❡ ✰①✳ ❈♦♠♣✉t❡r ♥✉♠❜❡rs ❤❛✈❡ ❛ ✜♥✐t❡ r❛♥❣❡✱ ✇❤✐❝❤ ✐❢ ❡①❝❡❡❞❡❞ ❣✐✈❡s r✐s❡ t♦ ❛♥ ❖✈❡r✢♦✇ ❡rr♦r✳ ❙♦♠❡ ▼▲ s②st❡♠s ❝❛♥ r❡♣r❡s❡♥t ✐♥t❡❣❡rs ♦❢ ❛r❜✐tr❛r② s✐③❡✳ ■❢ ✐♥t❡❣❡rs ❛♥❞ r❡❛❧s ♠✉st ❜❡ ❝♦♠❜✐♥❡❞ ✐♥ ❛ ❝❛❧❝✉❧❛t✐♦♥✱ ▼▲ ♣r♦✈✐❞❡s ❢✉♥❝t✐♦♥s t♦ ❝♦♥✈❡rt ❜❡t✇❡❡♥ t❤❡♠✿

r❡❛❧ ✿ ✐♥t ✲❃ r❡❛❧ ❝♦♥✈❡rt ❛♥ ✐♥t❡❣❡r t♦ t❤❡ ❝♦rr❡s♣♦♥❞✐♥❣ r❡❛❧ ❢❧♦♦r ✿ r❡❛❧ ✲❃ ✐♥t ❝♦♥✈❡rt ❛ r❡❛❧ t♦ t❤❡ ❣r❡❛t❡st ✐♥t❡❣❡r ♥♦t ❡①❝❡❡❞✐♥❣ ✐t

▼▲✬s ❧✐❜r❛r✐❡s ❛r❡ ♦r❣❛♥✐③❡❞ ✉s✐♥❣ ♠♦❞✉❧❡s✱ s♦ ✇❡ ✉s❡ ❝♦♠♣♦✉♥❞ ✐❞❡♥t✐✲ ✜❡rs s✉❝❤ ❛s ▼❛t❤✳sqrt t♦ r❡❢❡r t♦ ❧✐❜r❛r② ❢✉♥❝t✐♦♥s✳ ■♥ ▼♦s❝♦✇ ▼▲✱ ❧✐❜r❛r② ✉♥✐ts ❛r❡ ❧♦❛❞❡❞ ❜② ❝♦♠♠❛♥❞s s✉❝❤ ❛s ❧♦❛❞✧▼❛t❤✧❀✳ ❚❤❡r❡ ❛r❡ t❤♦✉s❛♥❞s ♦❢ ❧✐❜r❛r② ❢✉♥❝t✐♦♥s✱ ✐♥❝❧✉❞✐♥❣ t❡①t✲♣r♦❝❡ss✐♥❣ ❛♥❞ ♦♣❡r❛t✐♥❣ s②st❡♠s ❢✉♥❝t✐♦♥s ✐♥ ❛❞❞✐t✐♦♥ t♦ t❤❡ ✉s✉❛❧ ♥✉♠❡r✐❝❛❧ ♦♥❡s✳

■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✸ ❋♦r ♠♦r❡ ❞❡t❛✐❧s ♦♥ ▼▲✬s s②♥t❛①✱ ♣❧❡❛s❡ ❝♦♥s✉❧t ❛ t❡①t❜♦♦❦✳ ▼✐♥❡ ❬✶✸❪ ❛♥❞ ❲✐❦strö♠✬s ❬✶✻❪ ♠❛② ❜❡ ❢♦✉♥❞ ✐♥ ♠❛♥② ❈♦❧❧❡❣❡ ❧✐❜r❛r✐❡s✳ ❯❧❧♠❛♥ ❬✶✺❪✱ ✐♥ t❤❡ ❈♦♠♣✉t❡r ▲❛❜ ❧✐❜r❛r②✱ ✐s ❛❧s♦ ✇♦rt❤ ❛ ❧♦♦❦✳ ▲❡❛r♥✐♥❣ ❣✉✐❞❡✳ ❘❡❧❛t❡❞ ♠❛t❡r✐❛❧ ✐s ✐♥ ▼▲ ❢♦r t❤❡ ❲♦r❦✐♥❣ Pr♦❣r❛♠♠❡r✱ ♣❛❣❡s ✶✕✹✼✱ ❛♥❞ ❡s♣❡❝✐❛❧❧② ✶✼✕✸✷✳ ❊①❡r❝✐s❡ ✶✳✶ ❖♥❡ s♦❧✉t✐♦♥ t♦ t❤❡ ②❡❛r ✷✵✵✵ ❜✉❣ ✐♥✈♦❧✈❡s st♦r✐♥❣ ②❡❛rs ❛s t✇♦ ❞✐❣✐ts✱ ❜✉t ✐♥t❡r♣r❡t✐♥❣ t❤❡♠ s✉❝❤ t❤❛t ✺✵ ♠❡❛♥s ✶✾✺✵ ❛♥❞ ✹✾ ♠❡❛♥s ✷✵✹✾✳ ❈♦♠♠❡♥t ♦♥ t❤❡ ♠❡r✐ts ❛♥❞ ❞❡♠❡r✐ts ♦❢ t❤✐s ❛♣♣r♦❛❝❤✳ ❊①❡r❝✐s❡ ✶✳✷ ❯s✐♥❣ t❤❡ ❞❛t❡ r❡♣r❡s❡♥t❛t✐♦♥ ♦❢ t❤❡ ♣r❡✈✐♦✉s ❡①❡r❝✐s❡✱ ❝♦❞❡ ▼▲ ❢✉♥❝t✐♦♥s t♦ ✭❛✮ ❝♦♠♣❛r❡ t✇♦ ②❡❛rs ✭❜✮ ❛❞❞✴s✉❜tr❛❝t s♦♠❡ ❣✐✈❡♥ ♥✉♠❜❡r ♦❢ ②❡❛rs ❢r♦♠ ❛♥♦t❤❡r ②❡❛r✳ ✭❨♦✉ ♠❛② ♥❡❡❞ t♦ ❧♦♦❦ ❛❤❡❛❞ t♦ t❤❡ ♥❡①t ❧❡❝t✉r❡ ❢♦r ▼▲✬s ❝♦♠♣❛r✐s♦♥ ♦♣❡r❛t♦rs✳✮

■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✹

Slide 201

Raising a Number to a Power

fun npower(x,n) : real = if n=0 then 1.0 else x * npower(x, n-1); > val npower = fn : real * int -> real

Mathematical Justification (for x = 0):

x0 = 1 xn+1 = x × xn. ❚❤❡ ❢✉♥❝t✐♦♥ ♥♣♦✇❡r r❛✐s❡s ✐ts r❡❛❧ ❛r❣✉♠❡♥t ① t♦ t❤❡ ♣♦✇❡r ♥✱ ❛ ♥♦♥✲ ♥❡❣❛t✐✈❡ ✐♥t❡❣❡r✳ ❚❤❡ ❢✉♥❝t✐♦♥ ✐s r❡❝✉rs✐✈❡✿ ✐t ❝❛❧❧s ✐ts❡❧❢✳ ❚❤✐s ❝♦♥❝❡♣t s❤♦✉❧❞ ❜❡ ❢❛♠✐❧✐❛r ❢r♦♠ ♠❛t❤❡♠❛t✐❝s✱ s✐♥❝❡ ❡①♣♦♥❡♥t✐❛t✐♦♥ ✐s ❞❡✜♥❡❞ ❜② t❤❡ r✉❧❡s s❤♦✇♥ ❛❜♦✈❡✳ ❚❤❡ ▼▲ ♣r♦❣r❛♠♠❡r ✉s❡s r❡❝✉rs✐♦♥ ❤❡❛✈✐❧②✳ ❋♦r n ≥ 0✱ t❤❡ ❡q✉❛t✐♦♥ xn+1 = x × xn ②✐❡❧❞s ❛♥ ♦❜✈✐♦✉s ❝♦♠♣✉t❛t✐♦♥✿ x3 = x × x2 = x × x × x1 = x × x × x × x0 = x × x × x. ❚❤❡ ❡q✉❛t✐♦♥ ❝❧❡❛r❧② ❤♦❧❞s ❡✈❡♥ ❢♦r ♥❡❣❛t✐✈❡ n✳ ❍♦✇❡✈❡r✱ t❤❡ ❝♦rr❡s♣♦♥❞✐♥❣ ❝♦♠♣✉t❛t✐♦♥ r✉♥s ❢♦r❡✈❡r✿ x−1 = x × x−2 = x × x × x−3 = · · · ◆♦✇ ❢♦r ❛ t✐r❡s♦♠❡ ❜✉t ♥❡❝❡ss❛r② ❛s✐❞❡✳ ■♥ ♠♦st ❧❛♥❣✉❛❣❡s✱ t❤❡ t②♣❡s ♦❢ ❛r❣✉♠❡♥ts ❛♥❞ r❡s✉❧ts ♠✉st ❛❧✇❛②s ❜❡ s♣❡❝✐✜❡❞✳ ▼▲ ✐s ✉♥✉s✉❛❧ ✐♥ ♣r♦✈✐❞✐♥❣ t②♣❡ ✐♥❢❡r❡♥❝❡✿ ✐t ♥♦r♠❛❧❧② ✇♦r❦s ♦✉t t❤❡ t②♣❡s ❢♦r ✐ts❡❧❢✳ ❍♦✇❡✈❡r✱ s♦♠❡t✐♠❡s ▼▲ ♥❡❡❞s ❛ ❤✐♥t❀ ❢✉♥❝t✐♦♥ ♥♣♦✇❡r ❤❛s ❛ t②♣❡ ❝♦♥str❛✐♥t t♦ s❛② ✐ts r❡s✉❧t ✐s r❡❛❧✳ ❙✉❝❤ ❝♦♥str❛✐♥ts ❛r❡ r❡q✉✐r❡❞ ✇❤❡♥ ♦✈❡r❧♦❛❞✐♥❣ ✇♦✉❧❞ ♦t❤❡r✇✐s❡ ♠❛❦❡ ❛ ❢✉♥❝t✐♦♥✬s t②♣❡ ❛♠❜✐❣✉♦✉s✳ ▼▲ ❝❤♦♦s❡s t②♣❡ ✐♥t ❜② ❞❡❢❛✉❧t ♦r✱ ✐♥ ❡❛r❧✐❡r ✈❡rs✐♦♥s✱ ♣r✐♥ts ❛♥ ❡rr♦r ♠❡ss❛❣❡✳ ❉❡s♣✐t❡ t❤❡ ❜❡st ❡✛♦rts ♦❢ ❧❛♥❣✉❛❣❡ ❞❡s✐❣♥❡rs✱ ❛❧❧ ♣r♦❣r❛♠♠✐♥❣ ❧❛♥❣✉❛❣❡s ❤❛✈❡ tr♦✉❜❧❡ ♣♦✐♥ts s✉❝❤ ❛s t❤❡s❡✳ ❚②♣✐❝❛❧❧②✱ t❤❡② ❛r❡ ❝♦♠♣r♦♠✐s❡s ❝❛✉s❡❞ ❜② tr②✐♥❣ t♦ ❣❡t t❤❡ ❜❡st ♦❢ ❜♦t❤ ✇♦r❧❞s✱ ❤❡r❡ t②♣❡ ✐♥❢❡r❡♥❝❡ ❛♥❞ ♦✈❡r❧♦❛❞✐♥❣✳

■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✺

Slide 202

An Aside: Overloading

Functions defined for both int and real:

• operators

~ + - *

• relations

< <= > >=

The type checker requires help! — a type constraint

fun square (x) = x * x;

AMBIGUOUS

fun square (x:real) = x * x;

Clear

◆❡❛r❧② ❛❧❧ ♣r♦❣r❛♠♠✐♥❣ ❧❛♥❣✉❛❣❡s ♦✈❡r❧♦❛❞ t❤❡ ❛r✐t❤♠❡t✐❝ ♦♣❡r❛t♦rs✳ ❲❡ ❞♦♥✬t ✇❛♥t t♦ ❤❛✈❡ ❞✐✛❡r❡♥t ♦♣❡r❛t♦rs ❢♦r ❡❛❝❤ t②♣❡ ♦❢ ♥✉♠❜❡r✦ ❙♦♠❡ ❧❛♥✲ ❣✉❛❣❡s ❤❛✈❡ ❥✉st ♦♥❡ t②♣❡ ♦❢ ♥✉♠❜❡r✱ ❝♦♥✈❡rt✐♥❣ ❛✉t♦♠❛t✐❝❛❧❧② ❜❡t✇❡❡♥ ❞✐❢✲ ❢❡r❡♥t ❢♦r♠❛ts❀ t❤✐s ✐s s❧♦✇ ❛♥❞ ❝♦✉❧❞ ❧❡❛❞ t♦ ✉♥❡①♣❡❝t❡❞ r♦✉♥❞✐♥❣ ❡rr♦rs✳ ❚②♣❡ ❝♦♥str❛✐♥ts ❛r❡ ❛❧❧♦✇❡❞ ❛❧♠♦st ❛♥②✇❤❡r❡✳ ❲❡ ❝❛♥ ♣✉t ♦♥❡ ♦♥ ❛♥② ♦❝❝✉rr❡♥❝❡ ♦❢ ① ✐♥ t❤❡ ❢✉♥❝t✐♦♥✳ ❲❡ ❝❛♥ ❝♦♥str❛✐♥ t❤❡ ❢✉♥❝t✐♦♥✬s r❡s✉❧t✿

❢✉♥ sq✉❛r❡ ① ❂ ① ✯ ① ✿ r❡❛❧❀ ❢✉♥ sq✉❛r❡ ① ✿ r❡❛❧ ❂ ① ✯ ①❀

▼▲ tr❡❛ts t❤❡ ❡q✉❛❧✐t② t❡st s♣❡❝✐❛❧❧②✳ ❊①♣r❡ss✐♦♥s ❧✐❦❡

✐❢ ①❂② t❤❡♥ ✳✳✳

❛r❡ ✜♥❡ ♣r♦✈✐❞❡❞ x ❛♥❞ y ❤❛✈❡ t❤❡ s❛♠❡ t②♣❡ ❛♥❞ ❡q✉❛❧✐t② t❡st✐♥❣ ✐s ♣♦ss✐❜❧❡ ❢♦r t❤❛t t②♣❡✳✶ ◆♦t❡ t❤❛t ① ❁❃ ② ✐s ▼▲ ❢♦r x = y✳

✶❆❧❧ t❤❡ t②♣❡s t❤❛t ✇❡ s❤❛❧❧ s❡❡ ❢♦r s♦♠❡ t✐♠❡ ❛❞♠✐t ❡q✉❛❧✐t② t❡st✐♥❣✳ ▼♦s❝♦✇ ▼▲

❛❧❧♦✇s ❡✈❡♥ ❡q✉❛❧✐t② t❡st✐♥❣ ♦❢ r❡❛❧s✱ ✇❤✐❝❤ ✐s ❢♦r❜✐❞❞❡♥ ✐♥ t❤❡ ❧❛t❡st ✈❡rs✐♦♥ ♦❢ t❤❡ ▼▲ ❧✐❜r❛r②✳ ❙♦♠❡ ❝♦♠♣✐❧❡rs ♠❛② ✐♥s✐st t❤❛t ②♦✉ ✇r✐t❡ ❘❡❛❧✳❂❂✭①✱②✮✳

■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✻

Slide 203

Conditional Expressions and Type bool if b then x else y not(b)

negation of b

p andalso q ≡ if p then q else false p orelse q ≡ if p then true else q

A Boolean-valued function!

fun even n = (n mod 2 = 0); > val even = fn : int -> bool

❆ ❝❤❛r❛❝t❡r✐st✐❝ ❢❡❛t✉r❡ ♦❢ t❤❡ ❝♦♠♣✉t❡r ✐s ✐ts ❛❜✐❧✐t② t♦ t❡st ❢♦r ❝♦♥❞✐✲ t✐♦♥s ❛♥❞ ❛❝t ❛❝❝♦r❞✐♥❣❧②✳ ■♥ t❤❡ ❡❛r❧② ❞❛②s✱ ❛ ♣r♦❣r❛♠ ♠✐❣❤t ❥✉♠♣ t♦ ❛ ❣✐✈❡♥ ❛❞❞r❡ss ❞❡♣❡♥❞✐♥❣ ♦♥ t❤❡ s✐❣♥ ♦❢ s♦♠❡ ♥✉♠❜❡r✳ ▲❛t❡r✱ ❏♦❤♥ ▼❝❈❛rt❤② ❞❡✜♥❡❞ t❤❡ ❝♦♥❞✐t✐♦♥❛❧ ❡①♣r❡ss✐♦♥ t♦ s❛t✐s❢② (✐❢ tr✉❡ t❤❡♥ x ❡❧s❡ y) = x (✐❢ ❢❛❧s❡ t❤❡♥ x ❡❧s❡ y) = y ▼▲ ❡✈❛❧✉❛t❡s t❤❡ ❡①♣r❡ss✐♦♥ ✐❢ B t❤❡♥ E1 ❡❧s❡ E2 ❜② ✜rst ❡✈❛❧✉❛t✐♥❣ B✳ ■❢ t❤❡ r❡s✉❧t ✐s tr✉❡ t❤❡♥ ▼▲ ❡✈❛❧✉❛t❡s E1 ❛♥❞ ♦t❤❡r✇✐s❡ E2✳ ❖♥❧② ♦♥❡ ♦❢ t❤❡ t✇♦ ❡①♣r❡ss✐♦♥s E1 ❛♥❞ E2 ✐s ❡✈❛❧✉❛t❡❞✦ ■❢ ❜♦t❤ ✇❡r❡ ❡✈❛❧✉❛t❡❞✱ t❤❡♥ r❡❝✉rs✐✈❡ ❢✉♥❝t✐♦♥s ❧✐❦❡ ♥♣♦✇❡r ❛❜♦✈❡ ✇♦✉❧❞ r✉♥ ❢♦r❡✈❡r✳ ❚❤❡ ✐❢✲❡①♣r❡ss✐♦♥ ✐s ❣♦✈❡r♥❡❞ ❜② ❛♥ ❡①♣r❡ss✐♦♥ ♦❢ t②♣❡ ❜♦♦❧✱ ✇❤♦s❡ t✇♦ ✈❛❧✉❡s ❛r❡ tr✉❡ ❛♥❞ ❢❛❧s❡✳ ■♥ ♠♦❞❡r♥ ♣r♦❣r❛♠♠✐♥❣ ❧❛♥❣✉❛❣❡s✱ t❡sts ❛r❡ ♥♦t ❜✉✐❧t ✐♥t♦ ✏❝♦♥❞✐t✐♦♥❛❧ ❜r❛♥❝❤✑ ❝♦♥str✉❝ts ❜✉t ❤❛✈❡ ❛♥ ✐♥❞❡♣❡♥❞❡♥t st❛t✉s✳ ❚❡sts✱ ♦r ❇♦♦❧❡❛♥ ❡①♣r❡ss✐♦♥s✱ ❝❛♥ ❜❡ ❡①♣r❡ss❡❞ ✉s✐♥❣ r❡❧❛t✐♦♥❛❧ ♦♣❡r❛✲ t♦rs s✉❝❤ ❛s < ❛♥❞ =✳ ❚❤❡② ❝❛♥ ❜❡ ❝♦♠❜✐♥❡❞ ✉s✐♥❣ t❤❡ ❇♦♦❧❡❛♥ ♦♣❡r❛t♦rs ❢♦r ♥❡❣❛t✐♦♥ ✭♥♦t✮✱ ❝♦♥❥✉♥❝t✐♦♥ ✭❛♥❞❛❧s♦✮ ❛♥❞ ❞✐s❥✉♥❝t✐♦♥ ✭♦r❡❧s❡✮✳ ◆❡✇ ♣r♦♣❡rt✐❡s ❝❛♥ ❜❡ ❞❡❝❧❛r❡❞ ❛s ❢✉♥❝t✐♦♥s✱ ❡✳❣✳ t♦ t❡st ✇❤❡t❤❡r ❛♥ ✐♥t❡❣❡r ✐s ❡✈❡♥✳ ◆♦t❡✳ ❚❤❡ ❛♥❞❛❧s♦ ❛♥❞ ♦r❡❧s❡ ♦♣❡r❛t♦rs ❡✈❛❧✉❛t❡ t❤❡✐r s❡❝♦♥❞ ♦♣❡r❛♥❞ ♦♥❧② ✐❢ ♥❡❝❡ss❛r②✳ ❚❤❡② ❝❛♥♥♦t ❜❡ ❞❡✜♥❡❞ ❛s ❢✉♥❝t✐♦♥s✿ ▼▲ ❢✉♥❝t✐♦♥s ❡✈❛❧✉✲ ❛t❡ ❛❧❧ t❤❡✐r ❛r❣✉♠❡♥ts✳ ✭■♥ ▼▲✱ ❛♥② t✇♦✲❛r❣✉♠❡♥t ❢✉♥❝t✐♦♥ ❝❛♥ ❜❡ t✉r♥❡❞ ✐♥t♦ ❛♥ ✐♥✜① ♦♣❡r❛t♦r✳✮

■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✼

Slide 204

Raising a Number to a Power, Revisited

fun power(x,n) : real = if n=1 then x else if even n then power(x*x, n div 2) else x * power(x*x, n div 2)

Mathematical Justification:

x1 = x x2n = (x2)n x2n+1 = x × (x2)n. ❋♦r ❧❛r❣❡ n✱ ❝♦♠♣✉t✐♥❣ ♣♦✇❡rs ✉s✐♥❣ xn+1 = x × xn ✐s t♦♦ s❧♦✇ t♦ ❜❡ ♣r❛❝t✐❝❛❧✳ ❚❤❡ ❡q✉❛t✐♦♥s ❛❜♦✈❡ ❛r❡ ♠✉❝❤ ❢❛st❡r✿ 212 = 46 = 163 = 16 × 2561 = 16 × 256 = 4096. ■♥st❡❛❞ ♦❢ n ♠✉❧t✐♣❧✐❝❛t✐♦♥s✱ ✇❡ ♥❡❡❞ ❛t ♠♦st 2 lg n ♠✉❧t✐♣❧✐❝❛t✐♦♥s✱ ✇❤❡r❡ lg n ✐s t❤❡ ❧♦❣❛r✐t❤♠ ♦❢ n t♦ t❤❡ ❜❛s❡ ✷✳ ❲❡ ✉s❡ t❤❡ ❢✉♥❝t✐♦♥ ❡✈❡♥✱ ❞❡❝❧❛r❡❞ ♣r❡✈✐♦✉s❧②✱ t♦ t❡st ✇❤❡t❤❡r t❤❡ ❡①♣♦✲ ♥❡♥t ✐s ❡✈❡♥✳ ■♥t❡❣❡r ❞✐✈✐s✐♦♥ ✭❞✐✈✮ tr✉♥❝❛t❡s ✐ts r❡s✉❧t t♦ ❛♥ ✐♥t❡❣❡r✿ ❞✐✈✐❞✐♥❣ 2n + 1 ❜② ✷ ②✐❡❧❞s n✳ ❆ r❡❝✉rr❡♥❝❡ ✐s ❛ ✉s❡❢✉❧ ❝♦♠♣✉t❛t✐♦♥ r✉❧❡ ♦♥❧② ✐❢ ✐t ✐s ❜♦✉♥❞ t♦ t❡r♠✐♥❛t❡✳ ■❢ n > 0 t❤❡♥ n ✐s s♠❛❧❧❡r t❤❛♥ ❜♦t❤ 2n ❛♥❞ 2n + 1✳ ❆❢t❡r ❡♥♦✉❣❤ r❡❝✉rs✐✈❡ ❝❛❧❧s✱ t❤❡ ❡①♣♦♥❡♥t ✇✐❧❧ ❜❡ r❡❞✉❝❡❞ t♦ ✶✳ ❚❤❡ ❡q✉❛t✐♦♥s ❛❧s♦ ❤♦❧❞ ✐❢ n ≤ 0✱ ❜✉t t❤❡ ❝♦rr❡s♣♦♥❞✐♥❣ ❝♦♠♣✉t❛t✐♦♥ r✉♥s ❢♦r❡✈❡r✳ ❖✉r r❡❛s♦♥✐♥❣ ❛ss✉♠❡s ❛r✐t❤♠❡t✐❝ t♦ ❜❡ ❡①❛❝t❀ ❢♦rt✉♥❛t❡❧②✱ t❤❡ ❝❛❧❝✉❧❛t✐♦♥ ✐s ✇❡❧❧✲❜❡❤❛✈❡❞ ✉s✐♥❣ ✢♦❛t✐♥❣✲♣♦✐♥t✳

■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✽

Slide 205

Expression Evaluation E0 ⇒ E1 ⇒ · · · ⇒ En ⇒ v

Sample evaluation for power:

power(2, 12) ⇒ power(4, 6) ⇒ power(16, 3) ⇒ 16 × power(256, 1) ⇒ 16 × 256 ⇒ 4096. ❙t❛rt✐♥❣ ✇✐t❤ E0✱ t❤❡ ❡①♣r❡ss✐♦♥ Ei ✐s r❡❞✉❝❡❞ t♦ Ei+1 ✉♥t✐❧ t❤✐s ♣r♦❝❡ss ❝♦♥❝❧✉❞❡s ✇✐t❤ ❛ ✈❛❧✉❡ v✳ ❆ ✈❛❧✉❡ ✐s s♦♠❡t❤✐♥❣ ❧✐❦❡ ❛ ♥✉♠❜❡r t❤❛t ❝❛♥♥♦t ❜❡ ❢✉rt❤❡r r❡❞✉❝❡❞✳ ❲❡ ✇r✐t❡ E ⇒ E′ t♦ s❛② t❤❛t E ✐s r❡❞✉❝❡❞ t♦ E′✳ ▼❛t❤❡♠❛t✐❝❛❧❧②✱ t❤❡② ❛r❡ ❡q✉❛❧✿ E = E′✱ ❜✉t t❤❡ ❝♦♠♣✉t❛t✐♦♥ ❣♦❡s ❢r♦♠ E t♦ E′ ❛♥❞ ♥❡✈❡r t❤❡ ♦t❤❡r ✇❛② ❛r♦✉♥❞✳ ❊✈❛❧✉❛t✐♦♥ ❝♦♥❝❡r♥s ♦♥❧② ❡①♣r❡ss✐♦♥s ❛♥❞ t❤❡ ✈❛❧✉❡s t❤❡② r❡t✉r♥✳ ❚❤✐s ✈✐❡✇ ♦❢ ❝♦♠♣✉t❛t✐♦♥ ♠❛② s❡❡♠ t♦ ❜❡ t♦♦ ♥❛rr♦✇✳ ■t ✐s ❝❡rt❛✐♥❧② ❢❛r r❡♠♦✈❡❞ ❢r♦♠ ❝♦♠♣✉t❡r ❤❛r❞✇❛r❡✱ ❜✉t t❤❛t ❝❛♥ ❜❡ s❡❡♥ ❛s ❛♥ ❛❞✈❛♥t❛❣❡✳ ❋♦r t❤❡ tr❛❞✐t✐♦♥❛❧ ❝♦♥❝❡♣t ♦❢ ❝♦♠♣✉t✐♥❣ s♦❧✉t✐♦♥s t♦ ♣r♦❜❧❡♠s✱ ❡①♣r❡ss✐♦♥ ❡✈❛❧✉❛t✐♦♥ ✐s ❡♥t✐r❡❧② ❛❞❡q✉❛t❡✳ ❈♦♠♣✉t❡rs ❛❧s♦ ✐♥t❡r❛❝t ✇✐t❤ t❤❡ ♦✉ts✐❞❡ ✇♦r❧❞✳ ❋♦r ❛ st❛rt✱ t❤❡② ♥❡❡❞ s♦♠❡ ♠❡❛♥s ♦❢ ❛❝❝❡♣t✐♥❣ ♣r♦❜❧❡♠s ❛♥❞ ❞❡❧✐✈❡r✐♥❣ s♦❧✉t✐♦♥s✳ ▼❛♥② ❝♦♠♣✉t❡r s②st❡♠s ♠♦♥✐t♦r ❛♥❞ ❝♦♥tr♦❧ ✐♥❞✉str✐❛❧ ♣r♦❝❡ss❡s✳ ❚❤✐s r♦❧❡ ♦❢ ❝♦♠♣✉t❡rs ✐s ❢❛♠✐❧✐❛r ♥♦✇✱ ❜✉t ✇❛s ♥❡✈❡r ❡♥✈✐s❛❣❡❞ ❛t ✜rst✳ ▼♦❞❡❧❧✐♥❣ ✐t r❡q✉✐r❡s ❛ ♥♦t✐♦♥ ♦❢ st❛t❡s t❤❛t ❝❛♥ ❜❡ ♦❜s❡r✈❡❞ ❛♥❞ ❝❤❛♥❣❡❞✳ ❚❤❡♥ ✇❡ ❝❛♥ ❝♦♥s✐❞❡r ✉♣❞❛t✐♥❣ t❤❡ st❛t❡ ❜② ❛ss✐❣♥✐♥❣ t♦ ✈❛r✐❛❜❧❡s ♦r ♣❡r❢♦r♠✐♥❣ ✐♥♣✉t✴♦✉t♣✉t✱ ✜♥❛❧❧② ❛rr✐✈✐♥❣ ❛t ❝♦♥✈❡♥t✐♦♥❛❧ ♣r♦❣r❛♠s ✭❢❛♠✐❧✐❛r t♦ t❤♦s❡ ♦❢ ②♦✉ ✇❤♦ ❦♥♦✇ ❈✱ ❢♦r ✐♥st❛♥❝❡✮ t❤❛t ❝♦♥s✐st ♦❢ ❝♦♠♠❛♥❞s✳ ❋♦r ♥♦✇✱ ✇❡ r❡♠❛✐♥ ❛t t❤❡ ❧❡✈❡❧ ♦❢ ❡①♣r❡ss✐♦♥s✱ ✇❤✐❝❤ ✐s ✉s✉❛❧❧② t❡r♠❡❞ ❢✉♥❝t✐♦♥❛❧ ♣r♦❣r❛♠♠✐♥❣✳

■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✾

Slide 206

Example: Summing the First n Integers

fun nsum n = if n=0 then 0 else n + nsum (n-1); > val nsum = fn: int -> int

nsum 3 ⇒3 + nsum 2 ⇒3 + (2 + nsum 1) ⇒3 + (2 + (1 + nsum 0)) ⇒3 + (2 + (1 + 0)) ⇒ . . . ⇒ 6 ❚❤❡ ❢✉♥❝t✐♦♥ ❝❛❧❧ nsum n ❝♦♠♣✉t❡s t❤❡ s✉♠ 1 + · · · + n r❛t❤❡r ♥❛ï✈❡❧②✱ ❤❡♥❝❡ t❤❡ ✐♥✐t✐❛❧ ♥ ✐♥ ✐ts ♥❛♠❡✳ ❚❤❡ ♥❡st✐♥❣ ♦❢ ♣❛r❡♥t❤❡s❡s ✐s ♥♦t ❥✉st ❛♥ ❛rt✐❢❛❝t ♦❢ ♦✉r ♥♦t❛t✐♦♥❀ ✐t ✐♥❞✐❝❛t❡s ❛ r❡❛❧ ♣r♦❜❧❡♠✳ ❚❤❡ ❢✉♥❝t✐♦♥ ❣❛t❤❡rs ✉♣ ❛ ❝♦❧❧❡❝t✐♦♥ ♦❢ ♥✉♠❜❡rs✱ ❜✉t ♥♦♥❡ ♦❢ t❤❡ ❛❞❞✐t✐♦♥s ❝❛♥ ❜❡ ♣❡r❢♦r♠❡❞ ✉♥t✐❧ nsum 0 ✐s r❡❛❝❤❡❞✳ ▼❡❛♥✇❤✐❧❡✱ t❤❡ ❝♦♠♣✉t❡r ♠✉st st♦r❡ t❤❡ ♥✉♠❜❡rs ✐♥ ❛♥ ✐♥t❡r♥❛❧ ❞❛t❛ str✉❝t✉r❡✱ t②♣✐❝❛❧❧② t❤❡ st❛❝❦✳ ❋♦r ❧❛r❣❡ n✱ s❛② nsum 10000✱ t❤❡ ❝♦♠♣✉t❛t✐♦♥ ♠✐❣❤t ❢❛✐❧ ❞✉❡ t♦ st❛❝❦ ♦✈❡r✢♦✇✳ ❲❡ ❛❧❧ ❦♥♦✇ t❤❛t t❤❡ ❛❞❞✐t✐♦♥s ❝❛♥ ❜❡ ♣❡r❢♦r♠❡❞ ❛s ✇❡ ❣♦ ❛❧♦♥❣✳ ❍♦✇ ❞♦ ✇❡ ♠❛❦❡ t❤❡ ❝♦♠♣✉t❡r ❞♦ t❤❛t❄

■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✷✵

Slide 207

Iteratively Summing the First n Integers

fun summing (n,total) = if n=0 then total else summing (n-1, n + total); > val summing = fn : int * int -> int

summing (3, 0) ⇒summing (2, 3) ⇒summing (1, 5) ⇒summing (0, 6) ⇒ 6 ❋✉♥❝t✐♦♥ s✉♠♠✐♥❣ t❛❦❡s ❛♥ ❛❞❞✐t✐♦♥❛❧ ❛r❣✉♠❡♥t✿ ❛ r✉♥♥✐♥❣ t♦t❛❧✳ ■❢ n ✐s ③❡r♦ t❤❡♥ ✐t r❡t✉r♥s t❤❡ r✉♥♥✐♥❣ t♦t❛❧❀ ♦t❤❡r✇✐s❡✱ s✉♠♠✐♥❣ ❛❞❞s t♦ ✐t ❛♥❞ ❝♦♥t✐♥✉❡s✳ ❚❤❡ r❡❝✉rs✐✈❡ ❝❛❧❧s ❞♦ ♥♦t ♥❡st❀ t❤❡ ❛❞❞✐t✐♦♥s ❛r❡ ❞♦♥❡ ✐♠♠❡❞✐✲ ❛t❡❧②✳ ❆ r❡❝✉rs✐✈❡ ❢✉♥❝t✐♦♥ ✇❤♦s❡ ❝♦♠♣✉t❛t✐♦♥ ❞♦❡s ♥♦t ♥❡st ✐s ❝❛❧❧❡❞ ✐t❡r❛t✐✈❡ ♦r t❛✐❧✲r❡❝✉rs✐✈❡✳ ▼❛♥② ❢✉♥❝t✐♦♥s ❝❛♥ ❜❡ ♠❛❞❡ ✐t❡r❛t✐✈❡ ❜② ✐♥tr♦❞✉❝✐♥❣ ❛♥ ❛r❣✉♠❡♥t ❛♥❛❧♦❣♦✉s t♦ t♦t❛❧✱ ✇❤✐❝❤ ✐s ♦❢t❡♥ ❝❛❧❧❡❞ ❛♥ ❛❝❝✉♠✉❧❛t♦r✳ ❚❤❡ ❣❛✐♥ ✐♥ ❡✣❝✐❡♥❝② ✐s s♦♠❡t✐♠❡s ✇♦rt❤✇❤✐❧❡ ❛♥❞ s♦♠❡t✐♠❡s ♥♦t✳ ❚❤❡ ❢✉♥❝t✐♦♥ ♣♦✇❡r ✐s ♥♦t ✐t❡r❛t✐✈❡ ❜❡❝❛✉s❡ ♥❡st✐♥❣ ♦❝❝✉rs ✇❤❡♥❡✈❡r t❤❡ ❡①♣♦♥❡♥t ✐s ♦❞❞✳ ❆❞❞✐♥❣ ❛ t❤✐r❞ ❛r❣✉♠❡♥t ♠❛❦❡s ✐t ✐t❡r❛t✐✈❡✱ ❜✉t t❤❡ ❝❤❛♥❣❡ ❝♦♠♣❧✐✲ ❝❛t❡s t❤❡ ❢✉♥❝t✐♦♥ ❛♥❞ t❤❡ ❣❛✐♥ ✐♥ ❡✣❝✐❡♥❝② ✐s ♠✐♥✉t❡❀ ❢♦r ✸✷✲❜✐t ✐♥t❡❣❡rs✱ t❤❡ ♠❛①✐♠✉♠ ♣♦ss✐❜❧❡ ♥❡st✐♥❣ ✐s ✸✵ ❢♦r t❤❡ ❡①♣♦♥❡♥t 231 − 1✳

■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✷✶

Slide 208

Recursion Versus Iteration: Some Comments

Iterative normally refers to a loop—coded using while, for instance. Tail-recursion is efficient only if the compiler detects it. Mainly it saves space, though iterative code can run faster. DON’T make programs iterative unless the gain is significant.

• People fought to give recursion to programmers: first, in Algol-60.
• Your code may turn into a mess!

❆ ❝❧❛ss✐❝ ❜♦♦❦ ❜② ❆❜❡❧s♦♥ ❛♥❞ ❙✉ss♠❛♥ ❬✶❪ ✉s❡❞ ✐t❡r❛t✐✈❡ t♦ ♠❡❛♥ t❛✐❧✲ r❡❝✉rs✐✈❡✳ ■t ❞❡s❝r✐❜❡s t❤❡ ▲✐s♣ ❞✐❛❧❡❝t ❦♥♦✇♥ ❛s ❙❝❤❡♠❡✳ ■t❡r❛t✐✈❡ ❢✉♥❝t✐♦♥s ♣r♦❞✉❝❡ ❝♦♠♣✉t❛t✐♦♥s r❡s❡♠❜❧✐♥❣ t❤♦s❡ t❤❛t ❝❛♥ ❜❡ ❞♦♥❡ ✉s✐♥❣ ✇❤✐❧❡✲❧♦♦♣s ✐♥ ❝♦♥✈❡♥t✐♦♥❛❧ ❧❛♥❣✉❛❣❡s✳ ▼❛♥② ❛❧❣♦r✐t❤♠s ❝❛♥ ❜❡ ❡①♣r❡ss❡❞ ♥❛t✉r❛❧❧② ✉s✐♥❣ r❡❝✉rs✐♦♥✱ ❜✉t ♦♥❧② ❛✇❦✇❛r❞❧② ✉s✐♥❣ ✐t❡r❛t✐♦♥✳ ❚❤❡r❡ ✐s ❛ st♦r② t❤❛t ❉✐❥❦str❛ s♥❡❛❦❡❞ r❡❝✉rs✐♦♥ ✐♥t♦ ❆❧❣♦❧✲✻✵ ❜② ✐♥s❡rt✐♥❣ t❤❡ ✇♦r❞s ✏❛♥② ♦t❤❡r ♦❝❝✉rr❡♥❝❡ ♦❢ t❤❡ ♣r♦❝❡❞✉r❡ ♥❛♠❡ ❞❡♥♦t❡s ❡①❡❝✉t✐♦♥ ♦❢ t❤❡ ♣r♦❝❡❞✉r❡✑✳ ❇② ♥♦t ✉s✐♥❣ t❤❡ ✇♦r❞ ✏r❡❝✉rs✐♦♥✑✱ ❤❡ ♠❛♥❛❣❡❞ t♦ s❧✐♣ t❤✐s ❛♠❡♥❞♠❡♥t ♣❛st s❝❡♣t✐❝❛❧ ❝♦❧❧❡❛❣✉❡s✳ ❖❜s❡ss✐♦♥ ✇✐t❤ t❛✐❧ r❡❝✉rs✐♦♥ ❧❡❛❞s t♦ ❛ ❝♦❞✐♥❣ st②❧❡ ✐♥ ✇❤✐❝❤ ❢✉♥❝t✐♦♥s ❤❛✈❡ ♠❛♥② ♠♦r❡ ❛r❣✉♠❡♥ts t❤❛♥ ♥❡❝❡ss❛r②✳ ❲r✐t❡ str❛✐❣❤t❢♦r✇❛r❞ ❝♦❞❡ ✜rst✱ ❛✈♦✐❞✐♥❣ ♦♥❧② ❣r♦ss ✐♥❡✣❝✐❡♥❝②✳ ■❢ t❤❡ ♣r♦❣r❛♠ t✉r♥s ♦✉t t♦ ❜❡ t♦♦ s❧♦✇✱ t♦♦❧s ❛r❡ ❛✈❛✐❧❛❜❧❡ ❢♦r ♣✐♥♣♦✐♥t✐♥❣ t❤❡ ❝❛✉s❡✳ ❆❧✇❛②s r❡♠❡♠❜❡r ❑■❙❙ ✭❑❡❡♣ ■t ❙✐♠♣❧❡✱ ❙t✉♣✐❞✮✳ ■ ❤♦♣❡ ②♦✉ ❤❛✈❡ ❛❧❧ ♥♦t✐❝❡❞ ❜② ♥♦✇ t❤❛t t❤❡ s✉♠♠❛t✐♦♥ ❝❛♥ ❜❡ ❞♦♥❡ ❡✈❡♥ ♠♦r❡ ❡✣❝✐❡♥t❧② ✉s✐♥❣ t❤❡ ❛r✐t❤♠❡t✐❝ ♣r♦❣r❡ss✐♦♥ ❢♦r♠✉❧❛ 1 + · · · + n = n(n + 1)/2.

■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✷✷

Slide 209

Computing Square Roots: Newton-Raphson xi+1 = a/xi + xi 2

fun nextApprox (a,x) = (a/x + x) / 2.0; > nextApprox = fn : real * real -> real nextApprox (2.0, 1.5); > val it = 1.41666666667 : real nextApprox (2.0, it); > val it = 1.41421568627 : real nextApprox (2.0, it); > val it = 1.41421356237 : real

◆♦✇✱ ❧❡t ✉s ❧♦♦❦ ❛t ❛ ❞✐✛❡r❡♥t s♦rt ♦❢ ❛❧❣♦r✐t❤♠✳ ❚❤❡ ◆❡✇t♦♥✲❘❛♣❤s♦♥ ♠❡t❤♦❞ ✐s ❛ ❤✐❣❤❧② ❡✛❡❝t✐✈❡ ♠❡❛♥s ♦❢ ✜♥❞✐♥❣ r♦♦ts ♦❢ ❡q✉❛t✐♦♥s✳ ■t ✐s ✉s❡❞ ✐♥ ♥✉♠❡r✐❝❛❧ ❧✐❜r❛r✐❡s t♦ ❝♦♠♣✉t❡ ♠❛♥② st❛♥❞❛r❞ ❢✉♥❝t✐♦♥s✱ ❛♥❞ ✐♥ ❤❛r❞✇❛r❡✱ t♦ ❝♦♠♣✉t❡ r❡❝✐♣r♦❝❛❧s✳ ❙t❛rt✐♥❣ ✇✐t❤ ❛♥ ❛♣♣r♦①✐♠❛t✐♦♥ x0✱ ❝♦♠♣✉t❡ ♥❡✇ ♦♥❡s x1✱ x2✱ ✳ ✳ ✳ ✱ ✉s✐♥❣ ❛ ❢♦r♠✉❧❛ ♦❜t❛✐♥❡❞ ❢r♦♠ t❤❡ ❡q✉❛t✐♦♥ t♦ ❜❡ s♦❧✈❡❞✳ Pr♦✈✐❞❡❞ t❤❡ ✐♥✐t✐❛❧ ❣✉❡ss ✐s s✉✣❝✐❡♥t❧② ❝❧♦s❡ t♦ t❤❡ r♦♦t✱ t❤❡ ♥❡✇ ❛♣♣r♦①✐♠❛t✐♦♥s ✇✐❧❧ ❝♦♥✈❡r❣❡ t♦ ✐t r❛♣✐❞❧②✳ ❚❤❡ ❢♦r♠✉❧❛ s❤♦✇♥ ❛❜♦✈❡ ❝♦♠♣✉t❡s t❤❡ sq✉❛r❡ r♦♦t ♦❢ a✳ ❚❤❡ ▼▲ s❡ss✐♦♥ ❞❡♠♦♥str❛t❡s t❤❡ ❝♦♠♣✉t❛t✐♦♥ ♦❢ √ 2✳ ❙t❛rt✐♥❣ ✇✐t❤ t❤❡ ❣✉❡ss x0 = 1.5✱ ✇❡ r❡❛❝❤ ❜② x3 t❤❡ sq✉❛r❡ r♦♦t ✐♥ ❢✉❧❧ ♠❛❝❤✐♥❡ ♣r❡❝✐s✐♦♥✳ ❈♦♥t✐♥✉✐♥❣ t❤❡ s❡ss✐♦♥ ❛ ❜✐t ❧♦♥❣❡r r❡✈❡❛❧s t❤❛t t❤❡ ❝♦♥✈❡r❣❡♥❝❡ ❤❛s ♦❝❝✉rr❡❞✱ ✇✐t❤ x4 = x3✿

♥❡①t❆♣♣r♦① ✭✷✳✵✱ ✐t✮❀ ❃ ✈❛❧ ✐t ❂ ✶✳✹✶✹✷✶✸✺✻✷✸✼ ✿ r❡❛❧ ✐t✯✐t❀ ❃ ✈❛❧ ✐t ❂ ✷✳✵ ✿ r❡❛❧

■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✷✸

Slide 210

A Square Root Function

fun findRoot (a, x, epsilon) = let val nextx = (a/x + x) / 2.0 in if abs(x-nextx) < epsilon*x then nextx else findRoot (a, nextx, epsilon) end; fun sqrt a = findRoot (a, 1.0, 1.0E~10); > sqrt = fn : real -> real sqrt 64.0; > val it = 8.0 : real

❚❤❡ ❢✉♥❝t✐♦♥ ❢✐♥❞❘♦♦t ❛♣♣❧✐❡s ◆❡✇t♦♥✲❘❛♣❤s♦♥ t♦ ❝♦♠♣✉t❡ t❤❡ sq✉❛r❡ r♦♦t ♦❢ a✱ st❛rt✐♥❣ ✇✐t❤ t❤❡ ✐♥✐t✐❛❧ ❣✉❡ss x✱ ✇✐t❤ r❡❧❛t✐✈❡ ❛❝❝✉r❛❝② ǫ✳ ■t t❡r♠✐♥❛t❡s ✇❤❡♥ s✉❝❝❡ss✐✈❡ ❛♣♣r♦①✐♠❛t✐♦♥s ❛r❡ ✇✐t❤✐♥ t❤❡ t♦❧❡r❛♥❝❡ ǫx✱ ♠♦r❡ ♣r❡❝✐s❡❧②✱ ✇❤❡♥ |xi − xi+1| < ǫx✳ ❚❤✐s r❡❝✉rs✐✈❡ ❢✉♥❝t✐♦♥ ❞✐✛❡rs ❢✉♥❞❛♠❡♥t❛❧❧② ❢r♦♠ ♣r❡✈✐♦✉s ♦♥❡s ❧✐❦❡ ♣♦✇❡r ❛♥❞ s✉♠♠✐♥❣✳ ❋♦r t❤♦s❡✱ ✇❡ ❝❛♥ ❡❛s✐❧② ♣✉t ❛ ❜♦✉♥❞ ♦♥ t❤❡ ♥✉♠❜❡r ♦❢ st❡♣s t❤❡② ✇✐❧❧ t❛❦❡✱ ❛♥❞ t❤❡✐r r❡s✉❧t ✐s ❡①❛❝t✳ ❋♦r ❢✐♥❞❘♦♦t✱ ❞❡t❡r♠✐♥✲ ✐♥❣ ❤♦✇ ♠❛♥② st❡♣s ❛r❡ r❡q✉✐r❡❞ ❢♦r ❝♦♥✈❡r❣❡♥❝❡ ✐s ❤❛r❞✳ ■t ♠✐❣❤t ♦s❝✐❧❧❛t❡ ❜❡t✇❡❡♥ t✇♦ ❛♣♣r♦①✐♠❛t✐♦♥s t❤❛t ❞✐✛❡r ✐♥ t❤❡✐r ❧❛st ❜✐t✳ ❖❜s❡r✈❡ ❤♦✇ ♥❡①t① ✐s ❞❡❝❧❛r❡❞ ❛s t❤❡ ♥❡①t ❛♣♣r♦①✐♠❛t✐♦♥✳ ❚❤✐s ✈❛❧✉❡ ✐s ✉s❡❞ t❤r❡❡ t✐♠❡s ❜✉t ❝♦♠♣✉t❡❞ ♦♥❧② ♦♥❝❡✳ ■♥ ❣❡♥❡r❛❧✱ ❧❡t D ✐♥ E ❡♥❞ ❞❡❝❧❛r❡s t❤❡ ✐t❡♠s ✐♥ D ❜✉t ♠❛❦❡s t❤❡♠ ✈✐s✐❜❧❡ ♦♥❧② ✐♥ t❤❡ ❡①♣r❡ss✐♦♥ E✳ ✭❘❡❝❛❧❧ t❤❛t ✐❞❡♥t✐✜❡rs ❞❡❝❧❛r❡❞ ✉s✐♥❣ ✈❛❧ ❝❛♥♥♦t ❜❡ ❛ss✐❣♥❡❞ t♦✳✮ ❋✉♥❝t✐♦♥ sqrt ♠❛❦❡s ❛♥ ✐♥✐t✐❛❧ ❣✉❡ss ♦❢ ✶✳✵✳ ❆ ♣r❛❝t✐❝❛❧ ❛♣♣❧✐❝❛t✐♦♥ ♦❢ ◆❡✇t♦♥✲❘❛♣❤s♦♥ ❣❡ts t❤❡ ✐♥✐t✐❛❧ ❛♣♣r♦①✐♠❛t✐♦♥ ❢r♦♠ ❛ t❛❜❧❡✳ ■♥❞❡①❡❞ ❜② s❛② ❡✐❣❤t ❜✐ts t❛❦❡♥ ❢r♦♠ a✱ t❤❡ t❛❜❧❡ ✇♦✉❧❞ ❤❛✈❡ ♦♥❧② ✷✺✻ ❡♥tr✐❡s✳ ❆ ❣♦♦❞ ✐♥✐t✐❛❧ ❣✉❡ss ❡♥s✉r❡s ❝♦♥✈❡r❣❡♥❝❡ ✇✐t❤✐♥ ❛ ♣r❡❞❡t❡r♠✐♥❡❞ ♥✉♠❜❡r ♦❢ st❡♣s✱ t②♣✐❝❛❧❧② t✇♦ ♦r t❤r❡❡✳ ❚❤❡ ❧♦♦♣ ❜❡❝♦♠❡s str❛✐❣❤t✲❧✐♥❡ ❝♦❞❡ ✇✐t❤ ♥♦ ❝♦♥✈❡r❣❡♥❝❡ t❡st✳

■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✷✹ ▲❡❛r♥✐♥❣ ❣✉✐❞❡✳ ❘❡❧❛t❡❞ ♠❛t❡r✐❛❧ ✐s ✐♥ ▼▲ ❢♦r t❤❡ ❲♦r❦✐♥❣ Pr♦❣r❛♠♠❡r✱ ♣❛❣❡s ✹✽✕✺✽✳ ❚❤❡ ♠❛t❡r✐❛❧ ♦♥ t②♣❡ ❝❤❡❝❦✐♥❣ ✭♣❛❣❡s ✻✸✕✻✼✮ ♠❛② ✐♥t❡r❡st t❤❡ ♠♦r❡ ❡♥t❤✉s✐❛st✐❝ st✉❞❡♥t✳ ❊①❡r❝✐s❡ ✷✳✶ ❈♦❞❡ ❛♥ ✐t❡r❛t✐✈❡ ✈❡rs✐♦♥ ♦❢ t❤❡ ❢✉♥❝t✐♦♥ ♣♦✇❡r✳ ❊①❡r❝✐s❡ ✷✳✷ ❚r② ✉s✐♥❣ xi+1 = xi(2 − xia) t♦ ❝♦♠♣✉t❡ 1/a✳ ❯♥❧❡ss t❤❡ ✐♥✐t✐❛❧ ❛♣♣r♦①✐♠❛t✐♦♥ x0 ✐s ❣♦♦❞✱ ✐t ♠✐❣❤t ♥♦t ❝♦♥✈❡r❣❡ ❛t ❛❧❧✳ ✭P✐❡rr❡ ❏♦✉❡t ❛♥❞ ❙t❡❢❛♥ ❘❡♥♦❧❞ ♥♦t❡ t❤❛t ✐❢ a > 0 t❤❡♥ t❤❡ s❡q✉❡♥❝❡ ❝♦♥✈❡r❣❡s ✐❢ ❛♥❞ ♦♥❧② ✐❢ 0 < x0 < 2/a✳✮ ❊①❡r❝✐s❡ ✷✳✸ ❋✉♥❝t✐♦♥s ♥♣♦✇❡r ❛♥❞ ♣♦✇❡r ❜♦t❤ ❤❛✈❡ t②♣❡ ❝♦♥str❛✐♥ts✱ ❜✉t ♦♥❧② ♦♥❡ ♦❢ t❤❡♠ ❛❝t✉❛❧❧② ♥❡❡❞s ✐t✳ ❚r② t♦ ✇♦r❦ ♦✉t ✇❤✐❝❤ ❢✉♥❝t✐♦♥ ❞♦❡s ♥♦t ♥❡❡❞s ✐ts t②♣❡ ❝♦♥str❛✐♥t ♠❡r❡❧② ❜② ❧♦♦❦✐♥❣ ❛t ✐ts ❞❡❝❧❛r❛t✐♦♥✳

■■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✷✺

Slide 301

A Silly Square Root Function

fun nthApprox (a,x,n) = if n=0 then x else (a / nthApprox(a,x,n-1) + nthApprox(a,x,n-1)) / 2.0;

The function calls itself 2n times! Bigger inputs mean higher costs—but what’s the growth rate?

❚❤❡ ♣✉r♣♦s❡ ♦❢ ♥t❤❆♣♣r♦① ✐s t♦ ❝♦♠♣✉t❡ xn ❢r♦♠ t❤❡ ✐♥✐t✐❛❧ ❛♣♣r♦①✐♠❛✲ t✐♦♥ x0 ✉s✐♥❣ t❤❡ ◆❡✇t♦♥✲❘❛♣❤s♦♥ ❢♦r♠✉❧❛ xi+1 = (a/xi + xi)/2✳ ❘❡♣❡❛t✐♥❣ t❤❡ r❡❝✉rs✐✈❡ ❝❛❧❧✖❛♥❞ t❤❡r❡❢♦r❡ t❤❡ ❝♦♠♣✉t❛t✐♦♥✖✐s ♦❜✈✐♦✉s❧② ✇❛st❡❢✉❧✳ ❚❤❡ r❡♣❡t✐t✐♦♥ ❝❛♥ ❜❡ ❡❧✐♠✐♥❛t❡❞ ✉s✐♥❣ ❧❡t ✈❛❧✳✳✳✐♥ E ❡♥❞✳ ❇❡tt❡r st✐❧❧ ✐s t♦ ❝❛❧❧ t❤❡ ❢✉♥❝t✐♦♥ ♥❡①t❆♣♣r♦①✱ ✉t✐❧✐③✐♥❣ ❛♥ ❡①✐st✐♥❣ ❛❜str❛❝t✐♦♥✳ ❋❛st ❤❛r❞✇❛r❡ ❞♦❡s ♥♦t ♠❛❦❡ ❣♦♦❞ ❛❧❣♦r✐t❤♠s ✉♥♥❡❝❡ss❛r②✳ ❖♥ t❤❡ ❝♦♥✲ tr❛r②✱ ❢❛st❡r ❤❛r❞✇❛r❡ ♠❛❣♥✐✜❡s t❤❡ s✉♣❡r✐♦r✐t② ♦❢ ❜❡tt❡r ❛❧❣♦r✐t❤♠s✳ ❚②♣✲ ✐❝❛❧❧②✱ ✇❡ ✇❛♥t t♦ ❤❛♥❞❧❡ t❤❡ ❧❛r❣❡st ✐♥♣✉ts ♣♦ss✐❜❧❡✳ ■❢ ✇❡ ❜✉② ❛ ♠❛❝❤✐♥❡ t❤❛t ✐s t✇✐❝❡ ❛s ♣♦✇❡r❢✉❧ ❛s ♦✉r ♦❧❞ ♦♥❡✱ ❤♦✇ ♠✉❝❤ ❝❛♥ t❤❡ ✐♥♣✉t t♦ ♦✉r ❢✉♥❝t✐♦♥ ❜❡ ✐♥❝r❡❛s❡❞❄ ❲✐t❤ ♥t❤❆♣♣r♦①✱ ✇❡ ❝❛♥ ♦♥❧② ❣♦ ❢r♦♠ n t♦ n + 1✳ ❲❡ ❛r❡ ❧✐♠✐t❡❞ t♦ t❤✐s ♠♦❞❡st ✐♥❝r❡❛s❡ ❜❡❝❛✉s❡ t❤❡ ❢✉♥❝t✐♦♥✬s r✉♥♥✐♥❣ t✐♠❡ ✐s ♣r♦♣♦rt✐♦♥❛❧ t♦ 2n✳ ❲✐t❤ t❤❡ ❢✉♥❝t✐♦♥ ♥♣♦✇❡r✱ ❞❡✜♥❡❞ ✐♥ ▲❡❝t✳ ✷✱ ✇❡ ❝❛♥ ❣♦ ❢r♦♠ n t♦ 2n✿ ✇❡ ❝❛♥ ❤❛♥❞❧❡ ♣r♦❜❧❡♠s t✇✐❝❡ ❛s ❜✐❣✳ ❲✐t❤ ♣♦✇❡r ✇❡ ❝❛♥ ❞♦ ♠✉❝❤ ❜❡tt❡r st✐❧❧✱ ❣♦✐♥❣ ❢r♦♠ n t♦ n2✳ ❆s②♠♣t♦t✐❝ ❝♦♠♣❧❡①✐t② r❡❢❡rs t♦ ❤♦✇ ❝♦sts ❣r♦✇ ✇✐t❤ ✐♥❝r❡❛s✐♥❣ ✐♥♣✉ts✳ ❈♦sts ✉s✉❛❧❧② r❡❢❡r t♦ t✐♠❡ ♦r s♣❛❝❡✳ ❙♣❛❝❡ ❝♦♠♣❧❡①✐t② ❝❛♥ ♥❡✈❡r ❡①❝❡❡❞ t✐♠❡ ❝♦♠♣❧❡①✐t②✱ ❢♦r ✐t t❛❦❡s t✐♠❡ t♦ ❞♦ ❛♥②t❤✐♥❣ ✇✐t❤ t❤❡ s♣❛❝❡✳ ❚✐♠❡ ❝♦♠♣❧❡①✐t② ♦❢t❡♥ ❣r❡❛t❧② ❡①❝❡❡❞s s♣❛❝❡ ❝♦♠♣❧❡①✐t②✳ ❚❤✐s ❧❡❝t✉r❡ ❝♦♥s✐❞❡rs ❤♦✇ t♦ ❡st✐♠❛t❡ ✈❛r✐♦✉s ❝♦sts ❛ss♦❝✐❛t❡❞ ✇✐t❤ ❛ ♣r♦✲ ❣r❛♠✳ ❆ ❜r✐❡❢ ✐♥tr♦❞✉❝t✐♦♥ t♦ ❛ ❞✐✣❝✉❧t s✉❜❥❡❝t✱ ✐t ❞r❛✇s ✉♣♦♥ t❤❡ ❡①❝❡❧❧❡♥t t❡①ts ❈♦♥❝r❡t❡ ▼❛t❤❡♠❛t✐❝s ❬✻❪ ❛♥❞ ■♥tr♦❞✉❝t✐♦♥ t♦ ❆❧❣♦r✐t❤♠s ❬✺❪✳

■■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✷✻

Slide 302

Some Illustrative Figures

complexity 1 second 1 minute 1 hour gain

n

1000 60,000 3,600,000

×60 n lg n

140 4,893 200,000

×41 n2

31 244 1,897

×8 n3

10 39 153

×4 2n

9 15 21

+6

complexity = milliseconds needed for an input of size n

❚❤✐s t❛❜❧❡ ✭❡①❝❡r♣t❡❞ ❢r♦♠ ❆❤♦ ❡t ❛❧✳ ❬✷✱ ♣❛❣❡ ✸❪✮ ✐❧❧✉str❛t❡s t❤❡ ❡✛❡❝t ♦❢ ✈❛r✐♦✉s t✐♠❡ ❝♦♠♣❧❡①✐t✐❡s✳ ❚❤❡ ❧❡❢t✲❤❛♥❞ ❝♦❧✉♠♥ ✐♥❞✐❝❛t❡s ❤♦✇ ♠❛♥② ♠✐❧❧✐s❡❝♦♥❞s ❛r❡ r❡q✉✐r❡❞ t♦ ♣r♦❝❡ss ❛♥ ✐♥♣✉t ♦❢ s✐③❡ n✳ ❚❤❡ ♦t❤❡r ❡♥tr✐❡s s❤♦✇ t❤❡ ♠❛①✐♠✉♠ s✐③❡ ♦❢ n t❤❛t ❝❛♥ ❜❡ ♣r♦❝❡ss❡❞ ✐♥ t❤❡ ❣✐✈❡♥ t✐♠❡ ✭♦♥❡ s❡❝♦♥❞✱ ♠✐♥✉t❡ ♦r ❤♦✉r✮✳ ❚❤❡ t❛❜❧❡ ✐❧❧✉str❛t❡s ❤♦✇ ❤♦✇ ❧❛r❣❡ ❛♥ ✐♥♣✉t ❝❛♥ ❜❡ ♣r♦❝❡ss❡❞ ❛s ❛ ❢✉♥❝✲ t✐♦♥ ♦❢ t✐♠❡✳ ❆s ✇❡ ✐♥❝r❡❛s❡ t❤❡ ❝♦♠♣✉t❡r t✐♠❡ ♣❡r ✐♥♣✉t ❢r♦♠ ♦♥❡ s❡❝♦♥❞ t♦ ♦♥❡ ♠✐♥✉t❡ ❛♥❞ t❤❡♥ t♦ ♦♥❡ ❤♦✉r✱ t❤❡ s✐③❡ ♦❢ t❤❡ ✐♥♣✉t ✐♥❝r❡❛s❡s ❛❝❝♦r❞✐♥❣❧②✳ ❚❤❡ t♦♣ t✇♦ r♦✇s ✭❝♦♠♣❧❡①✐t✐❡s n ❛♥❞ n lg n✮ ✐♥❝r❡❛s❡ r❛♣✐❞❧②✿ ❢♦r n✱ ❜② ❛ ❢❛❝t♦r ♦❢ ✻✵✳ ❚❤❡ ❜♦tt♦♠ t✇♦ st❛rt ♦✉t ❝❧♦s❡ t♦❣❡t❤❡r✱ ❜✉t n3 ✭✇❤✐❝❤ ❣r♦✇s ❜② ❛ ❢❛❝t♦r ♦❢ ✸✳✾✮ ♣✉❧❧s ✇❡❧❧ ❛✇❛② ❢r♦♠ 2n ✭✇❤♦s❡ ❣r♦✇t❤ ✐s ♦♥❧② ❛❞❞✐t✐✈❡✮✳ ■❢ ❛♥ ❛❧❣♦r✐t❤♠✬s ❝♦♠♣❧❡①✐t② ✐s ❡①♣♦♥❡♥t✐❛❧ t❤❡♥ ✐t ❝❛♥ ♥❡✈❡r ❤❛♥❞❧❡ ❧❛r❣❡ ✐♥♣✉ts✱ ❡✈❡♥ ✐❢ ✐t ✐s ❣✐✈❡♥ ❤✉❣❡ r❡s♦✉r❝❡s✳ ❖♥ t❤❡ ♦t❤❡r ❤❛♥❞✱ s✉♣♣♦s❡ t❤❡ ❝♦♠♣❧❡①✐t② ❤❛s t❤❡ ❢♦r♠ nc✱ ✇❤❡r❡ c ✐s ❛ ❝♦♥st❛♥t✳ ✭❲❡ s❛② t❤❡ ❝♦♠♣❧❡①✐t② ✐s ♣♦❧②♥♦♠✐❛❧✳✮ ❉♦✉❜❧✐♥❣ t❤❡ ❛r❣✉♠❡♥t t❤❡♥ ✐♥❝r❡❛s❡s t❤❡ ❝♦st ❜② ❛ ❝♦♥st❛♥t ❢❛❝t♦r✳ ❚❤❛t ✐s ♠✉❝❤ ❜❡tt❡r✱ t❤♦✉❣❤ ✐❢ c > 3 t❤❡ ❛❧❣♦r✐t❤♠ ♠❛② ♥♦t ❜❡ ❝♦♥s✐❞❡r❡❞ ♣r❛❝t✐❝❛❧✳ ❊①❡r❝✐s❡ ✸✳✶ ❆❞❞ ❛ ❝♦❧✉♠♥ t♦ t❤❡ t❛❜❧❡ ✇✐t❤ t❤❡ ❤❡❛❞✐♥❣ ✻✵ ❤♦✉rs✳

■■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✷✼

Slide 303

Comparing Algorithms

Look at the most significant term. Ignore constant factors:

• They are seldom important.
• They depend on ephemeral details such as computer brand.

Example: consider n2 instead of 3n2 + 34n + 433.

❚❤❡ ❝♦st ♦❢ ❛ ♣r♦❣r❛♠ ✐s ✉s✉❛❧❧② ❛ ❝♦♠♣❧✐❝❛t❡❞ ❢♦r♠✉❧❛✳ ❖❢t❡♥ ✇❡ s❤♦✉❧❞ ❝♦♥s✐❞❡r ♦♥❧② t❤❡ ♠♦st s✐❣♥✐✜❝❛♥t t❡r♠✳ ■❢ t❤❡ ❝♦st ✐s n2 + 99n + 900 ❢♦r ❛♥ ✐♥♣✉t ♦❢ s✐③❡ n✱ t❤❡♥ t❤❡ n2 t❡r♠ ✇✐❧❧ ❡✈❡♥t✉❛❧❧② ❞♦♠✐♥❛t❡✱ ❡✈❡♥ t❤♦✉❣❤ 99n ✐s ❜✐❣❣❡r ❢♦r n < 99✳ ❚❤❡ ❝♦♥st❛♥t t❡r♠ ✾✵✵ ♠❛② ❧♦♦❦ ❜✐❣✱ ❜✉t ❛s n ✐♥❝r❡❛s❡s ✐t r❛♣✐❞❧② ❜❡❝♦♠❡s ✐♥s✐❣♥✐✜❝❛♥t✳ ❈♦♥st❛♥t ❢❛❝t♦rs ✐♥ ❝♦sts ❛r❡ ♦❢t❡♥ ✐❣♥♦r❡❞✳ ❋♦r ♦♥❡ t❤✐♥❣✱ t❤❡② s❡❧❞♦♠ ♠❛❦❡ ❛ ❞✐✛❡r❡♥❝❡✿ 100n2 ✇✐❧❧ ❜❡ ❜❡tt❡r t❤❛♥ n3 ✐♥ t❤❡ ❧♦♥❣ r✉♥✳ ❖♥❧② ✐❢ t❤❡ ❧❡❛❞✐♥❣ t❡r♠s ❛r❡ ♦t❤❡r✇✐s❡ ✐❞❡♥t✐❝❛❧ ❞♦ ❝♦♥st❛♥t ❢❛❝t♦rs ❜❡❝♦♠❡ ✐♠♣♦rt❛♥t✳ ❇✉t t❤❡r❡ ✐s ❛ s❡❝♦♥❞ ❞✐✣❝✉❧t②✿ ❝♦♥st❛♥t ❢❛❝t♦rs ❛r❡ s❡❧❞♦♠ r❡❧✐❛❜❧❡✳ ❚❤❡② ❞❡♣❡♥❞ ✉♣♦♥ ❞❡t❛✐❧s s✉❝❤ ❛s ✇❤✐❝❤ ❤❛r❞✇❛r❡✱ ♦♣❡r❛t✐♥❣ s②st❡♠ ♦r ♣r♦❣r❛♠✲ ♠✐♥❣ ❧❛♥❣✉❛❣❡ ✐s ❜❡✐♥❣ ✉s❡❞✳ ❇② ✐❣♥♦r✐♥❣ ❝♦♥st❛♥t ❢❛❝t♦rs✱ ✇❡ ❝❛♥ ♠❛❦❡ ❝♦♠♣❛r✐s♦♥s ❜❡t✇❡❡♥ ❛❧❣♦r✐t❤♠s t❤❛t r❡♠❛✐♥ ✈❛❧✐❞ ✐♥ ❛ ❜r♦❛❞ r❛♥❣❡ ♦❢ ❝✐r✲ ❝✉♠st❛♥❝❡s✳ ■♥ ♣r❛❝t✐❝❡✱ ❝♦♥st❛♥t ❢❛❝t♦rs s♦♠❡t✐♠❡s ♠❛tt❡r✳ ■❢ ❛♥ ❛❧❣♦r✐t❤♠ ✐s t♦♦ ❝♦♠♣❧✐❝❛t❡❞✱ ✐ts ❝♦sts ✇✐❧❧ ✐♥❝❧✉❞❡ ❛ ❧❛r❣❡ ❝♦♥st❛♥t ❢❛❝t♦r✳ ■♥ t❤❡ ❝❛s❡ ♦❢ ♠✉❧✲ t✐♣❧✐❝❛t✐♦♥✱ t❤❡ t❤❡♦r❡t✐❝❛❧❧② ❢❛st❡st ❛❧❣♦r✐t❤♠ ❝❛t❝❤❡s ✉♣ ✇✐t❤ t❤❡ st❛♥❞❛r❞ ♦♥❡ ♦♥❧② ❢♦r ❡♥♦r♠♦✉s ✈❛❧✉❡s ♦❢ n✳

■■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✷✽

Slide 304

O Notation (And Friends)

f(n) = O(g(n)) provided |f(n)| ≤ c|g(n)|

• for some constant c
• and all sufficiently large n.

f(n) = O(g(n)) means g is an upper bound on f f(n) = Ω(g(n)) means g is an lower bound on f f(n) = Θ(g(n)) means g gives exact bounds on f ❚❤❡ ❵❇✐❣ ❖✬ ♥♦t❛t✐♦♥ ✐s ❝♦♠♠♦♥❧② ✉s❡❞ t♦ ❞❡s❝r✐❜❡ ❡✣❝✐❡♥❝②✖t♦ ❜❡ ♣r❡✲ ❝✐s❡✱ ❛s②♠♣t♦t✐❝ ❝♦♠♣❧❡①✐t②✳ ■t ❝♦♥❝❡r♥s t❤❡ ❧✐♠✐t ♦❢ ❛ ❢✉♥❝t✐♦♥ ❛s ✐ts ❛r❣✉✲ ♠❡♥t t❡♥❞s t♦ ✐♥✜♥✐t②✳ ■t ✐s ❛♥ ❛❜str❛❝t✐♦♥ t❤❛t ♠❡❡ts t❤❡ ✐♥❢♦r♠❛❧ ❝r✐t❡r✐❛ t❤❛t ✇❡ ❤❛✈❡ ❥✉st ❞✐s❝✉ss❡❞✳ ■♥ t❤❡ ❞❡✜♥✐t✐♦♥✱ s✉✣❝✐❡♥t❧② ❧❛r❣❡ ♠❡❛♥s t❤❡r❡ ✐s s♦♠❡ ❝♦♥st❛♥t n0 s✉❝❤ t❤❛t |f(n)| ≤ c|g(n)| ❢♦r ❛❧❧ n ❣r❡❛t❡r t❤❛♥ n0✳ ❚❤❡ r♦❧❡ ♦❢ n0 ✐s t♦ ✐❣♥♦r❡ ✜♥✐t❡❧② ♠❛♥② ❡①❝❡♣t✐♦♥s t♦ t❤❡ ❜♦✉♥❞✱ s✉❝❤ ❛s t❤❡ ❝❛s❡s ✇❤❡♥ 99n ❡①❝❡❡❞s n2✳ ❚❤❡ ♥♦t❛t✐♦♥ ❛❧s♦ ✐❣♥♦r❡s ❝♦♥st❛♥t ❢❛❝t♦rs s✉❝❤ ❛s c✳ ❲❡ ♠❛② ✉s❡ ❛ ❞✐✛❡r❡♥t c ❛♥❞ n0 ✇✐t❤ ❡❛❝❤ f✳ ❚❤❡ st❛♥❞❛r❞ ♥♦t❛t✐♦♥ f(n) = O(g(n)) ✐s ♠✐s❧❡❛❞✐♥❣✿ t❤✐s ✐s ♥♦ ❡q✉❛t✐♦♥✳ P❧❡❛s❡ ✉s❡ ❝♦♠♠♦♥ s❡♥s❡✳ ❋r♦♠ f(n) = O(n) ❛♥❞ f ′(n) = O(n) ✇❡ ❝❛♥♥♦t ✐♥❢❡r f(n) = f ′(n)✳ ◆♦t❡ t❤❛t f(n) = O(g(n)) ❣✐✈❡s ❛♥ ✉♣♣❡r ❜♦✉♥❞ ♦♥ f ✐♥ t❡r♠s ♦❢ g✳ ❚♦ s♣❡❝✐❢② ❛ ❧♦✇❡r ❜♦✉♥❞✱ ✇❡ ❤❛✈❡ t❤❡ ❞✉❛❧ ♥♦t❛t✐♦♥ f(n) = Ω(g(n)) ⇐ ⇒ |f(n)| ≥ c|g(n))| ❢♦r s♦♠❡ ❝♦♥st❛♥t c ❛♥❞ ❛❧❧ s✉✣❝✐❡♥t❧② ❧❛r❣❡ n✳ ❚❤❡ ❝♦♥❥✉♥❝t✐♦♥ ♦❢ f(n) = O(g(n)) ❛♥❞ f(n) = Ω(g(n)) ✐s ✇r✐tt❡♥ f(n) = Θ(g(n))✳ P❡♦♣❧❡ ♦❢t❡♥ ✉s❡ O(g(n)) ❛s ✐❢ ✐t ❣❛✈❡ ❛ t✐❣❤t ❜♦✉♥❞✱ ❝♦♥❢✉s✐♥❣ ✐t ✇✐t❤ Θ(g(n))✳ ❙✐♥❝❡ O(g(n)) ❣✐✈❡s ❛♥ ✉♣♣❡r ❜♦✉♥❞✱ ✐❢ f(n) = O(n) t❤❡♥ ❛❧s♦ f(n) = O(n2)✳ ❚r✐❝❦② ❡①❛♠✐♥❛t✐♦♥ q✉❡st✐♦♥s ❡①♣❧♦✐t t❤✐s ❢❛❝t✳

■■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✷✾

Slide 305

Simple Facts About O Notation O(2g(n)) is the same as O(g(n)) O(log10 n) is the same as O(ln n) O(n2 + 50n + 36) is the same as O(n2) O(n2) is contained in O(n3) O(2n) is contained in O(3n) O(log n) is contained in O(√n) O ♥♦t❛t✐♦♥ ❧❡ts ✉s r❡❛s♦♥ ❛❜♦✉t t❤❡ ❝♦sts ♦❢ ❛❧❣♦r✐t❤♠s ❡❛s✐❧②✳

• ❈♦♥st❛♥t ❢❛❝t♦rs s✉❝❤ ❛s t❤❡ ✷ ✐♥ O(2g(n)) ❞r♦♣ ♦✉t✿

✇❡ ❝❛♥ ✉s❡ O(g(n)) ✇✐t❤ t✇✐❝❡ t❤❡ ✈❛❧✉❡ ♦❢ c ✐♥ t❤❡ ❞❡✜♥✐t✐♦♥✳

• ❇❡❝❛✉s❡ ❝♦♥st❛♥t ❢❛❝t♦rs ❞r♦♣ ♦✉t✱ t❤❡ ❜❛s❡ ♦❢ ❧♦❣❛r✐t❤♠s ✐s ✐rr❡❧❡✈❛♥t✳
• ■♥s✐❣♥✐✜❝❛♥t t❡r♠s ❞r♦♣ ♦✉t✳ ❚♦ s❡❡ t❤❛t O(n2 + 50n + 36) ✐s t❤❡ s❛♠❡

❛s O(n2)✱ ❝♦♥s✐❞❡r t❤❡ ✈❛❧✉❡ ♦❢ n0 ♥❡❡❞❡❞ ✐♥ f(n) = O(n2 + 50n + 36)✳ ❯s✐♥❣ t❤❡ ❧❛✇ (n + k)2 = n2 + 2nk + k2✱ ✐t ✐s ❡❛s② t♦ ❝❤❡❝❦ t❤❛t ✉s✐♥❣ n0 + 25 ❢♦r n0 ❛♥❞ ❦❡❡♣✐♥❣ t❤❡ s❛♠❡ ✈❛❧✉❡ ♦❢ c ❣✐✈❡s f(n) = O(n2)✳ ■❢ c ❛♥❞ d ❛r❡ ❝♦♥st❛♥ts ✭t❤❛t ✐s✱ t❤❡② ❛r❡ ✐♥❞❡♣❡♥❞❡♥t ♦❢ n✮ ✇✐t❤ 0 < c < d t❤❡♥ O(nc) ✐s ❝♦♥t❛✐♥❡❞ ✐♥ O(nd) O(cn) ✐s ❝♦♥t❛✐♥❡❞ ✐♥ O(dn) O(log n) ✐s ❝♦♥t❛✐♥❡❞ ✐♥ O(nc) ❚♦ s❛② t❤❛t O(cn) ✐s ❝♦♥t❛✐♥❡❞ ✐♥ O(dn) ♠❡❛♥s t❤❛t t❤❡ ❢♦r♠❡r ❣✐✈❡s ❛ t✐❣❤t❡r ❜♦✉♥❞ t❤❛♥ t❤❡ ❧❛tt❡r✳ ❋♦r ❡①❛♠♣❧❡✱ ✐❢ f(n) = O(2n) t❤❡♥ f(n) = O(3n) tr✐✈✐❛❧❧②✱ ❜✉t t❤❡ ❝♦♥✈❡rs❡ ❞♦❡s ♥♦t ❤♦❧❞✳

■■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✸✵

Slide 306

Common Complexity Classes O(1)

constant

O(log n)

logarithmic

O(n)

linear

O(n log n)

quasi-linear

O(n2)

quadratic

O(n3)

cubic

O(an)

exponential (for fixed a)

▲♦❣❛r✐t❤♠s ❣r♦✇ ✈❡r② s❧♦✇❧②✱ s♦ O(log n) ❝♦♠♣❧❡①✐t② ✐s ❡①❝❡❧❧❡♥t✳ ❇❡❝❛✉s❡ O ♥♦t❛t✐♦♥ ✐❣♥♦r❡s ❝♦♥st❛♥t ❢❛❝t♦rs✱ t❤❡ ❜❛s❡ ♦❢ t❤❡ ❧♦❣❛r✐t❤♠ ✐s ✐rr❡❧❡✈❛♥t✦ ❯♥❞❡r ❧✐♥❡❛r ✇❡ ♠✐❣❤t ♠❡♥t✐♦♥ O(n log n)✱ ✇❤✐❝❤ ♦❝❝❛s✐♦♥❛❧❧② ✐s ❝❛❧❧❡❞ q✉❛s✐✲❧✐♥❡❛r✱ ❛♥❞ ✇❤✐❝❤ s❝❛❧❡s ✉♣ ✇❡❧❧ ❢♦r ❧❛r❣❡ n✳ ❆♥ ❡①❛♠♣❧❡ ♦❢ q✉❛❞r❛t✐❝ ❝♦♠♣❧❡①✐t② ✐s ♠❛tr✐① ❛❞❞✐t✐♦♥✿ ❢♦r♠✐♥❣ t❤❡ s✉♠ ♦❢ t✇♦ n × n ♠❛tr✐❝❡s ♦❜✈✐♦✉s❧② t❛❦❡s n2 ❛❞❞✐t✐♦♥s✳ ▼❛tr✐① ♠✉❧t✐♣❧✐❝❛t✐♦♥ ✐s ♦❢ ❝✉❜✐❝ ❝♦♠♣❧❡①✐t②✱ ✇❤✐❝❤ ❧✐♠✐ts t❤❡ s✐③❡ ♦❢ ♠❛tr✐❝❡s t❤❛t ✇❡ ❝❛♥ ♠✉❧t✐♣❧② ✐♥ r❡❛s♦♥❛❜❧❡ t✐♠❡✳ ❆♥ O(n2.81) ❛❧❣♦r✐t❤♠ ❡①✐sts✱ ❜✉t ✐t ✐s t♦♦ ❝♦♠♣❧✐❝❛t❡❞ t♦ ❜❡ ♦❢ ♠✉❝❤ ✉s❡✱ ❡✈❡♥ t❤♦✉❣❤ ✐t ✐s t❤❡♦r❡t✐❝❛❧❧② ❜❡tt❡r✳ ❆♥ ❡①♣♦♥❡♥t✐❛❧ ❣r♦✇t❤ r❛t❡ s✉❝❤ ❛s 2n r❡str✐❝ts ✉s t♦ s♠❛❧❧ ✈❛❧✉❡s ♦❢ n✳ ❆❧r❡❛❞② ✇✐t❤ n = 20 t❤❡ ❝♦st ❡①❝❡❡❞s ♦♥❡ ♠✐❧❧✐♦♥✳ ❍♦✇❡✈❡r✱ t❤❡ ✇♦rst ❝❛s❡ ♠✐❣❤t ♥♦t ❛r✐s❡ ✐♥ ♥♦r♠❛❧ ♣r❛❝t✐❝❡✳ ▼▲ t②♣❡✲❝❤❡❝❦✐♥❣ ✐s ❡①♣♦♥❡♥t✐❛❧ ✐♥ t❤❡ ✇♦rst ❝❛s❡✱ ❜✉t ♥♦t ❢♦r ♦r❞✐♥❛r② ♣r♦❣r❛♠s✳

■■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✸✶

Slide 307

Sample Costs in O Notation

function time space

npower, nsum O(n) O(n) summing O(n) O(1) n(n + 1)/2 O(1) O(1) power O(log n) O(log n) nthApprox O(2n) O(n) ❘❡❝❛❧❧ ✭▲❡❝t✳ ✷✮ t❤❛t ♥♣♦✇❡r ❝♦♠♣✉t❡s xn ❜② r❡♣❡❛t❡❞ ♠✉❧t✐♣❧✐❝❛t✐♦♥ ✇❤✐❧❡ ♥s✉♠ ♥❛ï✈❡❧② ❝♦♠♣✉t❡s t❤❡ s✉♠ 1 + · · · + n✳ ❊❛❝❤ ♦❜✈✐♦✉s❧② ♣❡r❢♦r♠s O(n) ❛r✐t❤♠❡t✐❝ ♦♣❡r❛t✐♦♥s✳ ❇❡❝❛✉s❡ t❤❡② ❛r❡ ♥♦t t❛✐❧ r❡❝✉rs✐✈❡✱ t❤❡✐r ✉s❡ ♦❢ s♣❛❝❡ ✐s ❛❧s♦ O(n)✳ ❚❤❡ ❢✉♥❝t✐♦♥ s✉♠♠✐♥❣ ✐s ❛ ✈❡rs✐♦♥ ♦❢ ♥s✉♠ ✇✐t❤ ❛♥ ❛❝❝✉✲ ♠✉❧❛t✐♥❣ ❛r❣✉♠❡♥t❀ ✐ts ✐t❡r❛t✐✈❡ ❜❡❤❛✈✐♦✉r ❧❡ts ✐t ✇♦r❦ ✐♥ ❝♦♥st❛♥t s♣❛❝❡✳ O ♥♦t❛t✐♦♥ s♣❛r❡s ✉s ❢r♦♠ ❤❛✈✐♥❣ t♦ s♣❡❝✐❢② t❤❡ ✉♥✐ts ✉s❡❞ t♦ ♠❡❛s✉r❡ s♣❛❝❡✳ ❊✈❡♥ ✐❣♥♦r✐♥❣ ❝♦♥st❛♥t ❢❛❝t♦rs✱ t❤❡ ✉♥✐ts ❝❤♦s❡♥ ❝❛♥ ✐♥✢✉❡♥❝❡ t❤❡ r❡s✉❧t✳ ▼✉❧t✐♣❧✐❝❛t✐♦♥ ♠❛② ❜❡ r❡❣❛r❞❡❞ ❛s ❛ s✐♥❣❧❡ ✉♥✐t ♦❢ ❝♦st✳ ❍♦✇❡✈❡r✱ t❤❡ ❝♦st ♦❢ ♠✉❧t✐♣❧②✐♥❣ t✇♦ n✲❞✐❣✐t ♥✉♠❜❡rs ❢♦r ❧❛r❣❡ n ✐s ✐ts❡❧❢ ❛♥ ✐♠♣♦rt❛♥t q✉❡st✐♦♥✱ ❡s♣❡❝✐❛❧❧② ♥♦✇ t❤❛t ♣✉❜❧✐❝✲❦❡② ❝r②♣t♦❣r❛♣❤② ✉s❡s ♥✉♠❜❡rs ❤✉♥❞r❡❞s ♦❢ ❞✐❣✐ts ❧♦♥❣✳ ❋❡✇ t❤✐♥❣s ❝❛♥ r❡❛❧❧② ❜❡ ❞♦♥❡ ✐♥ ❝♦♥st❛♥t t✐♠❡ ♦r st♦r❡❞ ✐♥ ❝♦♥st❛♥t s♣❛❝❡✳ ▼❡r❡❧② t♦ st♦r❡ t❤❡ ♥✉♠❜❡r n r❡q✉✐r❡s O(log n) ❜✐ts✳ ■❢ ❛ ♣r♦❣r❛♠ ❝♦st ✐s O(1)✱ t❤❡♥ ✇❡ ❤❛✈❡ ♣r♦❜❛❜❧② ❛ss✉♠❡❞ t❤❛t ❝❡rt❛✐♥ ♦♣❡r❛t✐♦♥s ✐t ♣❡r❢♦r♠s ❛r❡ ❛❧s♦ O(1)✖t②♣✐❝❛❧❧② ❜❡❝❛✉s❡ ✇❡ ❡①♣❡❝t ♥❡✈❡r t♦ ❡①❝❡❡❞ t❤❡ ❝❛♣❛❝✐t② ♦❢ t❤❡ st❛♥❞❛r❞ ❤❛r❞✇❛r❡ ❛r✐t❤♠❡t✐❝✳ ❲✐t❤ ♣♦✇❡r✱ t❤❡ ♣r❡❝✐s❡ ♥✉♠❜❡r ♦❢ ♦♣❡r❛t✐♦♥s ❞❡♣❡♥❞s ✉♣♦♥ n ✐♥ ❛ ❝♦♠✲ ♣❧✐❝❛t❡❞ ✇❛②✱ ❞❡♣❡♥❞✐♥❣ ♦♥ ❤♦✇ ♠❛♥② ♦❞❞ ♥✉♠❜❡rs ❛r✐s❡✱ s♦ ✐t ✐s ❝♦♥✈❡♥✐❡♥t t❤❛t ✇❡ ❝❛♥ ❥✉st ✇r✐t❡ O(log n)✳ ❆♥ ❛❝❝✉♠✉❧❛t✐♥❣ ❛r❣✉♠❡♥t ❝♦✉❧❞ r❡❞✉❝❡ ✐ts s♣❛❝❡ ❝♦st t♦ O(1)✳

■■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✸✷

Slide 308

Solving Simple Recurrence Relations T(n): a cost we want to bound using O notation

Typical base case: T(1) = 1 Some recurrences:

T(n + 1) = T(n) + 1

linear

T(n + 1) = T(n) + n

quadratic

T(n) = T(n/2) + 1

logarithmic

❚♦ ❛♥❛❧②③❡ ❛ ❢✉♥❝t✐♦♥✱ ✐♥s♣❡❝t ✐ts ▼▲ ❞❡❝❧❛r❛t✐♦♥✳ ❘❡❝✉rr❡♥❝❡ ❡q✉❛t✐♦♥s ❢♦r t❤❡ ❝♦st ❢✉♥❝t✐♦♥ T(n) ❝❛♥ ✉s✉❛❧❧② ❜❡ r❡❛❞ ♦✛✳ ❙✐♥❝❡ ✇❡ ✐❣♥♦r❡ ❝♦♥st❛♥t ❢❛❝t♦rs✱ ✇❡ ❝❛♥ ❣✐✈❡ t❤❡ ❜❛s❡ ❝❛s❡ ❛ ❝♦st ♦❢ ♦♥❡ ✉♥✐t✳ ❈♦♥st❛♥t ✇♦r❦ ❞♦♥❡ ✐♥ t❤❡ r❡❝✉rs✐✈❡ st❡♣ ❝❛♥ ❛❧s♦ ❜❡ ❣✐✈❡♥ ✉♥✐t ❝♦st❀ s✐♥❝❡ ✇❡ ♦♥❧② ♥❡❡❞ ❛♥ ✉♣♣❡r ❜♦✉♥❞✱ t❤✐s ✉♥✐t r❡♣r❡s❡♥ts t❤❡ ❧❛r❣❡r ♦❢ t❤❡ t✇♦ ❛❝t✉❛❧ ❝♦sts✳ ❲❡ ❝♦✉❧❞ ✉s❡ ♦t❤❡r ❝♦♥st❛♥ts ✐❢ ✐t s✐♠♣❧✐✜❡s t❤❡ ❛❧❣❡❜r❛✳ ❋♦r ❡①❛♠♣❧❡✱ r❡❝❛❧❧ ♦✉r ❢✉♥❝t✐♦♥ ♥s✉♠✿

❢✉♥ ♥s✉♠ ♥ ❂ ✐❢ ♥❂✵ t❤❡♥ ✵ ❡❧s❡ ♥ ✰ ♥s✉♠ ✭♥✲✶✮❀

• ✐✈❡♥ n + 1✱ ✐t ♣❡r❢♦r♠s ❛ ❝♦♥st❛♥t ❛♠♦✉♥t ♦❢ ✇♦r❦ ✭❛♥ ❛❞❞✐t✐♦♥ ❛♥❞ s✉❜✲

tr❛❝t✐♦♥✮ ❛♥❞ ❝❛❧❧s ✐ts❡❧❢ r❡❝✉rs✐✈❡❧② ✇✐t❤ ❛r❣✉♠❡♥t n✳ ❲❡ ❣❡t t❤❡ r❡❝✉rr❡♥❝❡ ❡q✉❛t✐♦♥s T(0) = 1 ❛♥❞ T(n + 1) = T(n) + 1✳ ❚❤❡ ❝❧♦s❡❞ ❢♦r♠ ✐s ❝❧❡❛r❧② T(n) = n + 1✱ ❛s ✇❡ ❝❛♥ ❡❛s✐❧② ✈❡r✐❢② ❜② s✉❜st✐t✉t✐♦♥✳ ❚❤❡ ❝♦st ✐s ❧✐♥❡❛r✳ ❚❤✐s ❢✉♥❝t✐♦♥✱ ❣✐✈❡♥ n + 1✱ ❝❛❧❧s ♥s✉♠✱ ♣❡r❢♦r♠✐♥❣ O(n) ✇♦r❦✳ ❆❣❛✐♥ ✐❣♥♦r✐♥❣ ❝♦♥st❛♥t ❢❛❝t♦rs✱ ✇❡ ❝❛♥ s❛② t❤❛t t❤✐s ❝❛❧❧ t❛❦❡s ❡①❛❝t❧② n ✉♥✐ts✳

❢✉♥ ♥s✉♠s✉♠ ♥ ❂ ✐❢ ♥❂✵ t❤❡♥ ✵ ❡❧s❡ ♥s✉♠ ♥ ✰ ♥s✉♠s✉♠ ✭♥✲✶✮❀

❲❡ ❣❡t t❤❡ r❡❝✉rr❡♥❝❡ ❡q✉❛t✐♦♥s T(0) = 1 ❛♥❞ T(n + 1) = T(n) + n✳ ■t ✐s ❡❛s② t♦ s❡❡ t❤❛t T(n) = (n − 1) + · · · + 1 = n(n − 1)/2 = O(n2)✳ ❚❤❡ ❝♦st ✐s q✉❛❞r❛t✐❝✳ ❚❤❡ ❢✉♥❝t✐♦♥ ♣♦✇❡r ❞✐✈✐❞❡s ✐ts ✐♥♣✉t n ✐♥t♦ t✇♦✱ ✇✐t❤ t❤❡ r❡❝✉rr❡♥❝❡ ❡q✉❛t✐♦♥ T(n) = T(n/2) + 1✳ ❈❧❡❛r❧② T(2n) = n + 1✱ s♦ T(n) = O(log n)✳

■■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✸✸

Slide 309

Recurrence for nthApprox: O(2n) T(0) = 1 T(n + 1) = 2T(n) + 1

Explicit solution: T(n) = 2n+1 − 1

T(n + 1) = 2T(n) + 1 = 2(2n+1 − 1) + 1

induction hypothesis

= 2n+2 − 1 ◆♦✇ ✇❡ ❛♥❛❧②③❡ t❤❡ ❢✉♥❝t✐♦♥ ♥t❤❆♣♣r♦① ❣✐✈❡♥ ❛t t❤❡ st❛rt ♦❢ t❤❡ ❧❡❝t✉r❡✳ ❚❤❡ t✇♦ r❡❝✉rs✐✈❡ ❝❛❧❧s ❛r❡ r❡✢❡❝t❡❞ ✐♥ t❤❡ t❡r♠ 2T(n) ♦❢ t❤❡ r❡❝✉rr❡♥❝❡✳ ❆s ❢♦r t❤❡ ❝♦♥st❛♥t ❡✛♦rt✱ ❛❧t❤♦✉❣❤ t❤❡ r❡❝✉rs✐✈❡ ❝❛s❡ ❞♦❡s ♠♦r❡ ✇♦r❦ t❤❛♥ t❤❡ ❜❛s❡ ❝❛s❡✱ ✇❡ ❝❛♥ ❝❤♦♦s❡ ✉♥✐ts s✉❝❤ t❤❛t ❜♦t❤ ❝♦♥st❛♥ts ❛r❡ ♦♥❡✳ ✭❘❡♠❡♠❜❡r✱ ✇❡ s❡❡❦ ❛♥ ✉♣♣❡r ❜♦✉♥❞ r❛t❤❡r t❤❛♥ t❤❡ ❡①❛❝t ❝♦st✳✮

• ✐✈❡♥ t❤❡ r❡❝✉rr❡♥❝❡ ❡q✉❛t✐♦♥s ❢♦r T(n)✱ ❧❡t ✉s s♦❧✈❡ t❤❡♠✳ ■t ❤❡❧♣s ✐❢ ✇❡

❝❛♥ ❣✉❡ss t❤❡ ❝❧♦s❡❞ ❢♦r♠✱ ✇❤✐❝❤ ✐♥ t❤✐s ❝❛s❡ ♦❜✈✐♦✉s❧② ✐s s♦♠❡t❤✐♥❣ ❧✐❦❡ 2n✳ ❊✈❛❧✉❛t✐♥❣ T(n) ❢♦r n = 0✱ ✶✱ ✷✱ ✸✱ ✳ ✳ ✳ ✱ ✇❡ ❣❡t ✶✱ ✸✱ ✼✱ ✶✺✱ ✳ ✳ ✳ ✳ ❖❜✈✐♦✉s❧② T(n) = 2n+1 − 1✱ ✇❤✐❝❤ ✇❡ ❝❛♥ ❡❛s✐❧② ♣r♦✈❡ ❜② ✐♥❞✉❝t✐♦♥ ♦♥ n✳ ❲❡ ♠✉st ❝❤❡❝❦ t❤❡ ❜❛s❡ ❝❛s❡✿ T(0) = 21 − 1 = 1 ■♥ t❤❡ ✐♥❞✉❝t✐✈❡ st❡♣✱ ❢♦r T(n + 1)✱ ✇❡ ♠❛② ❛ss✉♠❡ ♦✉r ❡q✉❛t✐♦♥ ✐♥ ♦r❞❡r t♦ r❡♣❧❛❝❡ T(n) ❜② 2n+1 − 1✳ ❚❤❡ r❡st ✐s ❡❛s②✳ ❲❡ ❤❛✈❡ ♣r♦✈❡❞ T(n) = O(2n+1 − 1)✱ ❜✉t ♦❜✈✐♦✉s❧② 2n ✐s ❛❧s♦ ❛♥ ✉♣♣❡r ❜♦✉♥❞✿ ✇❡ ♠❛② ❝❤♦♦s❡ t❤❡ ❝♦♥st❛♥t ❢❛❝t♦r t♦ ❜❡ t✇♦✳ ❍❡♥❝❡ T(n) = O(2n)✳ ❚❤❡ ♣r♦♦❢ ❛❜♦✈❡ ✐s r❛t❤❡r ✐♥❢♦r♠❛❧✳ ❚❤❡ ♦rt❤♦❞♦① ✇❛② ♦❢ ♣r♦✈✐♥❣ f(n) = O(g(n)) ✐s t♦ ❢♦❧❧♦✇ t❤❡ ❞❡✜♥✐t✐♦♥ ♦❢ O ♥♦t❛t✐♦♥✳ ❇✉t ❛♥ ✐♥❞✉❝t✐✈❡ ♣r♦♦❢ ♦❢ T(n) ≤ c2n✱ ✉s✐♥❣ t❤❡ ❞❡✜♥✐t✐♦♥ ♦❢ T(n)✱ r✉♥s ✐♥t♦ ❞✐✣❝✉❧t✐❡s✿ t❤✐s ❜♦✉♥❞ ✐s t♦♦ ❧♦♦s❡✳ ❚✐❣❤t❡♥✐♥❣ t❤❡ ❜♦✉♥❞ t♦ T(n) ≤ c2n −1 ❧❡ts t❤❡ ♣r♦♦❢ ❣♦ t❤r♦✉❣❤✳ ❊①❡r❝✐s❡ ✸✳✷ ❚r② t❤❡ ♣r♦♦❢ s✉❣❣❡st❡❞ ❛❜♦✈❡✳ ❲❤❛t ❞♦❡s ✐t s❛② ❛❜♦✉t c❄

■■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✸✹

Slide 310

An O(n log n) Recurrence T(1) = 0 T(n) = 2T(n/2) + n

Proof that T(n) ≤ n lg n:

T(n) ≤ 2(n/2) lg(n/2) + n = n(lg n − 1) + n = n lg n − n + n = n lg n ❚❤✐s r❡❝✉rr❡♥❝❡ ❡q✉❛t✐♦♥ ❛r✐s❡s ✇❤❡♥ ❛ ❢✉♥❝t✐♦♥ ❞✐✈✐❞❡s ✐ts ✐♥♣✉t ✐♥t♦ t✇♦ ❡q✉❛❧ ♣❛rts✱ ❞♦❡s O(n) ✇♦r❦ ❛♥❞ ❛❧s♦ ❝❛❧❧s ✐ts❡❧❢ r❡❝✉rs✐✈❡❧② ♦♥ ❡❛❝❤✳ ❙✉❝❤ ❜❛❧❛♥❝✐♥❣ ✐s ❜❡♥❡✜❝✐❛❧✳ ■♥st❡❛❞ ❞✐✈✐❞✐♥❣ t❤❡ ✐♥♣✉t ✐♥t♦ ✉♥❡q✉❛❧ ♣❛rts ♦❢ s✐③❡s ✶ ❛♥❞ n − 1 ❣✐✈❡s t❤❡ r❡❝✉rr❡♥❝❡ T(n + 1) = T(n) + n✱ ✇❤✐❝❤ ❤❛s q✉❛❞r❛t✐❝ ❝♦♠♣❧❡①✐t②✳ ❙❤♦✇♥ ♦♥ t❤❡ s❧✐❞❡ ✐s t❤❡ r❡s✉❧t ♦❢ s✉❜st✐t✉t✐♥❣ t❤❡ ❝❧♦s❡❞ ❢♦r♠ T(n) = cn lg n ✐♥t♦ t❤❡ ♦r✐❣✐♥❛❧ ❡q✉❛t✐♦♥s✳ ❚❤✐s ✐s ❛♥♦t❤❡r ♣r♦♦❢ ❜② ✐♥❞✉❝t✐♦♥✳ ❚❤❡ ❧❛st st❡♣ ❤♦❧❞s ♣r♦✈✐❞❡❞ c ≥ 1✳ ❙♦♠❡t❤✐♥❣ ✐s ✇r♦♥❣✱ ❤♦✇❡✈❡r✳ ❚❤❡ ❜❛s❡ ❝❛s❡ ❢❛✐❧s✿ ✐❢ n = 1 t❤❡♥ cn lg n = 0✱ ✇❤✐❝❤ ✐s ♥♦t ❛♥ ✉♣♣❡r ❜♦✉♥❞ ❢♦r T(1)✳ ❲❡ ❝♦✉❧❞ ❧♦♦❦ ❢♦r ❛ ♣r❡❝✐s❡ ❝❧♦s❡❞ ❢♦r♠ ❢♦r T(n)✱ ❜✉t ✐t ✐s s✐♠♣❧❡r t♦ r❡❝❛❧❧ t❤❛t O ♥♦t❛t✐♦♥ ❧❡ts ✉s ✐❣♥♦r❡ ❛ ✜♥✐t❡ ♥✉♠❜❡r ♦❢ ❛✇❦✇❛r❞ ❝❛s❡s✳ ❈❤♦♦s✐♥❣ n = 2 ❛♥❞ n = 3 ❛s ❜❛s❡ ❝❛s❡s ❡❧✐♠✐♥❛t❡s n = 1 ❡♥t✐r❡❧② ❢r♦♠ ❝♦♥s✐❞❡r❛t✐♦♥✳ ❚❤❡ ❝♦♥str❛✐♥ts T(2) ≤ 2c lg 2 ❛♥❞ T(3) ≤ 3c lg 3 ❝❛♥ ❜❡ s❛t✐s✜❡❞ ❢♦r c ≥ 2✳ ❙♦ T(n) = O(n log n)✳ ■♥❝✐❞❡♥t❛❧❧②✱ ✐♥ t❤❡s❡ r❡❝✉rr❡♥❝❡s n/2 st❛♥❞s ❢♦r ✐♥t❡❣❡r ❞✐✈✐s✐♦♥✳ ❚♦ ❜❡ ♣r❡❝✐s❡✱ ✇❡ s❤♦✉❧❞ ✐♥❞✐❝❛t❡ tr✉♥❝❛t✐♦♥ t♦ t❤❡ ♥❡①t s♠❛❧❧❡r ✐♥t❡❣❡r ❜② ✇r✐t✐♥❣ ⌊n/2⌋✳ ❖♥❡✲❤❛❧❢ ♦❢ ❛♥ ♦❞❞ ♥✉♠❜❡r ✐s ❣✐✈❡♥ ❜② ⌊(2n+1)/2⌋ = n✳ ❋♦r ❡①❛♠♣❧❡✱ ⌊2.9⌋ = 2✱ ❛♥❞ ⌊n⌋ = n ✐❢ n ✐s ❛♥ ✐♥t❡❣❡r✳

■■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✸✺ ▲❡❛r♥✐♥❣ ❣✉✐❞❡✳ ❋♦r ❛ ❞❡❡♣❡r tr❡❛t♠❡♥t ♦❢ ❝♦♠♣❧❡①✐t②✱ ②♦✉ ♠✐❣❤t ❧♦♦❦ ❛t ❈❤❛♣t❡r ✷ ♦❢ ■♥tr♦❞✉❝t✐♦♥ t♦ ❆❧❣♦r✐t❤♠s ❬✺❪✳ ❊①❡r❝✐s❡ ✸✳✸ ❋✐♥❞ ❛♥ ✉♣♣❡r ❜♦✉♥❞ ❢♦r t❤❡ r❡❝✉rr❡♥❝❡ ❣✐✈❡♥ ❜② T(1) = 1 ❛♥❞ T(n) = 2T(n/2) + 1✳ ❨♦✉ s❤♦✉❧❞ ❜❡ ❛❜❧❡ t♦ ✜♥❞ ❛ t✐❣❤t❡r ❜♦✉♥❞ t❤❛♥ O(n log n)✳ ❊①❡r❝✐s❡ ✸✳✹ Pr♦✈❡ t❤❛t t❤❡ r❡❝✉rr❡♥❝❡ T(n) =

• 1

✐❢ 1 ≤ n < 4 T(⌈n/4⌉) + T(⌊3n/4⌋) + n ✐❢ n ≥ 4 ✐s O(n log n)✳ ❚❤❡ ♥♦t❛t✐♦♥ ⌈x⌉ ♠❡❛♥s tr✉♥❝❛t✐♦♥ t♦ t❤❡ ♥❡①t ❧❛r❣❡r ✐♥t❡❣❡r❀ ❢♦r ❡①❛♠♣❧❡✱ ⌈3.1⌉ = 4✳

■❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✸✻

Slide 401

Lists

[3,5,9]; > [3, 5, 9] : int list it @ [2,10]; > [3, 5, 9, 2, 10] : int list rev [(1,"one"), (2,"two")]; > [(2, "two"), (1, "one")] : (int * string) list

❆ ❧✐st ✐s ❛♥ ♦r❞❡r❡❞ s❡r✐❡s ♦❢ ❡❧❡♠❡♥ts❀ r❡♣❡t✐t✐♦♥s ❛r❡ s✐❣♥✐✜❝❛♥t✳ ❙♦ ❬✸✱✺✱✾❪ ❞✐✛❡rs ❢r♦♠ ❬✺✱✸✱✾❪ ❛♥❞ ❢r♦♠ ❬✸✱✸✱✺✱✾❪✳ ❆❧❧ ❡❧❡♠❡♥ts ♦❢ ❛ ❧✐st ♠✉st ❤❛✈❡ t❤❡ s❛♠❡ t②♣❡✳ ❆❜♦✈❡ ✇❡ s❡❡ ❛ ❧✐st ♦❢ ✐♥t❡❣❡rs ❛♥❞ ❛ ❧✐st ♦❢ ✭✐♥t❡❣❡r✱ str✐♥❣✮ ♣❛✐rs✳ ❖♥❡ ❝❛♥ ❛❧s♦ ❤❛✈❡ ❧✐sts ♦❢ ❧✐sts✱ s✉❝❤ ❛s ❬❬✸❪✱ ❬❪✱ ❬✺✱✻❪❪✱ ✇❤✐❝❤ ❤❛s t②♣❡ ✐♥t ❧✐st ❧✐st✳ ■♥ t❤❡ ❣❡♥❡r❛❧ ❝❛s❡✱ ✐❢ x1✱ ✳ ✳ ✳ ✱ xn ❛❧❧ ❤❛✈❡ t❤❡ s❛♠❡ t②♣❡ ✭s❛② τ✮ t❤❡♥ t❤❡ ❧✐st [x1, . . . , xn] ❤❛s t②♣❡ (τ)list✳ ▲✐sts ❛r❡ t❤❡ s✐♠♣❧❡st ❞❛t❛ str✉❝t✉r❡ t❤❛t ❝❛♥ ❜❡ ✉s❡❞ t♦ ♣r♦❝❡ss ❝♦❧✲ ❧❡❝t✐♦♥s ♦❢ ✐t❡♠s✳ ❈♦♥✈❡♥t✐♦♥❛❧ ❧❛♥❣✉❛❣❡s ✉s❡ ❛rr❛②s✱ ✇❤♦s❡ ❡❧❡♠❡♥ts ❛r❡ ❛❝❝❡ss❡❞ ✉s✐♥❣ s✉❜s❝r✐♣t✐♥❣✿ ❢♦r ❡①❛♠♣❧❡✱ A[i] ②✐❡❧❞s t❤❡ it❤ ❡❧❡♠❡♥t ♦❢ t❤❡ ❛rr❛② A✳ ❙✉❜s❝r✐♣t✐♥❣ ❡rr♦rs ❛r❡ ❛ ❦♥♦✇♥ ❝❛✉s❡ ♦❢ ♣r♦❣r❛♠♠❡r ❣r✐❡❢✱ ❤♦✇✲ ❡✈❡r✱ s♦ ❛rr❛②s s❤♦✉❧❞ ❜❡ r❡♣❧❛❝❡❞ ❜② ❤✐❣❤❡r✲❧❡✈❡❧ ❞❛t❛ str✉❝t✉r❡s ✇❤❡♥❡✈❡r ♣♦ss✐❜❧❡✳ ❚❤❡ ✐♥✜① ♦♣❡r❛t♦r ❅✱ ❝❛❧❧❡❞ ❛♣♣❡♥❞✱ ❝♦♥❝❛t❡♥❛t❡s t✇♦ ❧✐sts✳ ❆❧s♦ ❜✉✐❧t✲✐♥ ✐s r❡✈✱ ✇❤✐❝❤ r❡✈❡rs❡s ❛ ❧✐st✳ ❚❤❡s❡ ❛r❡ ❞❡♠♦♥str❛t❡❞ ✐♥ t❤❡ s❡ss✐♦♥ ❛❜♦✈❡✳

■❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✸✼

Slide 402

The List Primitives

The two kinds of list

nil or [] is the empty list x::l is the list with head x and tail l

List notation

[x1, x2, . . . , xn] ≡ x1

head

:: (x2 :: · · · (xn :: nil))

• tail

❚❤❡ ♦♣❡r❛t♦r ✿✿✱ ❝❛❧❧❡❞ ❝♦♥s ✭❢♦r ❵❝♦♥str✉❝t✬✮✱ ♣✉ts ❛ ♥❡✇ ❡❧❡♠❡♥t ♦♥ t♦ t❤❡ ❤❡❛❞ ♦❢ ❛♥ ❡①✐st✐♥❣ ❧✐st✳ ❲❤✐❧❡ ✇❡ s❤♦✉❧❞ ♥♦t ❜❡ t♦♦ ♣r❡♦❝❝✉♣✐❡❞ ✇✐t❤ ✐♠♣❧❡♠❡♥t❛t✐♦♥ ❞❡t❛✐❧s✱ ✐t ✐s ❡ss❡♥t✐❛❧ t♦ ❦♥♦✇ t❤❛t ✿✿ ✐s ❛♥ O(1) ♦♣❡r❛t✐♦♥✳ ■t ✉s❡s ❝♦♥st❛♥t t✐♠❡ ❛♥❞ s♣❛❝❡✱ r❡❣❛r❞❧❡ss ♦❢ t❤❡ ❧❡♥❣t❤ ♦❢ t❤❡ r❡s✉❧t✐♥❣ ❧✐st✳ ▲✐sts ❛r❡ r❡♣r❡s❡♥t❡❞ ✐♥t❡r♥❛❧❧② ✇✐t❤ ❛ ❧✐♥❦❡❞ str✉❝t✉r❡❀ ❛❞❞✐♥❣ ❛ ♥❡✇ ❡❧❡♠❡♥t t♦ ❛ ❧✐st ♠❡r❡❧② ❤♦♦❦s t❤❡ ♥❡✇ ❡❧❡♠❡♥t t♦ t❤❡ ❢r♦♥t ♦❢ t❤❡ ❡①✐st✐♥❣ str✉❝t✉r❡✳ ▼♦r❡♦✈❡r✱ t❤❛t str✉❝t✉r❡ ❝♦♥t✐♥✉❡s t♦ ❞❡♥♦t❡ t❤❡ s❛♠❡ ❧✐st ❛s ✐t ❞✐❞ ❜❡❢♦r❡❀ t♦ s❡❡ t❤❡ ♥❡✇ ❧✐st✱ ♦♥❡ ♠✉st ❧♦♦❦ ❛t t❤❡ ♥❡✇ ✿✿ ♥♦❞❡ ✭♦r ❝♦♥s ❝❡❧❧✮ ❥✉st ❝r❡❛t❡❞✳ ❍❡r❡ ✇❡ s❡❡ t❤❡ ❡❧❡♠❡♥t ✶ ❜❡✐♥❣ ❝♦♥s❡❞ t♦ t❤❡ ❢r♦♥t ♦❢ t❤❡ ❧✐st ❬✸✱✺✱✾❪✿ :: → · · · :: → :: → :: → nil ↓ ↓ ↓ ↓ 1 3 5 9

• ✐✈❡♥ ❛ ❧✐st✱ t❛❦✐♥❣ ✐ts ✜rst ❡❧❡♠❡♥t ✭✐ts ❤❡❛❞✮ ♦r ✐ts ❧✐st ♦❢ r❡♠❛✐♥✐♥❣ ❡❧❡♠❡♥ts

✭✐ts t❛✐❧✮ ❛❧s♦ t❛❦❡s ❝♦♥st❛♥t t✐♠❡✳ ❊❛❝❤ ♦♣❡r❛t✐♦♥ ❥✉st ❢♦❧❧♦✇s ❛ ❧✐♥❦✳ ■♥ t❤❡ ❞✐❛❣r❛♠ ❛❜♦✈❡✱ t❤❡ ✜rst ↓ ❛rr♦✇ ❧❡❛❞s t♦ t❤❡ ❤❡❛❞ ❛♥❞ t❤❡ ❧❡❢t♠♦st → ❛rr♦✇ ❧❡❛❞s t♦ t❤❡ t❛✐❧✳ ❖♥❝❡ ✇❡ ❤❛✈❡ t❤❡ t❛✐❧✱ ✐ts ❤❡❛❞ ✐s t❤❡ s❡❝♦♥❞ ❡❧❡♠❡♥t ♦❢ t❤❡ ♦r✐❣✐♥❛❧ ❧✐st✱ ❡t❝✳ ❚❤❡ t❛✐❧ ✐s ♥♦t t❤❡ ❧❛st ❡❧❡♠❡♥t❀ ✐t ✐s t❤❡ ❧✐st ♦❢ ❛❧❧ ❡❧❡♠❡♥ts ♦t❤❡r t❤❛♥ t❤❡ ❤❡❛❞✦

■❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✸✽

Slide 403

Getting at the Head and Tail

fun null [] = true | null (x::l) = false; > val null = fn : ’a list -> bool fun hd (x::l) = x; > Warning: pattern matching is not exhaustive > val hd = fn : ’a list -> ’a tl [7,6,5]; > val it = [6, 5] : int list

❚❤❡r❡ ❛r❡ t❤r❡❡ ❜❛s✐❝ ❢✉♥❝t✐♦♥s ❢♦r ✐♥s♣❡❝t✐♥❣ ❧✐sts✳ ◆♦t❡ t❤❡✐r ♣♦❧②♠♦r✲ ♣❤✐❝ t②♣❡s✦

♥✉❧❧ ✿ ✬❛ ❧✐st ✲❃ ❜♦♦❧ ✐s ❛ ❧✐st ❡♠♣t②❄ ❤❞ ✿ ✬❛ ❧✐st ✲❃ ✬❛ ❤❡❛❞ ♦❢ ❛ ♥♦♥✲❡♠♣t② ❧✐st t❧ ✿ ✬❛ ❧✐st ✲❃ ✬❛ ❧✐st t❛✐❧ ♦❢ ❛ ♥♦♥✲❡♠♣t② ❧✐st

❚❤❡ ❡♠♣t② ❧✐st ❤❛s ♥❡✐t❤❡r ❤❡❛❞ ♥♦r t❛✐❧✳ ❆♣♣❧②✐♥❣ ❡✐t❤❡r ♦♣❡r❛t✐♦♥ t♦ ♥✐❧ ✐s ❛♥ ❡rr♦r✖str✐❝t❧② s♣❡❛❦✐♥❣✱ ❛♥ ❡①❝❡♣t✐♦♥✳ ❚❤❡ ❢✉♥❝t✐♦♥ ♥✉❧❧ ❝❛♥ ❜❡ ✉s❡❞ t♦ ❝❤❡❝❦ ❢♦r t❤❡ ❡♠♣t② ❧✐st ❜❡❢♦r❡ ❛♣♣❧②✐♥❣ ❤❞ ♦r t❧✳ ❚♦ ❧♦♦❦ ❞❡❡♣ ✐♥s✐❞❡ ❛ ❧✐st ♦♥❡ ❝❛♥ ❛♣♣❧② ❝♦♠❜✐♥❛t✐♦♥s ♦❢ t❤❡s❡ ❢✉♥❝t✐♦♥s✱ ❜✉t t❤✐s st②❧❡ ✐s ❤❛r❞ t♦ r❡❛❞✳ ❋♦rt✉♥❛t❡❧②✱ ✐t ✐s s❡❧❞♦♠ ♥❡❝❡ss❛r② ❜❡❝❛✉s❡ ♦❢ ♣❛tt❡r♥✲♠❛t❝❤✐♥❣✳ ❚❤❡ ❞❡❝❧❛r❛t✐♦♥ ♦❢ ♥✉❧❧ ❛❜♦✈❡ ❤❛s t✇♦ ❝❧❛✉s❡s✿ ♦♥❡ ❢♦r t❤❡ ❡♠♣t② ❧✐st ✭❢♦r ✇❤✐❝❤ ✐t r❡t✉r♥s tr✉❡✮ ❛♥❞ ♦♥❡ ❢♦r ♥♦♥✲❡♠♣t② ❧✐sts ✭❢♦r ✇❤✐❝❤ ✐t r❡t✉r♥s ❢❛❧s❡✮✳ ❚❤❡ ❞❡❝❧❛r❛t✐♦♥ ♦❢ ❤❞ ❛❜♦✈❡ ❤❛s ♦♥❧② ♦♥❡ ❝❧❛✉s❡✱ ❢♦r ♥♦♥✲❡♠♣t② ❧✐sts✳ ❚❤❡② ❤❛✈❡ t❤❡ ❢♦r♠ ①✿✿❧ ❛♥❞ t❤❡ ❢✉♥❝t✐♦♥ r❡t✉r♥s ①✱ ✇❤✐❝❤ ✐s t❤❡ ❤❡❛❞✳ ▼▲ ♣r✐♥ts ❛ ✇❛r♥✐♥❣ t♦ t❡❧❧ ✉s t❤❛t ❝❛❧❧✐♥❣ t❤❡ ❢✉♥❝t✐♦♥ ❝♦✉❧❞ r❛✐s❡ ❡①❝❡♣t✐♦♥ ▼❛t❝❤✱ ✇❤✐❝❤ ✐♥❞✐❝❛t❡s ❢❛✐❧✉r❡ ♦❢ ♣❛tt❡r♥✲♠❛t❝❤✐♥❣✳ ❚❤❡ ❞❡❝❧❛r❛t✐♦♥ ♦❢ t❧ ✐s ♦♠✐tt❡❞ ❜❡❝❛✉s❡ ✐t ✐s s✐♠✐❧❛r t♦ ❤❞✳ ■♥st❡❛❞✱ t❤❡r❡ ✐s ❛♥ ❡①❛♠♣❧❡ ♦❢ ❛♣♣❧②✐♥❣ t❧✳

■❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✸✾

Slide 404

Computing the Length of a List

fun nlength [] = 0 | nlength (x::xs) = 1 + nlength xs; > val nlength = fn: ’a list -> int

nlength[a, b, c] ⇒ 1 + nlength[b, c] ⇒ 1 + (1 + nlength[c]) ⇒ 1 + (1 + (1 + nlength[])) ⇒ 1 + (1 + (1 + 0)) ⇒ . . . ⇒ 3 ▼♦st ❧✐st ♣r♦❝❡ss✐♥❣ ✐♥✈♦❧✈❡s r❡❝✉rs✐♦♥✳ ❚❤✐s ✐s ❛ s✐♠♣❧❡ ❡①❛♠♣❧❡❀ ♣❛tt❡r♥s ❝❛♥ ❜❡ ♠♦r❡ ❝♦♠♣❧❡①✳ ❖❜s❡r✈❡ t❤❡ ✉s❡ ♦❢ ❛ ✈❡rt✐❝❛❧ ❜❛r ✭⑤✮ t♦ s❡♣❛r❛t❡ t❤❡ ❢✉♥❝t✐♦♥✬s ❝❧❛✉s❡s✳ ❲❡ ❤❛✈❡ ♦♥❡ ❢✉♥❝t✐♦♥ ❞❡❝❧❛r❛t✐♦♥ t❤❛t ❤❛♥❞❧❡s t✇♦ ❝❛s❡s✳ ❚♦ ✉♥❞❡rst❛♥❞ ✐ts r♦❧❡✱ ❝♦♥s✐❞❡r t❤❡ ❢♦❧❧♦✇✐♥❣ ❢❛✉❧t② ❝♦❞❡✿

❢✉♥ ♥❧❡♥❣t❤ ❬❪ ❂ ✵❀ ❃ ❲❛r♥✐♥❣✿ ♣❛tt❡r♥ ♠❛t❝❤✐♥❣ ✐s ♥♦t ❡①❤❛✉st✐✈❡ ❃ ✈❛❧ ♥❧❡♥❣t❤ ❂ ❢♥✿ ✬❛ ❧✐st ✲❃ ✐♥t ❢✉♥ ♥❧❡♥❣t❤ ✭①✿✿①s✮ ❂ ✶ ✰ ♥❧❡♥❣t❤ ①s❀ ❃ ❲❛r♥✐♥❣✿ ♣❛tt❡r♥ ♠❛t❝❤✐♥❣ ✐s ♥♦t ❡①❤❛✉st✐✈❡ ❃ ✈❛❧ ♥❧❡♥❣t❤ ❂ ❢♥✿ ✬❛ ❧✐st ✲❃ ✐♥t

❚❤❡s❡ ❛r❡ t✇♦ ❞❡❝❧❛r❛t✐♦♥s✱ ♥♦t ♦♥❡✳ ❋✐rst ✇❡ ❞❡❝❧❛r❡ ♥❧❡♥❣t❤ t♦ ❜❡ ❛ ❢✉♥❝✲ t✐♦♥ t❤❛t ❤❛♥❞❧❡s ♦♥❧② ❡♠♣t② ❧✐sts✳ ❚❤❡♥ ✇❡ r❡❞❡❝❧❛r❡ ✐t t♦ ❜❡ ❛ ❢✉♥❝t✐♦♥ t❤❛t ❤❛♥❞❧❡s ♦♥❧② ♥♦♥✲❡♠♣t② ❧✐sts❀ ✐t ❝❛♥ ♥❡✈❡r ❞❡❧✐✈❡r ❛ r❡s✉❧t✳ ❲❡ s❡❡ t❤❛t ❛ s❡❝♦♥❞ ❢✉♥ ❞❡❝❧❛r❛t✐♦♥ r❡♣❧❛❝❡s ❛♥② ♣r❡✈✐♦✉s ♦♥❡ r❛t❤❡r t❤❛♥ ❡①t❡♥❞✐♥❣ ✐t t♦ ❝♦✈❡r ♥❡✇ ❝❛s❡s✳ ◆♦✇✱ ❧❡t ✉s r❡t✉r♥ t♦ t❤❡ ❞❡❝❧❛r❛t✐♦♥ s❤♦✇♥ ♦♥ t❤❡ s❧✐❞❡✳ ❚❤❡ ❧❡♥❣t❤ ❢✉♥❝t✐♦♥ ✐s ♣♦❧②♠♦r♣❤✐❝✿ ✐t ❛♣♣❧✐❡s t♦ ❛❧❧ ❧✐sts r❡❣❛r❞❧❡ss ♦❢ ❡❧❡♠❡♥t t②♣❡✦ ▼♦st ♣r♦❣r❛♠♠✐♥❣ ❧❛♥❣✉❛❣❡s ❧❛❝❦ s✉❝❤ ✢❡①✐❜✐❧✐t②✳ ❯♥❢♦rt✉♥❛t❡❧②✱ t❤✐s ❧❡♥❣t❤ ❝♦♠♣✉t❛t✐♦♥ ✐s ♥❛ï✈❡ ❛♥❞ ✇❛st❡❢✉❧✳ ▲✐❦❡ ♥s✉♠ ✐♥ ▲❡❝t✳ ✷✱ ✐t ✐s ♥♦t t❛✐❧✲r❡❝✉rs✐✈❡✳ ■t ✉s❡s O(n) s♣❛❝❡✱ ✇❤❡r❡ n ✐s t❤❡ ❧❡♥❣t❤ ♦❢ ✐ts ✐♥♣✉t✳ ❆s ✉s✉❛❧✱ t❤❡ s♦❧✉t✐♦♥ ✐s t♦ ❛❞❞ ❛♥ ❛❝❝✉♠✉❧❛t✐♥❣ ❛r❣✉♠❡♥t✳

■❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✹✵

Slide 405

Efficiently Computing the Length of a List

fun addlen (n, [ ]) = n | addlen (n, x::xs) = addlen (n+1, xs); > val addlen = fn: int * ’a list -> int

addlen(0, [a, b, c]) ⇒ addlen(1, [b, c]) ⇒ addlen(2, [c]) ⇒ addlen(3, []) ⇒ 3 P❛tt❡r♥s ❝❛♥ ❜❡ ❛s ❝♦♠♣❧✐❝❛t❡❞ ❛s ✇❡ ❧✐❦❡✳ ❍❡r❡✱ t❤❡ t✇♦ ♣❛tt❡r♥s ❛r❡ ✭♥✱❬❪✮ ❛♥❞ ✭♥✱①✿✿①s✮✳ ❋✉♥❝t✐♦♥ ❛❞❞❧❡♥ ✐s ❛❣❛✐♥ ♣♦❧②♠♦r♣❤✐❝✳ ■ts t②♣❡ ♠❡♥t✐♦♥s t❤❡ ✐♥t❡❣❡r ❛❝❝✉♠✉❧❛t♦r✳ ◆♦✇ ✇❡ ♠❛② ❞❡❝❧❛r❡ ❛♥ ❡✣❝✐❡♥t ❧❡♥❣t❤ ❢✉♥❝t✐♦♥✳ ■t ✐s s✐♠♣❧② ❛ ✇r❛♣♣❡r ❢♦r ❛❞❞❧❡♥✱ s✉♣♣❧②✐♥❣ ③❡r♦ ❛s t❤❡ ✐♥✐t✐❛❧ ✈❛❧✉❡ ♦❢ ♥✳

❢✉♥ ❧❡♥❣t❤ ①s ❂ ❛❞❞❧❡♥✭✵✱①s✮❀ ❃ ✈❛❧ ❧❡♥❣t❤ ❂ ❢♥ ✿ ✬❛ ❧✐st ✲❃ ✐♥t

❚❤❡ r❡❝✉rs✐✈❡ ❝❛❧❧s ❞♦ ♥♦t ♥❡st✿ t❤✐s ✈❡rs✐♦♥ ✐s ✐t❡r❛t✐✈❡✳ ■t t❛❦❡s O(1) s♣❛❝❡✳ ❖❜✈✐♦✉s❧② ✐ts t✐♠❡ r❡q✉✐r❡♠❡♥t ✐s O(n) ❜❡❝❛✉s❡ ✐t t❛❦❡s ❛t ❧❡❛st n st❡♣s t♦ ✜♥❞ t❤❡ ❧❡♥❣t❤ ♦❢ ❛♥ n✲❡❧❡♠❡♥t ❧✐st✳

■❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✹✶

Slide 406

Append: List Concatenation

fun append([], ys) = ys | append(x::xs, ys) = x :: append(xs,ys); > val append = fn: ’a list * ’a list -> ’a list

append([1, 2, 3], [4]) ⇒ 1 :: append([2, 3], [4]) ⇒ 1 :: (2 :: append([3], [4])) ⇒ 1 :: (2 :: (3 :: append([], [4]))) ⇒ 1 :: (2 :: (3 :: [4])) ⇒ [1, 2, 3, 4] ❍❡r❡ ✐s ❤♦✇ ❛♣♣❡♥❞ ♠✐❣❤t ❜❡ ❞❡❝❧❛r❡❞✱ ✐❣♥♦r✐♥❣ t❤❡ ❞❡t❛✐❧s ♦❢ ❤♦✇ ❅ ✐s ♠❛❞❡ ❛♥ ✐♥✜① ♦♣❡r❛t♦r✳ ❚❤✐s ❢✉♥❝t✐♦♥ ✐s ❛❧s♦ ♥♦t ✐t❡r❛t✐✈❡✳ ■t s❝❛♥s ✐ts ✜rst ❛r❣✉♠❡♥t✱ s❡ts ✉♣ ❛ str✐♥❣ ♦❢ ❵❝♦♥s✬ ♦♣❡r❛t✐♦♥s ✭✿✿✮ ❛♥❞ ✜♥❛❧❧② ❞♦❡s t❤❡♠✳ ■t ✉s❡s O(n) s♣❛❝❡ ❛♥❞ t✐♠❡✱ ✇❤❡r❡ n ✐s t❤❡ ❧❡♥❣t❤ ♦❢ ✐ts ✜rst ❛r❣✉♠❡♥t✳ ■ts ❝♦sts ❛r❡ ✐♥❞❡♣❡♥❞❡♥t ♦❢ ✐ts s❡❝♦♥❞ ❛r❣✉♠❡♥t✳ ❆♥ ❛❝❝✉♠✉❧❛t✐♥❣ ❛r❣✉♠❡♥t ❝♦✉❧❞ ♠❛❦❡ ✐t ✐t❡r❛t✐✈❡✱ ❜✉t ✇✐t❤ ❝♦♥s✐❞❡r✲ ❛❜❧❡ ❝♦♠♣❧✐❝❛t✐♦♥✳ ❚❤❡ ✐t❡r❛t✐✈❡ ✈❡rs✐♦♥ ✇♦✉❧❞ st✐❧❧ r❡q✉✐r❡ O(n) s♣❛❝❡ ❛♥❞ t✐♠❡ ❜❡❝❛✉s❡ ❝♦♥❝❛t❡♥❛t✐♦♥ r❡q✉✐r❡s ❝♦♣②✐♥❣ ❛❧❧ t❤❡ ❡❧❡♠❡♥ts ♦❢ t❤❡ ✜rst ❧✐st✳ ❚❤❡r❡❢♦r❡✱ ✇❡ ❝❛♥♥♦t ❤♦♣❡ ❢♦r ❛s②♠♣t♦t✐❝ ❣❛✐♥s❀ ❛t ❜❡st ✇❡ ❝❛♥ ❞❡❝r❡❛s❡ t❤❡ ❝♦♥st❛♥t ❢❛❝t♦r ✐♥✈♦❧✈❡❞ ✐♥ O(n)✱ ❜✉t ❝♦♠♣❧✐❝❛t✐♥❣ t❤❡ ❝♦❞❡ ✐s ❧✐❦❡❧② t♦ ✐♥❝r❡❛s❡ t❤❛t ❢❛❝t♦r✳ ◆❡✈❡r ❛❞❞ ❛♥ ❛❝❝✉♠✉❧❛t♦r ♠❡r❡❧② ♦✉t ♦❢ ❤❛❜✐t✳ ◆♦t❡ ❛♣♣❡♥❞✬s ♣♦❧②♠♦r♣❤✐❝ t②♣❡✳ ❚✇♦ ❧✐sts ❝❛♥ ❜❡ ❥♦✐♥❡❞ ✐❢ t❤❡✐r ❡❧❡♠❡♥t t②♣❡s ❛❣r❡❡✳

■❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✹✷

Slide 407

Reversing a List in O(n2)

fun nrev [] = [] | nrev(x::xs) = (nrev xs) @ [x]; > val nrev = fn: ’a list -> ’a list

nrev[a, b, c] ⇒ nrev[b, c] @ [a] ⇒ (nrev[c] @ [b]) @ [a] ⇒ ((nrev[] @ [c]) @ [b]) @ [a] ⇒ (([] @ [c]) @ [b]) @ [a] ⇒ . . . ⇒ [c, b, a] ❚❤✐s r❡✈❡rs❡ ❢✉♥❝t✐♦♥ ✐s ❣r♦ss❧② ✐♥❡✣❝✐❡♥t ❞✉❡ t♦ ♣♦♦r ✉s❛❣❡ ♦❢ ❛♣♣❡♥❞✱ ✇❤✐❝❤ ❝♦♣✐❡s ✐ts ✜rst ❛r❣✉♠❡♥t✳ ■❢ ♥r❡✈ ✐s ❣✐✈❡♥ ❛ ❧✐st ♦❢ ❧❡♥❣t❤ n > 0✱ t❤❡♥ ❛♣♣❡♥❞ ♠❛❦❡s n − 1 ❝♦♥s❡s t♦ ❝♦♣② t❤❡ r❡✈❡rs❡❞ t❛✐❧✳ ❈♦♥str✉❝t✐♥❣ t❤❡ ❧✐st ❬①❪ ❝❛❧❧s ❝♦♥s ❛❣❛✐♥✱ ❢♦r ❛ t♦t❛❧ ♦❢ n ❝❛❧❧s✳ ❘❡✈❡rs✐♥❣ t❤❡ t❛✐❧ r❡q✉✐r❡s n − 1 ♠♦r❡ ❝♦♥s❡s✱ ❛♥❞ s♦ ❢♦rt❤✳ ❚❤❡ t♦t❛❧ ♥✉♠❜❡r ♦❢ ❝♦♥s❡s ✐s 0 + 1 + 2 + · · · + n = n(n + 1)/2. ❚❤❡ t✐♠❡ ❝♦♠♣❧❡①✐t② ✐s t❤❡r❡❢♦r❡ O(n2)✳ ❙♣❛❝❡ ❝♦♠♣❧❡①✐t② ✐s ♦♥❧② O(n) ❜❡❝❛✉s❡ t❤❡ ❝♦♣✐❡s ❞♦♥✬t ❛❧❧ ❡①✐st ❛t t❤❡ s❛♠❡ t✐♠❡✳

■❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✹✸

Slide 408

Reversing a List in O(n)

fun revApp ([], ys) = ys | revApp (x::xs, ys) = revApp (xs, x::ys); > val revApp = fn: ’a list * ’a list -> ’a list

revApp([a, b, c], []) ⇒ revApp([b, c], [a]) ⇒ revApp([c], [b, a]) ⇒ revApp([], [c, b, a]) ⇒ [c, b, a] ❈❛❧❧✐♥❣ r❡✈❆♣♣ ✭①s✱②s✮ r❡✈❡rs❡s t❤❡ ❡❧❡♠❡♥ts ♦❢ ①s ❛♥❞ ♣r❡♣❡♥❞s t❤❡♠ t♦ ②s✳ ◆♦✇ ✇❡ ♠❛② ❞❡❝❧❛r❡

❢✉♥ r❡✈ ①s ❂ r❡✈❆♣♣✭①s✱❬❪✮❀ ❃ ✈❛❧ r❡✈ ❂ ❢♥ ✿ ✬❛ ❧✐st ✲❃ ✬❛ ❧✐st

■t ✐s ❡❛s② t♦ s❡❡ t❤❛t t❤✐s r❡✈❡rs❡ ❢✉♥❝t✐♦♥ ♣❡r❢♦r♠s ❥✉st n ❝♦♥s❡s✱ ❣✐✈❡♥ ❛♥ n✲❡❧❡♠❡♥t ❧✐st✳ ❋♦r ❜♦t❤ r❡✈❡rs❡ ❢✉♥❝t✐♦♥s✱ ✇❡ ❝♦✉❧❞ ❝♦✉♥t t❤❡ ♥✉♠❜❡r ♦❢ ❝♦♥s❡s ♣r❡❝✐s❡❧②✖♥♦t ❥✉st ✉♣ t♦ ❛ ❝♦♥st❛♥t ❢❛❝t♦r✳ O ♥♦t❛t✐♦♥ ✐s st✐❧❧ ✉s❡❢✉❧ t♦ ❞❡s❝r✐❜❡ t❤❡ ♦✈❡r❛❧❧ r✉♥♥✐♥❣ t✐♠❡✿ t❤❡ t✐♠❡ t❛❦❡♥ ❜② ❛ ❝♦♥s ✈❛r✐❡s ❢r♦♠ ♦♥❡ s②st❡♠ t♦ ❛♥♦t❤❡r✳ ❚❤❡ ❛❝❝✉♠✉❧❛t♦r y ♠❛❦❡s t❤❡ ❢✉♥❝t✐♦♥ ✐t❡r❛t✐✈❡✳ ❇✉t t❤❡ ❣❛✐♥ ✐♥ ❝♦♠✲ ♣❧❡①✐t② ❛r✐s❡s ❢r♦♠ t❤❡ r❡♠♦✈❛❧ ♦❢ ❛♣♣❡♥❞✳ ❘❡♣❧❛❝✐♥❣ ❛♥ ❡①♣❡♥s✐✈❡ ♦♣❡r❛t✐♦♥ ✭❛♣♣❡♥❞✮ ❜② ❛ s❡r✐❡s ♦❢ ❝❤❡❛♣ ♦♣❡r❛t✐♦♥s ✭❝♦♥s✮ ✐s ❝❛❧❧❡❞ r❡❞✉❝t✐♦♥ ✐♥ str❡♥❣t❤✱ ❛♥❞ ✐s ❛ ❝♦♠♠♦♥ t❡❝❤♥✐q✉❡ ✐♥ ❝♦♠♣✉t❡r s❝✐❡♥❝❡✳ ■t ♦r✐❣✐♥❛t❡❞ ✇❤❡♥ ♠❛♥② ❝♦♠♣✉t❡rs ❞✐❞ ♥♦t ❤❛✈❡ ❛ ❤❛r❞✇❛r❡ ♠✉❧t✐♣❧② ✐♥str✉❝t✐♦♥❀ t❤❡ s❡r✐❡s ♦❢ ♣r♦❞✲ ✉❝ts i × r ❢♦r i = 0✱ ✳ ✳ ✳ ✱ n ❝♦✉❧❞ ♠♦r❡ ❡✣❝✐❡♥t❧② ❜❡ ❝♦♠♣✉t❡❞ ❜② r❡♣❡❛t❡❞ ❛❞❞✐t✐♦♥✳ ❘❡❞✉❝t✐♦♥ ✐♥ str❡♥❣t❤ ❝❛♥ ❜❡ ❞♦♥❡ ✐♥ ✈❛r✐♦✉s ✇❛②s❀ ✇❡ s❤❛❧❧ s❡❡ ♠❛♥② ✐♥st❛♥❝❡s ♦❢ r❡♠♦✈✐♥❣ ❛♣♣❡♥❞✳ ❈♦♥s✐♥❣ t♦ ❛♥ ❛❝❝✉♠✉❧❛t♦r ♣r♦❞✉❝❡s t❤❡ r❡s✉❧t ✐♥ r❡✈❡rs❡✳ ■❢ t❤❛t ❢♦r❝❡s t❤❡ ✉s❡ ♦❢ ❛♥ ❡①tr❛ ❧✐st r❡✈❡rs❛❧ t❤❡♥ t❤❡ ✐t❡r❛t✐✈❡ ❢✉♥❝t✐♦♥ ♠❛② ❜❡ ♠✉❝❤ s❧♦✇❡r t❤❛♥ t❤❡ r❡❝✉rs✐✈❡ ♦♥❡✳

■❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✹✹

Slide 409

Lists, Strings and Characters

character constants

#"A" #"\""

. . . string constants

"" "B" "Oh, no!"

. . .

explode(s)

list of the characters in string s

implode(l)

string made of the characters in list l

size(s)

number of chars in string s

s1^s2

concatenation of strings s1 and s2

❙tr✐♥❣s ❛r❡ ♣r♦✈✐❞❡❞ ✐♥ ♠♦st ♣r♦❣r❛♠♠✐♥❣ ❧❛♥❣✉❛❣❡s t♦ ❛❧❧♦✇ t❡①t ♣r♦✲ ❝❡ss✐♥❣✳ ❆t ❛ ❜❛r❡ ♠✐♥✐♠✉♠✱ ♥✉♠❜❡rs ♠✉st ❜❡ ❝♦♥✈❡rt❡❞ t♦ ♦r ❢r♦♠ ❛ t❡①t✉❛❧ r❡♣r❡s❡♥t❛t✐♦♥✳ Pr♦❣r❛♠s ✐ss✉❡ t❡①t✉❛❧ ♠❡ss❛❣❡s t♦ ✉s❡rs ❛♥❞ ❛♥❛❧②③❡ t❤❡✐r r❡s♣♦♥s❡s✳ ❙tr✐♥❣s ❛r❡ ❡ss❡♥t✐❛❧ ✐♥ ♣r❛❝t✐❝❡✱ ❜✉t t❤❡② ❜r✐♥❣ ✉♣ ❢❡✇ ✐ss✉❡s r❡❧❡✈❛♥t t♦ t❤✐s ❝♦✉rs❡✳ ❚❤❡ ❢✉♥❝t✐♦♥s ❡①♣❧♦❞❡ ❛♥❞ ✐♠♣❧♦❞❡ ❝♦♥✈❡rt ❜❡t✇❡❡♥ str✐♥❣s ❛♥❞ ❧✐sts ♦❢ ❝❤❛r❛❝t❡rs✳ ■♥ ❛ ❢❡✇ ♣r♦❣r❛♠♠✐♥❣ ❧❛♥❣✉❛❣❡s✱ str✐♥❣s s✐♠♣❧② ❛r❡ ❧✐sts ♦❢ ❝❤❛r✲ ❛❝t❡rs✱ ❜✉t t❤✐s ✐s ♣♦♦r ❞❡s✐❣♥✳ ❙tr✐♥❣s ❛r❡ ❛♥ ❛❜str❛❝t ❝♦♥❝❡♣t ✐♥ t❤❡♠s❡❧✈❡s✳ ❚r❡❛t✐♥❣ t❤❡♠ ❛s ❧✐sts ❧❡❛❞s t♦ ❝❧✉♠s② ❛♥❞ ✐♥❡✣❝✐❡♥t ❝♦❞❡✳ ❙✐♠✐❧❛r❧②✱ ❝❤❛r❛❝t❡rs ❛r❡ ♥♦t str✐♥❣s ♦❢ s✐③❡ ♦♥❡✱ ❜✉t ❛r❡ ❛ ♣r✐♠✐t✐✈❡ ❝♦♥✲ ❝❡♣t✳ ❈❤❛r❛❝t❡r ❝♦♥st❛♥ts ✐♥ ▼▲ ❤❛✈❡ t❤❡ ❢♦r♠ ★✧c✧✱ ✇❤❡r❡ c ✐s ❛♥② ❝❤❛r❛❝✲ t❡r✳ ❋♦r ❡①❛♠♣❧❡✱ t❤❡ ❝♦♠♠❛ ❝❤❛r❛❝t❡r ✐s ★✧✱✧✳ ■♥ ❛❞❞✐t✐♦♥ t♦ t❤❡ ♦♣❡r❛t♦rs ❞❡s❝r✐❜❡❞ ❛❜♦✈❡✱ t❤❡ r❡❧❛t✐♦♥s ❁ ❁❂ ❃ ❃❂ ✇♦r❦ ❢♦r str✐♥❣s ❛♥❞ ②✐❡❧❞ ❛❧♣❤❛❜❡t✐❝ ♦r❞❡r ✭♠♦r❡ ♣r❡❝✐s❡❧②✱ ❧❡①✐❝♦❣r❛♣❤✐❝ ♦r❞❡r ✇✐t❤ r❡s♣❡❝t t♦ ❆❙❈■■ ❝❤❛r❛❝t❡r ❝♦❞❡s✮✳

■❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✹✺ ▲❡❛r♥✐♥❣ ❣✉✐❞❡✳ ❘❡❧❛t❡❞ ♠❛t❡r✐❛❧ ✐s ✐♥ ▼▲ ❢♦r t❤❡ ❲♦r❦✐♥❣ Pr♦❣r❛♠♠❡r✱ ♣❛❣❡s ✻✾✕✽✵✳ ❊①❡r❝✐s❡ ✹✳✶ ❈♦❞❡ ❛ r❡❝✉rs✐✈❡ ❢✉♥❝t✐♦♥ t♦ ❝♦♠♣✉t❡ t❤❡ s✉♠ ♦❢ ❛ ❧✐st✬s ❡❧❡♠❡♥ts✳ ❚❤❡♥ ❝♦❞❡ ❛♥ ✐t❡r❛t✐✈❡ ✈❡rs✐♦♥ ❛♥❞ ❝♦♠♠❡♥t ♦♥ t❤❡ ✐♠♣r♦✈❡♠❡♥t ✐♥ ❡✣❝✐❡♥❝②✳

❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✹✻

Slide 501

List Utilities: take and drop

Removing the first i elements

fun take ([], _) = [] | take (x::xs, i) = if i>0 then x :: take(xs, i-1) else []; fun drop ([], _) = [] | drop (x::xs, i) = if i>0 then drop(xs,i-1) else x::xs;

❚❤✐s ❧❡❝t✉r❡ ❡①❛♠✐♥❡s ♠♦r❡ ❧✐st ✉t✐❧✐t✐❡s✱ ✐❧❧✉str❛t✐♥❣ ♠♦r❡ ♣❛tt❡r♥s ♦❢ r❡❝✉rs✐♦♥✱ ❛♥❞ ❝♦♥❝❧✉❞❡s ✇✐t❤ ❛ s♠❛❧❧ ♣r♦❣r❛♠ ❢♦r ♠❛❦✐♥❣ ❝❤❛♥❣❡✳ ❚❤❡ ❢✉♥❝t✐♦♥s t❛❦❡ ❛♥❞ ❞r♦♣ ❞✐✈✐❞❡ ❛ ❧✐st ✐♥t♦ ♣❛rts✱ r❡t✉r♥✐♥❣ ♦r ❞✐s✲ ❝❛r❞✐♥❣ t❤❡ ✜rst i ❡❧❡♠❡♥ts✳ xs = [x0, . . . , xi−1

• take(xs, i)

, xi, . . . , xn−1

• drop(xs, i)

] ❆♣♣❧✐❝❛t✐♦♥s ♦❢ t❛❦❡ ❛♥❞ ❞r♦♣ ✇✐❧❧ ❛♣♣❡❛r ✐♥ ❢✉t✉r❡ ❧❡❝t✉r❡s✳ ❚②♣✐❝❛❧❧②✱ t❤❡② ❞✐✈✐❞❡ ❛ ❝♦❧❧❡❝t✐♦♥ ♦❢ ✐t❡♠s ✐♥t♦ ❡q✉❛❧ ♣❛rts ❢♦r r❡❝✉rs✐✈❡ ♣r♦❝❡ss✐♥❣✳ ❚❤❡ s♣❡❝✐❛❧ ♣❛tt❡r♥ ✈❛r✐❛❜❧❡ ❴ ❛♣♣❡❛rs ✐♥ ❜♦t❤ ❢✉♥❝t✐♦♥s✳ ❚❤✐s ✇✐❧❞❝❛r❞ ♣❛tt❡r♥ ♠❛t❝❤❡s ❛♥②t❤✐♥❣✳ ❲❡ ❝♦✉❧❞ ❤❛✈❡ ✇r✐tt❡♥ ✐ ✐♥ ❜♦t❤ ♣♦s✐t✐♦♥s✱ ❜✉t t❤❡ ✇✐❧❞❝❛r❞ r❡♠✐♥❞s ✉s t❤❛t t❤❡ r❡❧❡✈❛♥t ❝❧❛✉s❡ ✐❣♥♦r❡s t❤✐s ❛r❣✉♠❡♥t✳ ❋✉♥❝t✐♦♥ t❛❦❡ ✐s ♥♦t ✐t❡r❛t✐✈❡✱ ❜✉t ♠❛❦✐♥❣ ✐t s♦ ✇♦✉❧❞ ♥♦t ✐♠♣r♦✈❡ ✐ts ❡✣❝✐❡♥❝②✳ ❚❤❡ t❛s❦ r❡q✉✐r❡s ❝♦♣②✐♥❣ ✉♣ t♦ i ❧✐st ❡❧❡♠❡♥ts✱ ✇❤✐❝❤ ♠✉st t❛❦❡ O(i) s♣❛❝❡ ❛♥❞ t✐♠❡✳ ❋✉♥❝t✐♦♥ ❞r♦♣ s✐♠♣❧② s❦✐♣s ♦✈❡r i ❧✐st ❡❧❡♠❡♥ts✳ ❚❤✐s r❡q✉✐r❡s O(i) t✐♠❡ ❜✉t ♦♥❧② ❝♦♥st❛♥t s♣❛❝❡✳ ■t ✐s ✐t❡r❛t✐✈❡ ❛♥❞ ♠✉❝❤ ❢❛st❡r t❤❛♥ t❛❦❡✳ ❇♦t❤ ❢✉♥❝t✐♦♥s ✉s❡ O(i) t✐♠❡✱ ❜✉t s❦✐♣♣✐♥❣ ❡❧❡♠❡♥ts ✐s ❢❛st❡r t❤❛♥ ❝♦♣②✐♥❣ t❤❡♠✿ ❞r♦♣✬s ❝♦♥st❛♥t ❢❛❝t♦r ✐s s♠❛❧❧❡r✳ ❇♦t❤ ❢✉♥❝t✐♦♥s t❛❦❡ ❛ ❧✐st ❛♥❞ ❛♥ ✐♥t❡❣❡r✱ r❡t✉r♥✐♥❣ ❛ ❧✐st ♦❢ t❤❡ s❛♠❡ t②♣❡✳ ❙♦ t❤❡✐r t②♣❡ ✐s ✬❛ ❧✐st ✯ ✐♥t ✲❃ ✬❛ ❧✐st✳

❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✹✼

Slide 502

Linear Search

find x in list [x1, . . . , xn] by comparing with each element

• bviously O(n) TIME

simple & general

• rdered searching needs only O(log n)

indexed lookup needs only O(1)

▲✐♥❡❛r s❡❛r❝❤ ✐s t❤❡ ♦❜✈✐♦✉s ✇❛② t♦ ✜♥❞ ❛ ❞❡s✐r❡❞ ✐t❡♠ ✐♥ ❛ ❝♦❧❧❡❝t✐♦♥✿ s✐♠♣❧② ❧♦♦❦ t❤r♦✉❣❤ ❛❧❧ t❤❡ ✐t❡♠s✱ ♦♥❡ ❛t ❛ t✐♠❡✳ ■❢ x ✐s ✐♥ t❤❡ ❧✐st✱ t❤❡♥ ✐t ✇✐❧❧ ❜❡ ❢♦✉♥❞ ✐♥ n/2 st❡♣s ♦♥ ❛✈❡r❛❣❡✱ ❛♥❞ ❡✈❡♥ t❤❡ ✇♦rst ❝❛s❡ ✐s ♦❜✈✐♦✉s❧② O(n)✳ ▲❛r❣❡ ❝♦❧❧❡❝t✐♦♥s ♦❢ ❞❛t❛ ❛r❡ ✉s✉❛❧❧② ♦r❞❡r❡❞ ♦r ✐♥❞❡①❡❞ s♦ t❤❛t ✐t❡♠s ❝❛♥ ❜❡ ❢♦✉♥❞ ✐♥ O(log n) t✐♠❡✱ ✇❤✐❝❤ ✐s ❡①♣♦♥❡♥t✐❛❧❧② ❜❡tt❡r t❤❛♥ O(n)✳ ❊✈❡♥ O(1) ✐s ❛❝❤✐❡✈❛❜❧❡ ✭✉s✐♥❣ ❛ ❤❛s❤ t❛❜❧❡✮✱ t❤♦✉❣❤ s✉❜❥❡❝t t♦ t❤❡ ✉s✉❛❧ ♣r♦✈✐s♦ t❤❛t ♠❛❝❤✐♥❡ ❧✐♠✐ts ❛r❡ ♥♦t ❡①❝❡❡❞❡❞✳ ❊✣❝✐❡♥t ✐♥❞❡①✐♥❣ ♠❡t❤♦❞s ❛r❡ ♦❢ ♣r✐♠❡ ✐♠♣♦rt❛♥❝❡✿ ❝♦♥s✐❞❡r ❲❡❜ s❡❛r❝❤ ❡♥❣✐♥❡s✳ ◆❡✈❡rt❤❡❧❡ss✱ ❧✐♥❡❛r s❡❛r❝❤ ✐s ♦❢t❡♥ ✉s❡❞ t♦ s❡❛r❝❤ s♠❛❧❧ ❝♦❧❧❡❝t✐♦♥s ❜❡❝❛✉s❡ ✐t ✐s s♦ s✐♠♣❧❡ ❛♥❞ ❣❡♥❡r❛❧✱ ❛♥❞ ✐t ✐s t❤❡ st❛rt✐♥❣ ♣♦✐♥t ❢♦r ❜❡tt❡r ❛❧❣♦r✐t❤♠s✳

❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✹✽

Slide 503

Types with Equality

The membership test has a strange polymorphic type.

fun member(x, []) = false | member(x, y::l) = (x=y) orelse member(x,l); > val member = fn : ’’a * ’’a list -> bool

Here, ”a stands for any equality type. Equality testing is OK for integers but NOT for functions.

❆❧❧ t❤❡ ❧✐st ❢✉♥❝t✐♦♥s ✇❡ ❤❛✈❡ ❡♥❝♦✉♥t❡r❡❞ ✉♣ t♦ ♥♦✇ ❤❛✈❡ ❜❡❡♥ ♣♦❧②♠♦r✲ ♣❤✐❝✱ ✇♦r❦✐♥❣ ❢♦r ❧✐sts ♦❢ ❛♥② t②♣❡✳ ❋✉♥❝t✐♦♥ ♠❡♠❜❡r ✉s❡s ❧✐♥❡❛r s❡❛r❝❤ t♦ r❡♣♦rt ✇❤❡t❤❡r ♦r ♥♦t ① ♦❝❝✉rs ✐♥ ❧✳ ■ts ♣♦❧②♠♦r♣❤✐s♠ ✐s r❡str✐❝t❡❞ t♦ t❤❡ s♦✲❝❛❧❧❡❞ ❡q✉❛❧✐t② t②♣❡s✳ ❚❤❡s❡ ✐♥❝❧✉❞❡ ✐♥t❡❣❡rs✱ str✐♥❣s✱ ❜♦♦❧❡❛♥s✱ ❛♥❞ t✉♣❧❡s ♦r ❧✐sts ♦❢ ♦t❤❡r ❡q✉❛❧✐t② t②♣❡s✳ ❊q✉❛❧✐t② t❡st✐♥❣ ✐s ♥♦t ❛✈❛✐❧❛❜❧❡ ❢♦r ❡✈❡r② t②♣❡✱ ❤♦✇❡✈❡r✳ ❋✉♥❝t✐♦♥s ❛r❡ ✈❛❧✉❡s ✐♥ ▼▲✱ ❛♥❞ t❤❡r❡ ✐s ♥♦ ✇❛② ♦❢ ❝♦♠♣❛r✐♥❣ t✇♦ ❢✉♥❝t✐♦♥s t❤❛t ✐s ❜♦t❤ ♣r❛❝t✐❝❛❧ ❛♥❞ ♠❡❛♥✐♥❣❢✉❧✳ ❆❜str❛❝t t②♣❡s ❝❛♥ ❜❡ ❞❡❝❧❛r❡❞ ✐♥ ▼▲✱ ❤✐❞✐♥❣ t❤❡✐r ✐♥t❡r♥❛❧ r❡♣r❡s❡♥t❛t✐♦♥✱ ✐♥❝❧✉❞✐♥❣ ✐ts ❡q✉❛❧✐t② t❡st✳ ❊q✉❛❧✐t② ✐s ♥♦t ❡✈❡♥ ❛❧❧♦✇❡❞ ❢♦r t②♣❡ r❡❛❧✱ t❤♦✉❣❤ s♦♠❡ ▼▲ s②st❡♠s ✐❣♥♦r❡ t❤✐s✳ ❲❡ s❤❛❧❧ ❞✐s❝✉ss ❢✉♥❝t✐♦♥ ✈❛❧✉❡s ❛♥❞ ❛❜str❛❝t t②♣❡s ❧❛t❡r✳ ■❢ ❛ ❢✉♥❝t✐♦♥✬s t②♣❡ ❝♦♥t❛✐♥s ❡q✉❛❧✐t② t②♣❡ ✈❛r✐❛❜❧❡s✱ s✉❝❤ ❛s ✑❛✱ ✑❜✱ t❤❡♥ ✐t ✉s❡s ♣♦❧②♠♦r♣❤✐❝ ❡q✉❛❧✐t② t❡st✐♥❣✳

❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✹✾

Slide 504

Equality Polymorphism

fun inter([], ys) = [] | inter(x::xs, ys) = if member(x,ys) then x::inter(xs, ys) else inter(xs, ys); > val inter = fn: ’’a list * ’’a list -> ’’a list

ML notices that inter uses equality indirectly, by member. ML will OBJECT if we apply these functions to non-equality types.

❋✉♥❝t✐♦♥ ✐♥t❡r ❝♦♠♣✉t❡s t❤❡ ❵✐♥t❡rs❡❝t✐♦♥✬ ♦❢ t✇♦ ❧✐sts✱ r❡t✉r♥✐♥❣ t❤❡ ❧✐st ♦❢ ❡❧❡♠❡♥ts ❝♦♠♠♦♥ t♦ ❜♦t❤✳ ■t ❝❛❧❧s ♠❡♠❜❡r✳ ❚❤❡ ❡q✉❛❧✐t② t②♣❡ ✈❛r✐❛❜❧❡s ♣r♦♣❛❣❛t❡✿ t❤❡ ✐♥t❡rs❡❝t✐♦♥ ❢✉♥❝t✐♦♥ ❛❧s♦ ❤❛s t❤❡♠ ❡✈❡♥ t❤♦✉❣❤ ✐ts ✉s❡ ♦❢ ❡q✉❛❧✐t② ✐s ✐♥❞✐r❡❝t✳ ❚r②✐♥❣ t♦ ❛♣♣❧② ♠❡♠❜❡r ♦r ✐♥t❡r t♦ ❛ ❧✐st ♦❢ ❢✉♥❝t✐♦♥s ❝❛✉s❡s ▼▲ t♦ ❝♦♠♣❧❛✐♥ ♦❢ ❛ t②♣❡ ❡rr♦r✳ ■t ❞♦❡s s♦ ❛t ❝♦♠♣✐❧❡ t✐♠❡✿ ✐t ❞❡t❡❝ts t❤❡ ❡rr♦rs ❜② t②♣❡s ❛❧♦♥❡✱ ✇✐t❤♦✉t ❡①❡❝✉t✐♥❣ t❤❡ ♦✛❡♥❞✐♥❣ ❝♦❞❡✳ ❊q✉❛❧✐t② ♣♦❧②♠♦r♣❤✐s♠ ✐s ❛ ❝♦♥t❡♥t✐♦✉s ❢❡❛t✉r❡✳ ❙♦♠❡ r❡s❡❛r❝❤❡rs ❝♦♠✲ ♣❧❛✐♥ t❤❛t ✐t ♠❛❦❡s ▼▲ t♦♦ ❝♦♠♣❧✐❝❛t❡❞ ❛♥❞ ❧❡❛❞s ♣r♦❣r❛♠♠❡rs t♦ ✉s❡ ❧✐♥❡❛r s❡❛r❝❤ ❡①❝❡ss✐✈❡❧②✳ ❚❤❡ ❢✉♥❝t✐♦♥❛❧ ♣r♦❣r❛♠♠✐♥❣ ❧❛♥❣✉❛❣❡ ❍❛s❦❡❧❧ ❣❡♥❡r❛❧✲ ✐③❡s t❤❡ ❝♦♥❝❡♣t✱ ❛❧❧♦✇✐♥❣ ♣r♦❣r❛♠♠❡rs t♦ ✐♥tr♦❞✉❝❡ ♥❡✇ ❝❧❛ss❡s ♦❢ t②♣❡s s✉♣♣♦rt✐♥❣ ❛♥② ❞❡s✐r❡❞ ❝♦❧❧❡❝t✐♦♥ ♦❢ ♦♣❡r❛t✐♦♥s✳

❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✺✵

Slide 505

Building a List of Pairs

fun zip (x::xs,y::ys) = (x,y) :: zip(xs,ys) | zip _ = [];

[x1, . . . , xn] [y1, . . . , yn]

• −

→ [(x1, y1), . . . , (xn, yn)]

The wildcard pattern (_) catches empty lists. THE PATTERNS ARE TRIED IN ORDER.

❆ ❧✐st ♦❢ ♣❛✐rs ♦❢ t❤❡ ❢♦r♠ [(x1, y1), . . . , (xn, yn)] ❛ss♦❝✐❛t❡s ❡❛❝❤ xi ✇✐t❤ yi✳ ❈♦♥❝❡♣t✉❛❧❧②✱ ❛ t❡❧❡♣❤♦♥❡ ❞✐r❡❝t♦r② ❝♦✉❧❞ ❜❡ r❡❣❛r❞❡❞ ❛s s✉❝❤ ❛ ❧✐st✱ ✇❤❡r❡ xi r❛♥❣❡s ♦✈❡r ♥❛♠❡s ❛♥❞ yi ♦✈❡r t❤❡ ❝♦rr❡s♣♦♥❞✐♥❣ t❡❧❡♣❤♦♥❡ ♥✉♠❜❡r✳ ▲✐♥❡❛r s❡❛r❝❤ ✐♥ s✉❝❤ ❛ ❧✐st ❝❛♥ ✜♥❞ t❤❡ yi ❛ss♦❝✐❛t❡❞ ✇✐t❤ ❛ ❣✐✈❡♥ xi✱ ♦r ✈✐❝❡ ✈❡rs❛✖ ✈❡r② s❧♦✇❧②✳ ■♥ ♦t❤❡r ❝❛s❡s✱ t❤❡ (xi, yi) ♣❛✐rs ♠✐❣❤t ❤❛✈❡ ❜❡❡♥ ❣❡♥❡r❛t❡❞ ❜② ❛♣♣❧②✐♥❣ ❛ ❢✉♥❝t✐♦♥ t♦ t❤❡ ❡❧❡♠❡♥ts ♦❢ ❛♥♦t❤❡r ❧✐st [z1, . . . , zn]✳ ❚❤❡ ❢✉♥❝t✐♦♥s ③✐♣ ❛♥❞ ✉♥③✐♣ ❜✉✐❧❞ ❛♥❞ t❛❦❡ ❛♣❛rt ❧✐sts ♦❢ ♣❛✐rs✿ ③✐♣ ♣❛✐rs ✉♣ ❝♦rr❡s♣♦♥❞✐♥❣ ❧✐st ❡❧❡♠❡♥ts ❛♥❞ ✉♥③✐♣ ✐♥✈❡rts t❤✐s ♦♣❡r❛t✐♦♥✳ ❚❤❡✐r t②♣❡s r❡✢❡❝t ✇❤❛t t❤❡② ❞♦✿

③✐♣ ✿ ✭✬❛ ❧✐st ✯ ✬❜ ❧✐st✮ ✲❃ ✭✬❛ ✯ ✬❜✮ ❧✐st ✉♥③✐♣ ✿ ✭✬❛ ✯ ✬❜✮ ❧✐st ✲❃ ✭✬❛ ❧✐st ✯ ✬❜ ❧✐st✮

■❢ t❤❡ ❧✐sts ❛r❡ ♦❢ ✉♥❡q✉❛❧ ❧❡♥❣t❤✱ ③✐♣ ❞✐s❝❛r❞s s✉r♣❧✉s ✐t❡♠s ❛t t❤❡ ❡♥❞ ♦❢ t❤❡ ❧♦♥❣❡r ❧✐st✳ ■ts ✜rst ♣❛tt❡r♥ ♦♥❧② ♠❛t❝❤❡s ❛ ♣❛✐r ♦❢ ♥♦♥✲❡♠♣t② ❧✐sts✳ ❚❤❡ s❡❝♦♥❞ ♣❛tt❡r♥ ✐s ❥✉st ❛ ✇✐❧❞❝❛r❞ ❛♥❞ ❝♦✉❧❞ ♠❛t❝❤ ❛♥②t❤✐♥❣✳ ▼▲ tr✐❡s t❤❡ ❝❧❛✉s❡s ✐♥ t❤❡ ♦r❞❡r ❣✐✈❡♥✱ s♦ t❤❡ ✜rst ♣❛tt❡r♥ ✐s tr✐❡❞ ✜rst✳ ❚❤❡ s❡❝♦♥❞ ♦♥❧② ❣❡ts ❛r❣✉♠❡♥ts ✇❤❡r❡ ❛t ❧❡❛st ♦♥❡ ♦❢ t❤❡ ❧✐sts ✐s ❡♠♣t②✳

❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✺✶

Slide 506

Building a Pair of Results

fun unzip [] = ([],[]) | unzip ((x,y)::pairs) = let val (xs,ys) = unzip pairs in (x::xs, y::ys) end; fun revUnzip ([], xs, ys) = (xs,ys) | revUnzip ((x,y)::pairs, xs, ys) = revUnzip(pairs, x::xs, y::ys);

• ✐✈❡♥ ❛ ❧✐st ♦❢ ♣❛✐rs✱ ✉♥③✐♣ ❤❛s t♦ ❜✉✐❧❞ t✇♦ ❧✐sts ♦❢ r❡s✉❧ts✱ ✇❤✐❝❤ ✐s

❛✇❦✇❛r❞ ✉s✐♥❣ r❡❝✉rs✐♦♥✳ ❚❤❡ ✈❡rs✐♦♥ s❤♦✇♥ ❛❜♦✉t ✉s❡s t❤❡ ❧♦❝❛❧ ❞❡❝❧❛r❛t✐♦♥ ❧❡t D ✐♥ E ❡♥❞✱ ✇❤❡r❡ D ❝♦♥s✐sts ♦❢ ❞❡❝❧❛r❛t✐♦♥s ❛♥❞ E ✐s t❤❡ ❡①♣r❡ss✐♦♥ t❤❛t ❝❛♥ ✉s❡ t❤❡♠✳ ◆♦t❡ ❡s♣❡❝✐❛❧❧② t❤❡ ❞❡❝❧❛r❛t✐♦♥

✈❛❧ ✭①s✱②s✮ ❂ ✉♥③✐♣ ♣❛✐rs

✇❤✐❝❤ ❜✐♥❞s ①s ❛♥❞ ②s t♦ t❤❡ r❡s✉❧ts ♦❢ t❤❡ r❡❝✉rs✐✈❡ ❝❛❧❧✳ ■♥ ❣❡♥❡r❛❧✱ t❤❡ ❞❡❝❧❛r❛t✐♦♥ ✈❛❧ P ❂ E ♠❛t❝❤❡s t❤❡ ♣❛tt❡r♥ P ❛❣❛✐♥st t❤❡ ✈❛❧✉❡ ♦❢ ❡①♣r❡s✲ s✐♦♥ E✳ ■t ❜✐♥❞s ❛❧❧ t❤❡ ✈❛r✐❛❜❧❡s ✐♥ P t♦ t❤❡ ❝♦rr❡s♣♦♥❞✐♥❣ ✈❛❧✉❡s✳ ❍❡r❡ ✐s ✈❡rs✐♦♥ ♦❢ ✉♥③✐♣ t❤❛t r❡♣❧❛❝❡s t❤❡ ❧♦❝❛❧ ❞❡❝❧❛r❛t✐♦♥ ❜② ❛ ❢✉♥❝t✐♦♥ ✭❝♦♥s♣❛✐r✮ ❢♦r t❛❦✐♥❣ ❛♣❛rt t❤❡ ♣❛✐r ♦❢ ❧✐sts ✐♥ t❤❡ r❡❝✉rs✐✈❡ ❝❛❧❧✳ ■t ❞❡✜♥❡s t❤❡ s❛♠❡ ❝♦♠♣✉t❛t✐♦♥ ❛s t❤❡ ♣r❡✈✐♦✉s ✈❡rs✐♦♥ ♦❢ ③✐♣ ❛♥❞ ✐s ♣♦ss✐❜❧② ❝❧❡❛r❡r✱ ❜✉t ♥♦t ❡✈❡r② ❧♦❝❛❧ ❞❡❝❧❛r❛t✐♦♥ ❝❛♥ ❜❡ ❡❧✐♠✐♥❛t❡❞ ❛s ❡❛s✐❧②✳

❢✉♥ ❝♦♥s♣❛✐r ✭✭①✱②✮✱ ✭①s✱②s✮✮ ❂ ✭①✿✿①s✱ ②✿✿②s✮❀ ❢✉♥ ✉♥③✐♣ ❬❪ ❂ ✭❬❪✱❬❪✮ ⑤ ✉♥③✐♣✭①②✿✿♣❛✐rs✮ ❂ ❝♦♥s♣❛✐r✭①②✱ ✉♥③✐♣ ♣❛✐rs✮❀

▼❛❦✐♥❣ t❤❡ ❢✉♥❝t✐♦♥ ✐t❡r❛t✐✈❡ ②✐❡❧❞s r❡✈❯♥③✐♣ ❛❜♦✈❡✱ ✇❤✐❝❤ ✐s ✈❡r② s✐♠✲ ♣❧❡✳ ■t❡r❛t✐♦♥ ❝❛♥ ❝♦♥str✉❝t ♠❛♥② r❡s✉❧ts ❛t ♦♥❝❡ ✐♥ ❞✐✛❡r❡♥t ❛r❣✉♠❡♥t ♣♦s✐✲ t✐♦♥s✳ ❇♦t❤ ♦✉t♣✉t ❧✐sts ❛r❡ ❜✉✐❧t ✐♥ r❡✈❡rs❡ ♦r❞❡r✱ ✇❤✐❝❤ ❝❛♥ ❜❡ ❝♦rr❡❝t❡❞ ❜② r❡✈❡rs✐♥❣ t❤❡ ✐♥♣✉t t♦ r❡✈❯♥③✐♣✳ ❚❤❡ t♦t❛❧ ❝♦sts ✇✐❧❧ ♣r♦❜❛❜❧② ❡①❝❡❡❞ t❤♦s❡ ♦❢ ✉♥③✐♣ ❞❡s♣✐t❡ t❤❡ ❛❞✈❛♥t❛❣❡s ♦❢ ✐t❡r❛t✐♦♥✳

❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✺✷

Slide 507

An Application: Making Change

fun change (till, 0) = [] | change (c::till, amt) = if amt<c then change(till, amt) else c :: change(c::till, amt-c) > Warning: pattern matching is not exhaustive > val change = fn : int list * int -> int list

• The recursion terminates when amt = 0.
• Tries the largest coin first to use large coins.
• The algorithm is greedy, and it CAN FAIL!

❚❤❡ t✐❧❧ ❤❛s ✉♥❧✐♠✐t❡❞ s✉♣♣❧✐❡s ♦❢ ❝♦✐♥s✳ ❚❤❡ ❧❛r❣❡st ❝♦✐♥s s❤♦✉❧❞ ❜❡ tr✐❡❞ ✜rst✱ t♦ ❛✈♦✐❞ ❣✐✈✐♥❣ ❝❤❛♥❣❡ ❛❧❧ ✐♥ ♣❡♥♥✐❡s✳ ❚❤❡ ❧✐st ♦❢ ❧❡❣❛❧ ❝♦✐♥ ✈❛❧✉❡s✱ ❝❛❧❧❡❞ t✐❧❧✱ ✐s ❣✐✈❡♥ ✐♥ ❞❡s❝❡♥❞✐♥❣ ♦r❞❡r✱ s✉❝❤ ❛s ✺✵✱ ✷✵✱ ✶✵✱ ✺✱ ✷ ❛♥❞ ✶✳ ✭❘❡❝❛❧❧ t❤❛t t❤❡ ❤❡❛❞ ♦❢ ❛ ❧✐st ✐s t❤❡ ❡❧❡♠❡♥t ♠♦st ❡❛s✐❧② r❡❛❝❤❡❞✳✮ ❚❤❡ ❝♦❞❡ ❢♦r ❝❤❛♥❣❡ ✐s ❜❛s❡❞ ♦♥ s✐♠♣❧❡ ♦❜s❡r✈❛t✐♦♥s✳

• ❈❤❛♥❣❡ ❢♦r ③❡r♦ ❝♦♥s✐sts ♦❢ ♥♦ ❝♦✐♥s ❛t ❛❧❧✳ ✭◆♦t❡ t❤❡ ♣❛tt❡r♥ ♦❢ ✵ ✐♥

t❤❡ ✜rst ❝❧❛✉s❡✳✮

• ❋♦r ❛ ♥♦♥③❡r♦ ❛♠♦✉♥t✱ tr② t❤❡ ❧❛r❣❡st ❛✈❛✐❧❛❜❧❡ ❝♦✐♥✳

■❢ ✐t ✐s s♠❛❧❧ ❡♥♦✉❣❤✱ ✉s❡ ✐t ❛♥❞ ❞❡❝r❡❛s❡ t❤❡ ❛♠♦✉♥t ❛❝❝♦r❞✐♥❣❧②✳

• ❊①❝❧✉❞❡ ❢r♦♠ ❝♦♥s✐❞❡r❛t✐♦♥ ❛♥② ❝♦✐♥s t❤❛t ❛r❡ t♦♦ ❧❛r❣❡✳

❆❧t❤♦✉❣❤ ♥♦❜♦❞② ❝♦♥s✐❞❡rs ♠❛❦✐♥❣ ❝❤❛♥❣❡ ❢♦r ③❡r♦✱ t❤✐s ✐s t❤❡ s✐♠♣❧❡st ✇❛② t♦ ♠❛❦❡ t❤❡ ❛❧❣♦r✐t❤♠ t❡r♠✐♥❛t❡✳ ▼♦st ✐t❡r❛t✐✈❡ ♣r♦❝❡❞✉r❡s ❜❡❝♦♠❡ s✐♠♣❧❡st ✐❢✱ ✐♥ t❤❡✐r ❜❛s❡ ❝❛s❡✱ t❤❡② ❞♦ ♥♦t❤✐♥❣✳ ❆ ❜❛s❡ ❝❛s❡ ♦❢ ♦♥❡ ✐♥st❡❛❞ ♦❢ ③❡r♦ ✐s ♦❢t❡♥ ❛ s✐❣♥ ♦❢ ❛ ♥♦✈✐❝❡ ♣r♦❣r❛♠♠❡r✳ ❚❤❡ ❢✉♥❝t✐♦♥ ❝❛♥ t❡r♠✐♥❛t❡ ❡✐t❤❡r ✇✐t❤ s✉❝❝❡ss ♦r ❢❛✐❧✉r❡✳ ■t ❢❛✐❧s ❜② r❛✐s✐♥❣ ❡①❝❡♣t✐♦♥ ▼❛t❝❤✳ ❚❤❡ ❡①❝❡♣t✐♦♥ ♦❝❝✉rs ✐❢ ♥♦ ♣❛tt❡r♥ ♠❛t❝❤❡s✱ ♥❛♠❡❧② ✐❢ t✐❧❧ ❜❡❝♦♠❡s ❡♠♣t② ✇❤✐❧❡ ❛♠♦✉♥t ✐s st✐❧❧ ♥♦♥③❡r♦✳ ❯♥❢♦rt✉♥❛t❡❧②✱ ❢❛✐❧✉r❡ ❝❛♥ ♦❝❝✉r ❡✈❡♥ ✇❤❡♥ ❝❤❛♥❣❡ ❝❛♥ ❜❡ ♠❛❞❡✳ ❚❤❡ ❣r❡❡❞② ❵❧❛r❣❡st ❝♦✐♥ ✜rst✬ ❛♣♣r♦❛❝❤ ✐s t♦ ❜❧❛♠❡✳ ❙✉♣♣♦s❡ ✇❡ ❤❛✈❡ ❝♦✐♥s ♦❢ ✈❛❧✉❡s ✺ ❛♥❞ ✷✱ ❛♥❞ ♠✉st ♠❛❦❡ ❝❤❛♥❣❡ ❢♦r ✻❀ t❤❡ ♦♥❧② ✇❛② ✐s 6 = 2 + 2 + 2✱ ✐❣♥♦r✐♥❣ t❤❡ ✺✳ ●r❡❡❞② ❛❧❣♦r✐t❤♠s ❛r❡ ♦❢t❡♥ ❡✛❡❝t✐✈❡✱ ❜✉t ♥♦t ❤❡r❡✳

❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✺✸

Slide 508

ALL Ways of Making Change

fun change (till, 0) = [[]] | change ([], amt) = [] | change (c::till, amt) = if amt<c then change(till, amt) else let fun allc [] = [] | allc(cs::css) = (c::cs)::allc css in allc (change(c::till, amt-c)) @ change(till, amt) end;

▲❡t ✉s ❣❡♥❡r❛❧✐③❡ t❤❡ ♣r♦❜❧❡♠ t♦ ✜♥❞ ❛❧❧ ♣♦ss✐❜❧❡ ✇❛②s ♦❢ ♠❛❦✐♥❣ ❝❤❛♥❣❡✱ r❡t✉r♥✐♥❣ t❤❡♠ ❛s ❛ ❧✐st ♦❢ s♦❧✉t✐♦♥s✳ ▲♦♦❦ ❛t t❤❡ t②♣❡✿ t❤❡ r❡s✉❧t ✐s ♥♦✇ ❛ ❧✐st ♦❢ ❧✐sts✳

❃ ❝❤❛♥❣❡ ✿ ✐♥t ❧✐st ✯ ✐♥t ✲❃ ✐♥t ❧✐st ❧✐st

❚❤❡ ❝♦❞❡ ✇✐❧❧ ♥❡✈❡r r❛✐s❡ ❡①❝❡♣t✐♦♥s✳ ■t ❡①♣r❡ss❡s ❢❛✐❧✉r❡ ❜② r❡t✉r♥✐♥❣ ❛♥ ❡♠♣t② ❧✐st ♦❢ s♦❧✉t✐♦♥s✿ ✐t r❡t✉r♥s ❬❪ ✐❢ t❤❡ t✐❧❧ ✐s ❡♠♣t② ❛♥❞ t❤❡ ❛♠♦✉♥t ✐s ♥♦♥③❡r♦✳ ■❢ t❤❡ ❛♠♦✉♥t ✐s ③❡r♦✱ t❤❡♥ t❤❡r❡ ✐s ♦♥❧② ♦♥❡ ✇❛② ♦❢ ♠❛❦✐♥❣ ❝❤❛♥❣❡❀ t❤❡ r❡s✉❧t s❤♦✉❧❞ ❜❡ ❬❬❪❪✳ ❚❤✐s ✐s s✉❝❝❡ss ✐♥ t❤❡ ❜❛s❡ ❝❛s❡✳ ■♥ ♥♦♥tr✐✈✐❛❧ ❝❛s❡s✱ t❤❡r❡ ❛r❡ t✇♦ s♦✉r❝❡s ♦❢ s♦❧✉t✐♦♥s✿ t♦ ✉s❡ ❛ ❝♦✐♥ ✭✐❢ ♣♦ss✐❜❧❡✮ ❛♥❞ ❞❡❝r❡❛s❡ t❤❡ ❛♠♦✉♥t ❛❝❝♦r❞✐♥❣❧②✱ ♦r t♦ r❡♠♦✈❡ t❤❡ ❝✉rr❡♥t ❝♦✐♥ ✈❛❧✉❡ ❢r♦♠ ❝♦♥s✐❞❡r❛t✐♦♥✳ ❚❤❡ ❢✉♥❝t✐♦♥ ❛❧❧❝ ✐s ❞❡❝❧❛r❡❞ ❧♦❝❛❧❧② ✐♥ ♦r❞❡r t♦ ♠❛❦❡ ✉s❡ ♦❢ ❝✱ t❤❡ ❝✉rr❡♥t ❝♦✐♥✳ ■t ❛❞❞s ❛♥ ❡①tr❛ ❝ t♦ ❛❧❧ t❤❡ s♦❧✉t✐♦♥s r❡t✉r♥❡❞ ❜② t❤❡ r❡❝✉rs✐✈❡ ❝❛❧❧ t♦ ♠❛❦❡ ❝❤❛♥❣❡ ❢♦r ❛♠t✲❝✳ ❖❜s❡r✈❡ t❤❡ ♥❛♠✐♥❣ ❝♦♥✈❡♥t✐♦♥✿ ❝s ✐s ❛ ❧✐st ♦❢ ❝♦✐♥s✱ ✇❤✐❧❡ ❝ss ✐s ❛ ❧✐st ♦❢ s✉❝❤ ❧✐sts✳ ❚❤❡ tr❛✐❧✐♥❣ ❵s✬ ✐s s✉❣❣❡st✐✈❡ ♦❢ ❛ ♣❧✉r❛❧✳

❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✺✹

Slide 509

ALL Ways of Making Change — Faster!

fun change(till, 0, chg, chgs) = chg::chgs | change([], amt, chg, chgs) = chgs | change(c::till, amt, chg, chgs) = if amt<0 then chgs else change(c::till, amt-c, c::chg, change(till, amt, chg, chgs))

We’ve added another accumulating parameter! Repeatedly improving simple code is called stepwise refinement.

❚✇♦ ❡①tr❛ ❛r❣✉♠❡♥ts ❡❧✐♠✐♥❛t❡ ♠❛♥② ✿✿ ❛♥❞ ❛♣♣❡♥❞ ♦♣❡r❛t✐♦♥s ❢r♦♠ t❤❡ ♣r❡✈✐♦✉s s❧✐❞❡✬s ❝❤❛♥❣❡ ❢✉♥❝t✐♦♥✳ ❚❤❡ ✜rst✱ ❝❤❣✱ ❛❝❝✉♠✉❧❛t❡s t❤❡ ❝♦✐♥s ❝❤♦s❡♥ s♦ ❢❛r❀ ♦♥❡ ❡✈❛❧✉❛t✐♦♥ ♦❢ ❝✿✿❝❤❣ r❡♣❧❛❝❡s ♠❛♥② ❡✈❛❧✉❛t✐♦♥s ♦❢ ❛❧❧❝✳ ❚❤❡ s❡❝♦♥❞✱ ❝❤❣s✱ ❛❝❝✉♠✉❧❛t❡s t❤❡ ❧✐st ♦❢ s♦❧✉t✐♦♥s s♦ ❢❛r❀ ✐t ❛✈♦✐❞s t❤❡ ♥❡❡❞ ❢♦r ❛♣♣❡♥❞✳ ❚❤✐s ✈❡rs✐♦♥ r✉♥s s❡✈❡r❛❧ t✐♠❡s ❢❛st❡r t❤❛♥ t❤❡ ♣r❡✈✐♦✉s ♦♥❡✳ ▼❛❦✐♥❣ ❝❤❛♥❣❡ ✐s st✐❧❧ ❡①tr❡♠❡❧② s❧♦✇ ❢♦r ❛♥ ♦❜✈✐♦✉s r❡❛s♦♥✿ t❤❡ ♥✉♠❜❡r ♦❢ s♦❧✉t✐♦♥s ❣r♦✇s r❛♣✐❞❧② ✐♥ t❤❡ ❛♠♦✉♥t ❜❡✐♥❣ ❝❤❛♥❣❡❞✳ ❯s✐♥❣ ✺✵✱ ✷✵✱ ✶✵✱ ✺✱ ✷ ❛♥❞ ✶✱ t❤❡r❡ ❛r❡ ✹✸✻✻ ✇❛②s ♦❢ ❡①♣r❡ss✐♥❣ ✾✾✳ ❲❡ s❤❛❧❧ r❡✈✐s✐t t❤❡ ❵♠❛❦✐♥❣ ❝❤❛♥❣❡✬ t❛s❦ ❧❛t❡r t♦ ✐❧❧✉str❛t❡ ❡①❝❡♣t✐♦♥✲ ❤❛♥❞❧✐♥❣✳ ❖✉r t❤r❡❡ ❝❤❛♥❣❡ ❢✉♥❝t✐♦♥s ✐❧❧✉str❛t❡ ❛ ❜❛s✐❝ t❡❝❤♥✐q✉❡✿ ♣r♦❣r❛♠ ❞❡✈❡❧✲ ♦♣♠❡♥t ❜② st❡♣✇✐s❡ r❡✜♥❡♠❡♥t✳ ❇❡❣✐♥ ❜② ✇r✐t✐♥❣ ❛ ✈❡r② s✐♠♣❧❡ ♣r♦❣r❛♠ ❛♥❞ ❛❞❞ r❡q✉✐r❡♠❡♥ts ✐♥❞✐✈✐❞✉❛❧❧②✳ ❆❞❞ ❡✣❝✐❡♥❝② r❡✜♥❡♠❡♥ts ❧❛st ♦❢ ❛❧❧✳ ❊✈❡♥ ✐❢ t❤❡ s✐♠♣❧❡r ♣r♦❣r❛♠ ❝❛♥♥♦t ❜❡ ✐♥❝❧✉❞❡❞ ✐♥ t❤❡ ♥❡①t ✈❡rs✐♦♥ ❛♥❞ ❤❛s t♦ ❜❡ ❞✐s❝❛r❞❡❞✱ ♦♥❡ ❤❛s ❧❡❛r♥❡❞ ❛❜♦✉t t❤❡ t❛s❦ ❜② ✇r✐t✐♥❣ ✐t✳

❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✺✺ ▲❡❛r♥✐♥❣ ❣✉✐❞❡✳ ❘❡❧❛t❡❞ ♠❛t❡r✐❛❧ ✐s ✐♥ ▼▲ ❢♦r t❤❡ ❲♦r❦✐♥❣ Pr♦❣r❛♠♠❡r✱ ♣❛❣❡s ✽✷✲✶✵✼✱ t❤♦✉❣❤ ②♦✉ ♠❛② ✇❛♥t t♦ s❦✐♣ s♦♠❡ ♦❢ t❤❡ ❤❛r❞❡r ❡①❛♠♣❧❡s✳ ❊①❡r❝✐s❡ ✺✳✶ ❍♦✇ ❞♦❡s t❤✐s ✈❡rs✐♦♥ ♦❢ ③✐♣ ❞✐✛❡r ❢r♦♠ t❤❡ ♦♥❡ ❛❜♦✈❡❄

❢✉♥ ③✐♣ ✭①✿✿①s✱②✿✿②s✮ ❂ ✭①✱②✮ ✿✿ ③✐♣✭①s✱②s✮ ⑤ ③✐♣ ✭❬❪✱ ❬❪✮ ❂ ❬❪❀

❊①❡r❝✐s❡ ✺✳✷ ❲❤❛t ❛ss✉♠♣t✐♦♥s ❞♦ t❤❡ ❵♠❛❦✐♥❣ ❝❤❛♥❣❡✬ ❢✉♥❝t✐♦♥s ♠❛❦❡ ❛❜♦✉t t❤❡ ✈❛r✐❛❜❧❡s t✐❧❧✱ ❝ ❛♥❞ ❛♠t❄ ■❧❧✉str❛t❡ ✇❤❛t ❝♦✉❧❞ ❤❛♣♣❡♥ ✐❢ s♦♠❡ ♦❢ t❤❡s❡ ❛ss✉♠♣t✐♦♥s ✇❡r❡ ✈✐♦❧❛t❡❞✳ ❊①❡r❝✐s❡ ✺✳✸ ❙❤♦✇ t❤❛t t❤❡ ♥✉♠❜❡r ♦❢ ✇❛②s ♦❢ ♠❛❦✐♥❣ ❝❤❛♥❣❡ ❢♦r n ✭✐❣✲ ♥♦r✐♥❣ ♦r❞❡r✮ ✐s O(n) ✐❢ t❤❡r❡ ❛r❡ t✇♦ ❧❡❣❛❧ ❝♦✐♥ ✈❛❧✉❡s✳ ❲❤❛t ✐❢ t❤❡r❡ ❛r❡ t❤r❡❡✱ ❢♦✉r✱ ✳ ✳ ✳ ❝♦✐♥ ✈❛❧✉❡s❄

❱■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✺✻

Slide 601

Sorting: Arranging Items into Order

a few applications:

• fast search
• fast merging
• finding duplicates
• inverting tables
• graphics algorithms

❙♦rt✐♥❣ ✐s ♣❡r❤❛♣s t❤❡ ♠♦st ❞❡❡♣❧② st✉❞✐❡❞ ❛s♣❡❝t ♦❢ ❛❧❣♦r✐t❤♠ ❞❡s✐❣♥✳ ❑♥✉t❤✬s s❡r✐❡s ❚❤❡ ❆rt ♦❢ ❈♦♠♣✉t❡r Pr♦❣r❛♠♠✐♥❣ ❞❡✈♦t❡s ❛♥ ❡♥t✐r❡ ✈♦❧✉♠❡ t♦ s♦rt✐♥❣ ❛♥❞ s❡❛r❝❤✐♥❣ ❬✾❪✦ ❙❡❞❣❡✇✐❝❦ ❬✶✹❪ ❛❧s♦ ❝♦✈❡rs s♦rt✐♥❣✳ ❙♦rt✐♥❣ ❤❛s ❝♦✉♥t❧❡ss ❛♣♣❧✐❝❛t✐♦♥s✳ ❙♦rt✐♥❣ ❛ ❝♦❧❧❡❝t✐♦♥ ❛❧❧♦✇s ✐t❡♠s t♦ ❜❡ ❢♦✉♥❞ q✉✐❝❦❧②✳ ❘❡❝❛❧❧ t❤❛t ❧✐♥❡❛r s❡❛r❝❤ r❡q✉✐r❡s O(n) st❡♣s t♦ s❡❛r❝❤ ❛♠♦♥❣ n ✐t❡♠s✳ ❆ s♦rt❡❞ ❝♦❧❧❡❝t✐♦♥ ❛❞♠✐ts ❜✐♥❛r② s❡❛r❝❤✱ ✇❤✐❝❤ r❡q✉✐r❡s ♦♥❧② O(log n) t✐♠❡✳ ❚❤❡ ✐❞❡❛ ♦❢ ❜✐♥❛r② s❡❛r❝❤ ✐s t♦ ❝♦♠♣❛r❡ t❤❡ ✐t❡♠ ❜❡✐♥❣ s♦✉❣❤t ✇✐t❤ t❤❡ ♠✐❞❞❧❡ ✐t❡♠ ✭✐♥ ♣♦s✐t✐♦♥ n/2✮ ❛♥❞ t❤❡♥ t♦ ❞✐s❝❛r❞ ❡✐t❤❡r t❤❡ ❧❡❢t ❤❛❧❢ ♦r t❤❡ r✐❣❤t✱ ❞❡♣❡♥❞✐♥❣ ♦♥ t❤❡ r❡s✉❧t ♦❢ t❤❡ ❝♦♠♣❛r✐s♦♥✳ ❇✐♥❛r② s❡❛r❝❤ ♥❡❡❞s ❛rr❛②s ♦r tr❡❡s✱ ♥♦t ❧✐sts❀ ✇❡ s❤❛❧❧ ❝♦♠❡ t♦ ❜✐♥❛r② s❡❛r❝❤ tr❡❡s ❧❛t❡r✳ ❚✇♦ s♦rt❡❞ ✜❧❡s ❝❛♥ q✉✐❝❦❧② ❜❡ ♠❡r❣❡❞ t♦ ❢♦r♠ ❛ ❧❛r❣❡r s♦rt❡❞ ✜❧❡✳ ❖t❤❡r ❛♣♣❧✐❝❛t✐♦♥s ✐♥❝❧✉❞❡ ✜♥❞✐♥❣ ❞✉♣❧✐❝❛t❡s✿ ❛❢t❡r s♦rt✐♥❣✱ t❤❡② ❛r❡ ❛❞❥❛❝❡♥t✳ ❆ t❡❧❡♣❤♦♥❡ ❞✐r❡❝t♦r② ✐s s♦rt❡❞ ❛❧♣❤❛❜❡t✐❝❛❧❧② ❜② ♥❛♠❡✳ ❚❤❡ s❛♠❡ ✐♥❢♦r✲ ♠❛t✐♦♥ ❝❛♥ ✐♥st❡❛❞ ❜❡ s♦rt❡❞ ❜② t❡❧❡♣❤♦♥❡ ♥✉♠❜❡r ✭✉s❡❢✉❧ t♦ t❤❡ ♣♦❧✐❝❡✮ ♦r ❜② str❡❡t ❛❞❞r❡ss ✭✉s❡❢✉❧ t♦ ❥✉♥❦✲♠❛✐❧ ✜r♠s✮✳ ❙♦rt✐♥❣ ✐♥❢♦r♠❛t✐♦♥ ✐♥ ❞✐✛❡r❡♥t ✇❛②s ❣✐✈❡s ✐t ❞✐✛❡r❡♥t ❛♣♣❧✐❝❛t✐♦♥s✳ ❈♦♠♠♦♥ s♦rt✐♥❣ ❛❧❣♦r✐t❤♠s ✐♥❝❧✉❞❡ ✐♥s❡rt✐♦♥ s♦rt✱ q✉✐❝❦s♦rt✱ ♠❡r❣❡s♦rt ❛♥❞ ❤❡❛♣s♦rt✳ ❲❡ s❤❛❧❧ ❝♦♥s✐❞❡r t❤❡ ✜rst t❤r❡❡ ♦❢ t❤❡s❡✳ ❊❛❝❤ ❛❧❣♦r✐t❤♠ ❤❛s ✐ts ❛❞✈❛♥t❛❣❡s✳ ❆s ❛ ❝♦♥❝r❡t❡ ❜❛s✐s ❢♦r ❝♦♠♣❛r✐s♦♥✱ r✉♥t✐♠❡s ❛r❡ q✉♦t❡❞ ❢♦r ❉❊❈st❛t✐♦♥ ❝♦♠♣✉t❡rs✳ ✭❚❤❡s❡ ✇❡r❡ ❜❛s❡❞ ♦♥ t❤❡ ▼■P❙ ❝❤✐♣✱ ❛♥ ❡❛r❧② ❘■❙❈ ❞❡s✐❣♥✳✮

❱■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✺✼

Slide 602

How Fast Can We Sort?

typically count comparisons C(n) there are n! permutations of n elements each comparison distinguishes two permutations

2C(n) ≥ n!,

therefore C(n) ≥ log(n!) ≈ n log n − 1.44n

❚❤❡ ✉s✉❛❧ ♠❡❛s✉r❡ ♦❢ ❡✣❝✐❡♥❝② ❢♦r s♦rt✐♥❣ ❛❧❣♦r✐t❤♠s ✐s t❤❡ ♥✉♠❜❡r ♦❢ ❝♦♠♣❛r✐s♦♥ ♦♣❡r❛t✐♦♥s r❡q✉✐r❡❞✳ ▼❡r❣❡s♦rt r❡q✉✐r❡s ♦♥❧② O(n log n) ❝♦♠♣❛r✲ ✐s♦♥s t♦ s♦rt ❛♥ ✐♥♣✉t ♦❢ n ✐t❡♠s✳ ■t ✐s str❛✐❣❤t❢♦r✇❛r❞ t♦ ♣r♦✈❡ t❤❛t ❛t t❤✐s ❝♦♠♣❧❡①✐t② ✐s t❤❡ ❜❡st ♣♦ss✐❜❧❡ ❬✷✱ ♣❛❣❡s ✽✻✕✼❪✳ ❚❤❡r❡ ❛r❡ n! ♣❡r♠✉t❛t✐♦♥s ♦❢ n ❡❧❡♠❡♥ts ❛♥❞ ❡❛❝❤ ❝♦♠♣❛r✐s♦♥ ❞✐st✐♥❣✉✐s❤❡s t✇♦ ♣❡r♠✉t❛t✐♦♥s✳ ❚❤❡ ❧♦✇❡r ❜♦✉♥❞ ♦♥ t❤❡ ♥✉♠❜❡r ♦❢ ❝♦♠♣❛r✐s♦♥s✱ C(n)✱ ✐s ♦❜t❛✐♥❡❞ ❜② s♦❧✈✐♥❣ 2C(n) ≥ n!❀ t❤❡r❡❢♦r❡ C(n) ≥ log(n!) ≈ n log n − 1.44n✳ ■♥ ♦r❞❡r t♦ ❝♦♠♣❛r❡ t❤❡ s♦rt✐♥❣ ❛❧❣♦r✐t❤♠s✱ ✇❡ ✉s❡ t❤❡ ❢♦❧❧♦✇✐♥❣ s♦✉r❝❡ ♦❢ ♣s❡✉❞♦✲r❛♥❞♦♠ ♥✉♠❜❡rs ❬✶✷❪✿

❧♦❝❛❧ ✈❛❧ ❛ ❂ ✶✻✽✵✼✳✵ ❛♥❞ ♠ ❂ ✷✶✹✼✹✽✸✻✹✼✳✵ ✐♥ ❢✉♥ ♥❡①tr❛♥❞♦♠ s❡❡❞ ❂ ❧❡t ✈❛❧ t ❂ ❛✯s❡❡❞ ✐♥ t ✲ ♠ ✯ r❡❛❧✭❢❧♦♦r✭t✴♠✮✮ ❡♥❞ ❛♥❞ tr✉♥❝t♦ ❦ r ❂ ✶ ✰ ❢❧♦♦r✭✭r ✴ ♠✮ ✯ ✭r❡❛❧ ❦✮✮ ❡♥❞❀

❲❡ ❜✐♥❞ t❤❡ ✐❞❡♥t✐✜❡r rs t♦ ❛ ❧✐st ♦❢ ✶✵✱✵✵✵ r❛♥❞♦♠ ♥✉♠❜❡rs✳

❢✉♥ r❛♥❞❧✐st ✭♥✱s❡❡❞✱s❡❡❞s✮ ❂ ✐❢ ♥❂✵ t❤❡♥ ✭s❡❡❞✱s❡❡❞s✮ ❡❧s❡ r❛♥❞❧✐st✭♥✲✶✱ ♥❡①tr❛♥❞♦♠ s❡❡❞✱ s❡❡❞✿✿s❡❡❞s✮❀ ✈❛❧ ✭s❡❡❞✱rs✮ ❂ r❛♥❞❧✐st✭✶✵✵✵✵✱ ✶✳✵✱ ❬❪✮❀

◆❡✈❡r ♠✐♥❞ ❤♦✇ t❤✐s ✇♦r❦s✱ ❜✉t ♥♦t❡ t❤❛t ❣❡♥❡r❛t✐♥❣ st❛t✐st✐❝❛❧❧② ❣♦♦❞ r❛♥✲ ❞♦♠ ♥✉♠❜❡rs ✐s ❤❛r❞✳ ▼✉❝❤ ❡✛♦rt ❤❛s ❣♦♥❡ ✐♥t♦ t❤♦s❡ ❢❡✇ ❧✐♥❡s ♦❢ ❝♦❞❡✳

❱■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✺✽

Slide 603

Insertion Sort

Insert does n/2 comparisons on average

fun ins (x:real, []) = [x] | ins (x:real, y::ys) = if x<=y then x::y::ys else y::ins(x,ys);

Insertion sort takes O(n2) comparisons on average

fun insort [] = [] | insort (x::xs) = ins(x, insort xs);

174 seconds to sort 10,000 random numbers

■t❡♠s ❢r♦♠ t❤❡ ✐♥♣✉t ❛r❡ ❝♦♣✐❡❞ ♦♥❡ ❛t ❛ t✐♠❡ t♦ t❤❡ ♦✉t♣✉t✳ ❊❛❝❤ ♥❡✇ ✐t❡♠ ✐s ✐♥s❡rt❡❞ ✐♥t♦ t❤❡ r✐❣❤t ♣❧❛❝❡ s♦ t❤❛t t❤❡ ♦✉t♣✉t ✐s ❛❧✇❛②s ✐♥ ♦r❞❡r✳ ❲❡ ❝♦✉❧❞ ❡❛s✐❧② ✇r✐t❡ ✐t❡r❛t✐✈❡ ✈❡rs✐♦♥s ♦❢ t❤❡s❡ ❢✉♥❝t✐♦♥s✱ ❜✉t t♦ ♥♦ ♣✉r♣♦s❡✳ ■♥s❡rt✐♦♥ s♦rt ✐s s❧♦✇ ❜❡❝❛✉s❡ ✐t ❞♦❡s O(n2) ❝♦♠♣❛r✐s♦♥s ✭❛♥❞ ❛ ❧♦t ♦❢ ❧✐st ❝♦♣②✐♥❣✮✱ ♥♦t ❜❡❝❛✉s❡ ✐t ✐s r❡❝✉rs✐✈❡✳ ■ts q✉❛❞r❛t✐❝ r✉♥t✐♠❡ ♠❛❦❡s ✐t ♥❡❛r❧② ✉s❡❧❡ss✿ ✐t t❛❦❡s ✶✼✹ s❡❝♦♥❞s ❢♦r ♦✉r ❡①❛♠♣❧❡ ✇❤✐❧❡ t❤❡ ♥❡①t✲✇♦rst ✜❣✉r❡ ✐s ✶✳✹ s❡❝♦♥❞s✳ ■♥s❡rt✐♦♥ s♦rt ✐s ✇♦rt❤ ❝♦♥s✐❞❡r✐♥❣ ❜❡❝❛✉s❡ ✐t ✐s ❡❛s② t♦ ❝♦❞❡ ❛♥❞ ✐❧❧✉s✲ tr❛t❡s t❤❡ ❝♦♥❝❡♣ts✳ ❚✇♦ ❡✣❝✐❡♥t s♦rt✐♥❣ ❛❧❣♦r✐t❤♠s✱ ♠❡r❣❡s♦rt ❛♥❞ ❤❡❛♣s♦rt✱ ❝❛♥ ❜❡ r❡❣❛r❞❡❞ ❛s r❡✜♥❡♠❡♥ts ♦❢ ✐♥s❡rt✐♦♥ s♦rt✳ ❚❤❡ t②♣❡ ❝♦♥str❛✐♥t ✿r❡❛❧ r❡s♦❧✈❡s t❤❡ ♦✈❡r❧♦❛❞✐♥❣ ♦❢ t❤❡ ❁❂ ♦♣❡r❛t♦r❀ r❡❝❛❧❧ ▲❡❝t✳ ✷✳ ❆❧❧ ♦✉r s♦rt✐♥❣ ❢✉♥❝t✐♦♥s ✇✐❧❧ ♥❡❡❞ ❛ t②♣❡ ❝♦♥str❛✐♥t s♦♠❡✲ ✇❤❡r❡✳ ❚❤❡ ♥♦t✐♦♥ ♦❢ s♦rt✐♥❣ ❞❡♣❡♥❞s ✉♣♦♥ t❤❡ ❢♦r♠ ♦❢ ❝♦♠♣❛r✐s♦♥ ❜❡✐♥❣ ❞♦♥❡✱ ✇❤✐❝❤ ✐♥ t✉r♥ ❞❡t❡r♠✐♥❡s t❤❡ t②♣❡ ♦❢ t❤❡ s♦rt✐♥❣ ❢✉♥❝t✐♦♥✳

❱■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✺✾

Slide 604

Quicksort: The Idea

• choose a pivot element, a
• Divide: partition the input into two sublists:

– those at most a in value – those exceeding a

• Conquer using recursive calls to sort the sublists
• Combine the sorted lists by appending one to the other

◗✉✐❝❦s♦rt ✇❛s ✐♥✈❡♥t❡❞ ❜② ❈✳ ❆✳ ❘✳ ❍♦❛r❡✱ ✇❤♦ ❤❛s ❥✉st ♠♦✈❡❞ ❢r♦♠ ❖①❢♦r❞ t♦ ▼✐❝r♦s♦❢t ❘❡s❡❛r❝❤✱ ❈❛♠❜r✐❞❣❡✳ ◗✉✐❝❦s♦rt ✇♦r❦s ❜② ❞✐✈✐❞❡ ❛♥❞ ❝♦♥q✉❡r✱ ❛ ❜❛s✐❝ ❛❧❣♦r✐t❤♠ ❞❡s✐❣♥ ♣r✐♥❝✐♣❧❡✳ ◗✉✐❝❦s♦rt ❝❤♦♦s❡s ❢r♦♠ t❤❡ ✐♥♣✉t s♦♠❡ ✈❛❧✉❡ a✱ ❝❛❧❧❡❞ t❤❡ ♣✐✈♦t✳ ■t ♣❛rt✐t✐♦♥s t❤❡ r❡♠❛✐♥✐♥❣ ✐t❡♠s ✐♥t♦ t✇♦ ♣❛rts✿ t❤♦s❡ ≤ a✱ ❛♥❞ t❤♦s❡ > a✳ ■t s♦rts ❡❛❝❤ ♣❛rt r❡❝✉rs✐✈❡❧②✱ t❤❡♥ ♣✉ts t❤❡ s♠❛❧❧❡r ♣❛rt ❜❡❢♦r❡ t❤❡ ❣r❡❛t❡r✳ ❚❤❡ ❝❧❡✈❡r❡st ❢❡❛t✉r❡ ♦❢ ❍♦❛r❡✬s ❛❧❣♦r✐t❤♠ ✇❛s t❤❛t t❤❡ ♣❛rt✐t✐♦♥ ❝♦✉❧❞ ❜❡ ❞♦♥❡ ✐♥ ♣❧❛❝❡ ❜② ❡①❝❤❛♥❣✐♥❣ ❛rr❛② ❡❧❡♠❡♥ts✳ ◗✉✐❝❦s♦rt ✇❛s ✐♥✈❡♥t❡❞ ❜❡❢♦r❡ r❡❝✉rs✐♦♥ ✇❛s ✇❡❧❧ ❦♥♦✇♥✱ ❛♥❞ ♣❡♦♣❧❡ ❢♦✉♥❞ ✐t ❡①tr❡♠❡❧② ❤❛r❞ t♦ ✉♥❞❡rst❛♥❞✳ ❆s ✉s✉❛❧✱ ✇❡ s❤❛❧❧ ❝♦♥s✐❞❡r ❛ ❧✐st ✈❡rs✐♦♥ ❜❛s❡❞ ♦♥ ❢✉♥❝t✐♦♥❛❧ ♣r♦❣r❛♠♠✐♥❣✳

❱■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✻✵

Slide 605

Quicksort: The Code

fun quick [] = [] | quick [x] = [x] | quick (a::bs) = let fun part (l,r,[]) : real list = (quick l) @ (a :: quick r) | part (l, r, x::xs) = if x<=a then part(x::l, r, xs) else part(l, x::r, xs) in part([],[],bs) end;

0.74 seconds to sort 10,000 random numbers

❖✉r ▼▲ q✉✐❝❦s♦rt ❝♦♣✐❡s t❤❡ ✐t❡♠s✳ ■t ✐s st✐❧❧ ♣r❡tt② ❢❛st✱ ❛♥❞ ✐t ✐s ♠✉❝❤ ❡❛s✐❡r t♦ ✉♥❞❡rst❛♥❞✳ ■t t❛❦❡s r♦✉❣❤❧② ✵✳✼✹ s❡❝♦♥❞s t♦ s♦rt rs✱ ♦✉r ❧✐st ♦❢ r❛♥❞♦♠ ♥✉♠❜❡rs✳ ❚❤❡ ❢✉♥❝t✐♦♥ ❞❡❝❧❛r❛t✐♦♥ ❝♦♥s✐sts ♦❢ t❤r❡❡ ❝❧❛✉s❡s✳ ❚❤❡ ✜rst ❤❛♥❞❧❡s t❤❡ ❡♠♣t② ❧✐st❀ t❤❡ s❡❝♦♥❞ ❤❛♥❞❧❡s s✐♥❣❧❡t♦♥ ❧✐sts ✭t❤♦s❡ ♦❢ t❤❡ ❢♦r♠ ❬①❪✮❀ t❤❡ t❤✐r❞ ❤❛♥❞❧❡s ❧✐sts ♦❢ t✇♦ ♦r ♠♦r❡ ❡❧❡♠❡♥ts✳ ❖❢t❡♥✱ ❧✐sts ♦❢ ❧❡♥❣t❤ ✉♣ t♦ ✜✈❡ ♦r s♦ ❛r❡ tr❡❛t❡❞ ❛s s♣❡❝✐❛❧ ❝❛s❡s t♦ ❜♦♦st s♣❡❡❞✳ ❚❤❡ ❧♦❝❛❧❧② ❞❡❝❧❛r❡❞ ❢✉♥❝t✐♦♥ ♣❛rt ♣❛rt✐t✐♦♥s t❤❡ ✐♥♣✉t ✉s✐♥❣ ❛ ❛s t❤❡ ♣✐✈♦t✳ ❚❤❡ ❛r❣✉♠❡♥ts ❧ ❛♥❞ r ❛❝❝✉♠✉❧❛t❡ ✐t❡♠s ❢♦r t❤❡ ❧❡❢t ✭≤ a✮ ❛♥❞ r✐❣❤t ✭> a✮ ♣❛rts ♦❢ t❤❡ ✐♥♣✉t✱ r❡s♣❡❝t✐✈❡❧②✳ ■t ✐s ♥♦t ❤❛r❞ t♦ ♣r♦✈❡ t❤❛t q✉✐❝❦s♦rt ❞♦❡s n log n ❝♦♠♣❛r✐s♦♥s✱ ✐♥ t❤❡ ❛✈❡r❛❣❡ ❝❛s❡ ❬✷✱ ♣❛❣❡ ✾✹❪✳ ❲✐t❤ r❛♥❞♦♠ ❞❛t❛✱ t❤❡ ♣✐✈♦t ✉s✉❛❧❧② ❤❛s ❛♥ ❛✈❡r❛❣❡ ✈❛❧✉❡ t❤❛t ❞✐✈✐❞❡s t❤❡ ✐♥♣✉t ✐♥ t✇♦ ❛♣♣r♦①✐♠❛t❡❧② ❡q✉❛❧ ♣❛rts✳ ❲❡ ❤❛✈❡ t❤❡ r❡❝✉rr❡♥❝❡ T(1) = 1 ❛♥❞ T(n) = 2T(n/2) + n✱ ✇❤✐❝❤ ✐s O(n log n)✳ ■♥ ♦✉r ❡①❛♠♣❧❡✱ ✐t ✐s ❛❜♦✉t ✷✸✺ t✐♠❡s ❢❛st❡r t❤❛♥ ✐♥s❡rt✐♦♥ s♦rt✳ ■♥ t❤❡ ✇♦rst ❝❛s❡✱ q✉✐❝❦s♦rt✬s r✉♥♥✐♥❣ t✐♠❡ ✐s q✉❛❞r❛t✐❝✦ ❆♥ ❡①❛♠♣❧❡ ✐s ✇❤❡♥ ✐ts ✐♥♣✉t ✐s ❛❧♠♦st s♦rt❡❞ ♦r r❡✈❡rs❡ s♦rt❡❞✳ ◆❡❛r❧② ❛❧❧ ♦❢ t❤❡ ✐t❡♠s ❡♥❞ ✉♣ ✐♥ ♦♥❡ ♣❛rt✐t✐♦♥❀ ✇♦r❦ ✐s ♥♦t ❞✐✈✐❞❡❞ ❡✈❡♥❧②✳ ❲❡ ❤❛✈❡ t❤❡ r❡❝✉rr❡♥❝❡ T(1) = 1 ❛♥❞ T(n + 1) = T(n) + n✱ ✇❤✐❝❤ ✐s O(n2)✳ ❘❛♥❞♦♠✐③✐♥❣ t❤❡ ✐♥♣✉t ♠❛❦❡s t❤❡ ✇♦rst ❝❛s❡ ❤✐❣❤❧② ✉♥❧✐❦❡❧②✳

❱■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✻✶

Slide 606

Append-Free Quicksort

fun quik([], sorted) = sorted | quik([x], sorted) = x::sorted | quik(a::bs, sorted) = let fun part (l, r, []) : real list = quik(l, a :: quik(r,sorted)) | part (l, r, x::xs) = if x<=a then part(x::l, r, xs) else part(l, x::r, xs) in part([],[],bs) end;

0.53 seconds to sort 10,000 random numbers

❚❤❡ ❧✐st s♦rt❡❞ ❛❝❝✉♠✉❧❛t❡s t❤❡ r❡s✉❧t ✐♥ t❤❡ ❝♦♠❜✐♥❡ st❛❣❡ ♦❢ t❤❡ q✉✐❝❦✲ s♦rt ❛❧❣♦r✐t❤♠✳ ❲❡ ❤❛✈❡ ❛❣❛✐♥ ✉s❡❞ t❤❡ st❛♥❞❛r❞ t❡❝❤♥✐q✉❡ ❢♦r ❡❧✐♠✐♥❛t✐♥❣ ❛♣♣❡♥❞✳ ❈❛❧❧✐♥❣ q✉✐❦✭①s✱s♦rt❡❞✮ r❡✈❡rs❡s t❤❡ ❡❧❡♠❡♥ts ♦❢ ①s ❛♥❞ ♣r❡♣❡♥❞s t❤❡♠ t♦ t❤❡ ❧✐st s♦rt❡❞✳ ▲♦♦❦✐♥❣ ❝❧♦s❡❧② ❛t ♣❛rt✱ ♦❜s❡r✈❡ t❤❛t q✉✐❦✭r✱s♦rt❡❞✮ ✐s ♣❡r❢♦r♠❡❞ ✜rst✳ ❚❤❡♥ ❛ ✐s ❝♦♥s❡❞ t♦ t❤✐s s♦rt❡❞ ❧✐st✳ ❋✐♥❛❧❧②✱ q✉✐❦ ✐s ❝❛❧❧❡❞ ❛❣❛✐♥ t♦ s♦rt t❤❡ ❡❧❡♠❡♥ts ♦❢ ❧✳ ❚❤❡ s♣❡❡❞✉♣ ✐s s✐❣♥✐✜❝❛♥t✳ ❆♥ ✐♠♣❡r❛t✐✈❡ q✉✐❝❦s♦rt ❝♦❞❡❞ ✐♥ P❛s❝❛❧ ✭t❛❦❡♥ ❢r♦♠ ❙❡❞❣❡✇✐❝❦ ❬✶✹❪✮ ✐s ❥✉st s❧✐❣❤t❧② ❢❛st❡r t❤❛♥ ❢✉♥❝t✐♦♥ q✉✐❦✳ ❚❤❡ ♥❡❛r✲❛❣r❡❡♠❡♥t ✐s s✉r♣r✐s✐♥❣ ❜❡❝❛✉s❡ t❤❡ ❝♦♠♣✉t❛t✐♦♥❛❧ ♦✈❡r❤❡❛❞s ♦❢ ❧✐sts ❡①✲ ❝❡❡❞ t❤♦s❡ ♦❢ ❛rr❛②s✳ ■♥ r❡❛❧✐st✐❝ ❛♣♣❧✐❝❛t✐♦♥s✱ ❝♦♠♣❛r✐s♦♥s ❛r❡ t❤❡ ❞♦♠✐♥❛♥t ❝♦st ❛♥❞ t❤❡ ♦✈❡r❤❡❛❞s ♠❛tt❡r ❡✈❡♥ ❧❡ss✳

❱■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✻✷

Slide 607

Merging Two Lists

Merge joins two sorted lists

fun merge([],ys) = ys : real list | merge(xs,[]) = xs | merge(x::xs, y::ys) = if x<=y then x::merge(xs, y::ys) else y::merge(x::xs, ys);

Generalises Insert to two lists Does at most m + n − 1 comparisons

▼❡r❣✐♥❣ ♠❡❛♥s ❝♦♠❜✐♥✐♥❣ t✇♦ s♦rt❡❞ ❧✐sts t♦ ❢♦r♠ ❛ ❧❛r❣❡r s♦rt❡❞ ❧✐st✳ ■t ❞♦❡s ❛t ♠♦st m+n ❝♦♠♣❛r✐s♦♥s✱ ✇❤❡r❡ m ❛♥❞ n ❛r❡ t❤❡ ❧❡♥❣t❤s ♦❢ t❤❡ ✐♥♣✉t ❧✐sts✳ ■❢ m ❛♥❞ n ❛r❡ r♦✉❣❤❧② ❡q✉❛❧ t❤❡♥ ✇❡ ❤❛✈❡ ❛ ❢❛st ✇❛② ♦❢ ❝♦♥str✉❝t✐♥❣ s♦rt❡❞ ❧✐sts❀ ✐❢ n = 1 t❤❡♥ ♠❡r❣✐♥❣ ❞❡❣❡♥❡r❛t❡s t♦ ✐♥s❡rt✐♦♥✱ ❞♦✐♥❣ ♠✉❝❤ ✇♦r❦ ❢♦r ❧✐tt❧❡ ❣❛✐♥✳ ▼❡r❣✐♥❣ ✐s t❤❡ ❜❛s✐s ♦❢ s❡✈❡r❛❧ s♦rt✐♥❣ ❛❧❣♦r✐t❤♠s❀ ✇❡ ❧♦♦❦ ❛t ❛ ❞✐✈✐❞❡✲ ❛♥❞✲❝♦♥q✉❡r ♦♥❡✳ ▼❡r❣❡s♦rt ✐s s❡❧❞♦♠ ❢♦✉♥❞ ✐♥ ❝♦♥✈❡♥t✐♦♥❛❧ ♣r♦❣r❛♠♠✐♥❣ ❜❡❝❛✉s❡ ✐t ✐s ❤❛r❞ t♦ ❝♦❞❡ ❢♦r ❛rr❛②s❀ ✐t ✇♦r❦s ♥✐❝❡❧② ✇✐t❤ ❧✐sts✳ ■t ❞✐✈✐❞❡s t❤❡ ✐♥♣✉t ✭✐❢ ♥♦♥✲tr✐✈✐❛❧✮ ✐♥t♦ t✇♦ r♦✉❣❤❧② ❡q✉❛❧ ♣❛rts✱ s♦rts t❤❡♠ r❡❝✉rs✐✈❡❧②✱ t❤❡♥ ♠❡r❣❡s t❤❡♠✳ ❋✉♥❝t✐♦♥ ♠❡r❣❡ ✐s ♥♦t ✐t❡r❛t✐✈❡❀ t❤❡ r❡❝✉rs✐♦♥ ✐s ❞❡❡♣✳ ❆♥ ✐t❡r❛t✐✈❡ ✈❡rs✐♦♥ ✐s ♦❢ ❧✐tt❧❡ ❜❡♥❡✜t ❢♦r t❤❡ s❛♠❡ r❡❛s♦♥s t❤❛t ❛♣♣❧② t♦ ❛♣♣❡♥❞ ✭▲❡❝t✳ ✹✮✳

❱■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✻✸

Slide 608

Top-down Merge sort

fun tmergesort [] = [] | tmergesort [x] = [x] | tmergesort xs = let val k = length xs div 2 in merge(tmergesort (take(xs, k)), tmergesort (drop(xs, k))) end;

O(n log n) comparisons in worst case

1.4 seconds to sort 10,000 random numbers

▼❡r❣❡s♦rt✬s ❞✐✈✐❞❡ st❛❣❡ ❞✐✈✐❞❡s t❤❡ ✐♥♣✉t ♥♦t ❜② ❝❤♦♦s✐♥❣ ❛ ♣✐✈♦t ✭❛s ✐♥ q✉✐❝❦s♦rt✮ ❜✉t ❜② s✐♠♣❧② ❝♦✉♥t✐♥❣ ♦✉t ❤❛❧❢ ♦❢ t❤❡ ❡❧❡♠❡♥ts✳ ❚❤❡ ❝♦♥q✉❡r st❛❣❡ ❛❣❛✐♥ ✐♥✈♦❧✈❡s r❡❝✉rs✐✈❡ ❝❛❧❧s✱ ❛♥❞ t❤❡ ❝♦♠❜✐♥❡ st❛❣❡ ✐♥✈♦❧✈❡s ♠❡r❣✐♥❣✳ ❋✉♥❝t✐♦♥ t♠❡r❣❡s♦rt t❛❦❡s r♦✉❣❤❧② ✶✳✹ s❡❝♦♥❞s t♦ s♦rt t❤❡ ❧✐st rs✳ ■♥ t❤❡ ✇♦rst ❝❛s❡✱ ♠❡r❣❡s♦rt ❞♦❡s O(n log n) ❝♦♠♣❛r✐s♦♥s✱ ✇✐t❤ t❤❡ s❛♠❡ r❡❝✉rr❡♥❝❡ ❡q✉❛t✐♦♥ ❛s ✐♥ q✉✐❝❦s♦rt✬s ❛✈❡r❛❣❡ ❝❛s❡✳ ❇❡❝❛✉s❡ t❛❦❡ ❛♥❞ ❞r♦♣ ❞✐✈✐❞❡ t❤❡ ✐♥♣✉t ✐♥ t✇♦ ❡q✉❛❧ ♣❛rts ✭t❤❡② ❞✐✛❡r ❛t ♠♦st ❜② ♦♥❡ ❡❧❡♠❡♥t✮✱ ✇❡ ❛❧✇❛②s ❤❛✈❡ T(n) = 2T(n/2) + n✳ ◗✉✐❝❦s♦rt ✐s ♥❡❛r❧② ✸ t✐♠❡s ❛s ❢❛st ✐♥ t❤❡ ❡①❛♠♣❧❡✳ ❇✉t ✐t r✐s❦s ❛ q✉❛❞r❛t✐❝ ✇♦rst ❝❛s❡✦ ▼❡r❣❡ s♦rt ✐s s❛❢❡ ❜✉t s❧♦✇✳ ❙♦ ✇❤✐❝❤ ❛❧❣♦r✐t❤♠ ✐s ❜❡st❄ ❲❡ ❤❛✈❡ s❡❡♥ ❛ t♦♣✲❞♦✇♥ ♠❡r❣❡s♦rt✳ ❇♦tt♦♠✲✉♣ ❛❧❣♦r✐t❤♠s ❛❧s♦ ❡①✐st✳ ❚❤❡② st❛rt ✇✐t❤ ❛ ❧✐st ♦❢ ♦♥❡✲❡❧❡♠❡♥t ❧✐sts ❛♥❞ r❡♣❡❛t❡❞❧② ♠❡r❣❡ ❛❞❥❛❝❡♥t ❧✐sts ✉♥t✐❧ ♦♥❧② ♦♥❡ ✐s ❧❡❢t✳ ❆ r❡✜♥❡♠❡♥t✱ ✇❤✐❝❤ ❡①♣❧♦✐ts ❛♥② ✐♥✐t✐❛❧ ♦r❞❡r ❛♠♦♥❣ t❤❡ ✐♥♣✉t✱ ✐s t♦ st❛rt ✇✐t❤ ❛ ❧✐st ♦❢ ✐♥❝r❡❛s✐♥❣ ♦r ❞❡❝r❡❛s✐♥❣ r✉♥s ♦❢ ✐♥♣✉t ✐t❡♠s✳

❱■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✻✹

Slide 609

Summary of Sorting Algorithms

Optimal is O(n log n) comparisons Insertion sort: simple to code; too slow (quadratic) [174 secs] Quicksort: fast on average; quadratic in worst case [0.53 secs] Mergesort: optimal in theory; often slower than quicksort [1.4 secs] MATCH THE ALGORITHM TO THE APPLICATION

◗✉✐❝❦s♦rt✬s ✇♦rst ❝❛s❡ ❝❛♥♥♦t ❜❡ ✐❣♥♦r❡❞✳ ❋♦r ❧❛r❣❡ n✱ ❛ ❝♦♠♣❧❡①✐t② ♦❢ O(n2) ✐s ❝❛t❛str♦♣❤✐❝✳ ▼❡r❣❡s♦rt ❤❛s ❛♥ O(n log n) ✇♦rst ❝❛s❡ r✉♥♥✐♥❣ t✐♠❡✱ ✇❤✐❝❤ ✐s ♦♣t✐♠❛❧✱ ❜✉t ✐t ✐s t②♣✐❝❛❧❧② s❧♦✇❡r t❤❛♥ q✉✐❝❦s♦rt ❢♦r r❛♥❞♦♠ ❞❛t❛✳ ◆♦♥✲❝♦♠♣❛r✐s♦♥ s♦rt✐♥❣ ❞❡s❡r✈❡s ♠❡♥t✐♦♥✐♥❣✳ ❲❡ ❝❛♥ s♦rt ❛ ❧❛r❣❡ ♥✉♠❜❡r ♦❢ s♠❛❧❧ ✐♥t❡❣❡rs ✉s✐♥❣ t❤❡✐r r❛❞✐① r❡♣r❡s❡♥t❛t✐♦♥ ✐♥ O(n) t✐♠❡✳ ❚❤✐s r❡s✉❧t ❞♦❡s ♥♦t ❝♦♥tr❛❞✐❝t t❤❡ ❝♦♠♣❛r✐s♦♥✲❝♦✉♥t✐♥❣ ❛r❣✉♠❡♥t ❜❡❝❛✉s❡ ❝♦♠♣❛r✐s♦♥s ❛r❡ ♥♦t ✉s❡❞ ❛t ❛❧❧✳ ▲✐♥❡❛r t✐♠❡ ✐s ❛❝❤✐❡✈❛❜❧❡ ♦♥❧② ✐❢ t❤❡ ❣r❡❛t❡st ✐♥t❡❣❡r ✐s ✜①❡❞ ✐♥ ❛❞✈❛♥❝❡❀ ❛s n ❣♦❡s t♦ ✐♥✜♥✐t②✱ ✐♥❝r❡❛s✐♥❣❧② ♠❛♥② ♦❢ t❤❡ ✐t❡♠s ❛r❡ t❤❡ s❛♠❡✳ ■t ✐s ❛ s✐♠♣❧❡ s♣❡❝✐❛❧ ❝❛s❡✳ ▼❛♥② ♦t❤❡r s♦rt✐♥❣ ❛❧❣♦r✐t❤♠s ❡①✐st✳ ❲❡ ❤❛✈❡ ♥♦t ❝♦♥s✐❞❡r❡❞ t❤❡ ♣r♦❜✲ ❧❡♠ ♦❢ s♦rt✐♥❣ ❤✉❣❡ ❛♠♦✉♥ts ♦❢ ❞❛t❛ ✉s✐♥❣ ❡①t❡r♥❛❧ st♦r❛❣❡ ♠❡❞✐❛ s✉❝❤ ❛s ♠❛❣♥❡t✐❝ t❛♣❡✳ ▲❡❛r♥✐♥❣ ❣✉✐❞❡✳ ❘❡❧❛t❡❞ ♠❛t❡r✐❛❧ ✐s ✐♥ ▼▲ ❢♦r t❤❡ ❲♦r❦✐♥❣ Pr♦❣r❛♠♠❡r✱ ♣❛❣❡s ✶✵✽✕✶✶✸✳

❱■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✻✺

Slide 701

An Enumeration Type

datatype vehicle = Bike | Motorbike | Car | Lorry;

• We have declared a new type, namely vehicle,
• . . . along with four new constants.
• They are the constructors of the datatype.

❚❤❡ ❞❛t❛t②♣❡ ❞❡❝❧❛r❛t✐♦♥ ❛❞❞s ❛ ♥❡✇ t②♣❡ t♦ ♦✉r ▼▲ s❡ss✐♦♥✳ ❚②♣❡ ✈❡❤✐❝❧❡ ✐s ❛s ❣♦♦❞ ❛s ❛♥② ❜✉✐❧t✲✐♥ t②♣❡ ❛♥❞ ❡✈❡♥ ❛❞♠✐ts ♣❛tt❡r♥✲♠❛t❝❤✐♥❣✳ ❚❤❡ ❢♦✉r ♥❡✇ ✐❞❡♥t✐✜❡rs ♦❢ t②♣❡ ✈❡❤✐❝❧❡ ❛r❡ ❝❛❧❧❡❞ ❝♦♥str✉❝t♦rs✳ ❲❡ ❝♦✉❧❞ r❡♣r❡s❡♥t t❤❡ ✈❛r✐♦✉s ✈❡❤✐❝❧❡s ❜② t❤❡ ♥✉♠❜❡rs ✵✕✸✳ ❍♦✇❡✈❡r✱ t❤❡ ❝♦❞❡ ✇♦✉❧❞ ❜❡ ❤❛r❞ t♦ r❡❛❞ ❛♥❞ ❡✈❡♥ ❤❛r❞❡r t♦ ♠❛✐♥t❛✐♥✳ ❈♦♥s✐❞❡r ❛❞❞✐♥❣ ❚r✐❝②❝❧❡ ❛s ❛ ♥❡✇ ✈❡❤✐❝❧❡✳■❢ ✇❡ ✇❛♥t❡❞ t♦ ❛❞❞ ✐t ❜❡❢♦r❡ ❇✐❦❡✱ t❤❡♥ ❛❧❧ t❤❡ ♥✉♠❜❡rs ✇♦✉❧❞ ❤❛✈❡ t♦ ❜❡ ❝❤❛♥❣❡❞✳ ❯s✐♥❣ ❞❛t❛t②♣❡✱ s✉❝❤ ❛❞❞✐t✐♦♥s ❛r❡ tr✐✈✐❛❧ ❛♥❞ t❤❡ ❝♦♠♣✐❧❡r ❝❛♥ ✭❛t ❧❡❛st s♦♠❡t✐♠❡s✮ ✇❛r♥ ✉s ✇❤❡♥ ✐t ❡♥❝♦✉♥t❡rs ❛ ❢✉♥❝t✐♦♥ ❞❡❝❧❛r❛t✐♦♥ t❤❛t ❞♦❡s♥✬t ②❡t ❤❛✈❡ ❛ ❝❛s❡ ❢♦r ❚r✐❝②❝❧❡✳ ❘❡♣r❡s❡♥t✐♥❣ ✈❡❤✐❝❧❡s ❜② str✐♥❣s ❧✐❦❡ ✧❇✐❦❡✧✱ ✧❈❛r✧✱ ❡t❝✳✱ ✐s ❛❧s♦ ❜❛❞✳ ❈♦♠♣❛r✐♥❣ str✐♥❣ ✈❛❧✉❡s ✐s s❧♦✇ ❛♥❞ t❤❡ ❝♦♠♣✐❧❡r ❝❛♥✬t ✇❛r♥ ✉s ♦❢ ♠✐s✲ s♣❡❧❧✐♥❣s ❧✐❦❡ ✧▼❖t♦r❜✐❦❡✧✿ t❤❡② ✇✐❧❧ ♠❛❦❡ ♦✉r ❝♦❞❡ ❢❛✐❧✳ ▼♦st ♣r♦❣r❛♠♠✐♥❣ ❧❛♥❣✉❛❣❡s ❛❧❧♦✇ t❤❡ ❞❡❝❧❛r❛t✐♦♥ ♦❢ t②♣❡s ❧✐❦❡ ✈❡❤✐❝❧❡✳ ❇❡❝❛✉s❡ t❤❡② ❝♦♥s✐st ♦❢ ❛ s❡r✐❡s ♦❢ ✐❞❡♥t✐✜❡rs✱ t❤❡② ❛r❡ ❝❛❧❧❡❞ ❡♥✉♠❡r❛t✐♦♥ t②♣❡s✳ ❖t❤❡r ❝♦♠♠♦♥ ❡①❛♠♣❧❡s ❛r❡ ❞❛②s ♦❢ t❤❡ ✇❡❡❦ ♦r ❝♦❧♦✉rs✳ ❚❤❡ ❝♦♠♣✐❧❡r ❝❤♦♦s❡s t❤❡ ✐♥t❡❣❡rs ❢♦r ✉s❀ t②♣❡✲❝❤❡❝❦✐♥❣ ♣r❡✈❡♥ts ✉s ❢r♦♠ ❝♦♥❢✉s✐♥❣ ❇✐❦❡ ✇✐t❤ ❘❡❞ ♦r ❙✉♥❞❛②✳

❱■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✻✻

Slide 702

Declaring a Function on Vehicles

fun wheels Bike = 2 | wheels Motorbike = 2 | wheels Car = 4 | wheels Lorry = 18; > val wheels = fn : vehicle -> int

• Datatype constructors can be used in patterns.
• Pattern-matching is fast, even complicated nested patterns.

❚❤❡ ❜❡❛✉t② ♦❢ ❞❛t❛t②♣❡ ❞❡❝❧❛r❛t✐♦♥s ✐s t❤❛t t❤❡ ♥❡✇ t②♣❡s ❜❡❤❛✈❡ ❛s ✐❢ t❤❡② ✇❡r❡ ❜✉✐❧t ✐♥t♦ ▼▲✳ ❚②♣❡✲❝❤❡❝❦✐♥❣ ❝❛t❝❤❡s ❝♦♠♠♦♥ ❡rr♦rs✱ s✉❝❤ ❛s ♠✐①✐♥❣ ✉♣ ❞✐✛❡r❡♥t ❞❛t❛t②♣❡s ✐♥ ❛ ❢✉♥❝t✐♦♥ ❧✐❦❡ ✇❤❡❡❧s✱ ❛s ✇❡❧❧ ❛s ♠✐ss✐♥❣ ❛♥❞ r❡❞✉♥❞❛♥t ♣❛tt❡r♥s✳ ◆♦t❡✿ ▼▲ ❞♦❡s ♥♦t ❛❧✇❛②s ❝❛t❝❤ ♠✐ss♣❡❧t ❝♦♥str✉❝t♦rs✳ ■❢ ♦♥❡ ❛♣♣❡❛rs ❛s t❤❡ ❧❛st ♣❛tt❡r♥✱ ✐t ♠✐❣❤t ❜❡ t❛❦❡♥ ❛s ❛ ✈❛r✐❛❜❧❡ ♥❛♠❡✳ ▼② ❜♦♦❦ ❣✐✈❡s ❛♥ ❡①❛♠♣❧❡ ❬✶✸✱ ♣❛❣❡ ✶✸✶❪✳

❱■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✻✼

Slide 703

A Datatype with Constructor Functions

datatype vehicle = Bike | Motorbike of int | Car

• f bool

| Lorry

• f int;
• Constructor functions (like Lorry) make distinct values.
• Different kinds of vehicle can belong to one list:

[Bike, Car true, Motorbike 450];

▼▲ ❣❡♥❡r❛❧✐③❡s t❤❡ ♥♦t✐♦♥ ♦❢ ❡♥✉♠❡r❛t✐♦♥ t②♣❡ t♦ ❛❧❧♦✇ ❞❛t❛ t♦ ❜❡ ❛ss♦✲ ❝✐❛t❡❞ ✇✐t❤ ❡❛❝❤ ❝♦♥str✉❝t♦r✳ ❚❤❡ ❝♦♥str✉❝t♦r ❇✐❦❡ ✐s ❛ ✈❡❤✐❝❧❡ ❛❧❧ ❜② ✐ts❡❧❢✱ ❜✉t t❤❡ ♦t❤❡r t❤r❡❡ ❝♦♥str✉❝t♦rs ❛r❡ ❢✉♥❝t✐♦♥s ❢♦r ❝r❡❛t✐♥❣ ✈❡❤✐❝❧❡s✳ ❙✐♥❝❡ ✇❡ ♠✐❣❤t ✜♥❞ ✐t ❤❛r❞ t♦ r❡♠❡♠❜❡r ✇❤❛t t❤❡ ✈❛r✐♦✉s ✐♥t ❛♥❞ ❜♦♦❧ ❝♦♠♣♦♥❡♥ts ❛r❡ ❢♦r✱ ✐t ✐s ✇✐s❡ t♦ ✐♥❝❧✉❞❡ ❝♦♠♠❡♥ts ✐♥ ❝♦♠♣❧❡① ❞❡❝❧❛r❛t✐♦♥s✳ ■♥ ▼▲✱ ❝♦♠♠❡♥ts ❛r❡ ❡♥❝❧♦s❡❞ ✐♥ t❤❡ ❜r❛❝❦❡ts ✭✯ ❛♥❞ ✯✮✳ Pr♦❣r❛♠♠❡rs s❤♦✉❧❞ ❝♦♠♠❡♥t t❤❡✐r ❝♦❞❡ t♦ ❡①♣❧❛✐♥ ❞❡s✐❣♥ ❞❡❝✐s✐♦♥s ❛♥❞ ❦❡② ❢❡❛t✉r❡s ♦❢ t❤❡ ❛❧❣♦r✐t❤♠s ✭s♦♠❡t✐♠❡s ❜② ❝✐t✐♥❣ ❛ r❡❢❡r❡♥❝❡ ✇♦r❦✮✳

❞❛t❛t②♣❡ ✈❡❤✐❝❧❡ ❂ ❇✐❦❡ ⑤ ▼♦t♦r❜✐❦❡ ♦❢ ✐♥t ✭✯❡♥❣✐♥❡ s✐③❡ ✐♥ ❈❈s✯✮ ⑤ ❈❛r ♦❢ ❜♦♦❧ ✭✯tr✉❡ ✐❢ ❛ ❘❡❧✐❛♥t ❘♦❜✐♥✯✮ ⑤ ▲♦rr② ♦❢ ✐♥t❀ ✭✯♥✉♠❜❡r ♦❢ ✇❤❡❡❧s✯✮

❚❤❡ ❧✐st s❤♦✇♥ ♦♥ t❤❡ s❧✐❞❡ r❡♣r❡s❡♥ts ❛ ❜✐❝②❝❧❡✱ ❛ ❘❡❧✐❛♥t ❘♦❜✐♥ ❛♥❞ ❛ ❧❛r❣❡ ♠♦t♦r❜✐❦❡✳ ■t ❝❛♥ ❜❡ ❛❧♠♦st s❡❡♥ ❛s ❛ ♠✐①❡❞✲t②♣❡ ❧✐st ❝♦♥t❛✐♥✐♥❣ ✐♥t❡❣❡rs ❛♥❞ ❜♦♦❧❡❛♥s✳ ■t ✐s ❛❝t✉❛❧❧② ❛ ❧✐st ♦❢ ✈❡❤✐❝❧❡s❀ ❞❛t❛t②♣❡s ❧❡ss❡♥ t❤❡ ✐♠♣❛❝t ♦❢ t❤❡ r❡str✐❝t✐♦♥ t❤❛t ❛❧❧ ❧✐st ❡❧❡♠❡♥ts ♠✉st ❤❛✈❡ t❤❡ s❛♠❡ t②♣❡✳

❱■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✻✽

Slide 704

A Finer Wheel Computation

fun wheels Bike = 2 | wheels (Motorbike _) = 2 | wheels (Car robin) = if robin then 3 else 4 | wheels (Lorry w) = w; > val wheels = fn : vehicle -> int

❚❤✐s ❢✉♥❝t✐♦♥ ❝♦♥s✐sts ♦❢ ❢♦✉r ❝❧❛✉s❡s✿

• ❆ ❇✐❦❡ ❤❛s t✇♦ ✇❤❡❡❧s✳
• ❆ ▼♦t♦r❜✐❦❡ ❤❛s t✇♦ ✇❤❡❡❧s✳
• ❆ ❘❡❧✐❛♥t ❘♦❜✐♥ ❤❛s t❤r❡❡ ✇❤❡❡❧s❀ ❛❧❧ ♦t❤❡r ❝❛rs ❤❛✈❡ ❢♦✉r✳
• ❆ ▲♦rr② ❤❛s t❤❡ ♥✉♠❜❡r ♦❢ ✇❤❡❡❧s st♦r❡❞ ✇✐t❤ ✐ts ❝♦♥str✉❝t♦r✳

❚❤❡r❡ ✐s ♥♦ ♦✈❡r❧❛♣ ❜❡t✇❡❡♥ t❤❡ ▼♦t♦r❜✐❦❡ ❛♥❞ ▲♦rr② ❝❛s❡s✳ ❆❧t❤♦✉❣❤ ▼♦t♦r❜✐❦❡ ❛♥❞ ▲♦rr② ❜♦t❤ ❤♦❧❞ ❛♥ ✐♥t❡❣❡r✱ ▼▲ t❛❦❡s t❤❡ ❝♦♥str✉❝t♦r ✐♥t♦ ❛❝❝♦✉♥t✳ ❆ ▼♦t♦r❜✐❦❡ ✐s ❞✐st✐♥❝t ❢r♦♠ ❛♥② ▲♦rr②✳ ❱❡❤✐❝❧❡s ❛r❡ ♦♥❡ ❡①❛♠♣❧❡ ♦❢ ❛ ❝♦♥❝❡♣t ❝♦♥s✐st✐♥❣ ♦❢ s❡✈❡r❛❧ ✈❛r✐❡t✐❡s ✇✐t❤ ❞✐st✐♥❝t ❢❡❛t✉r❡s✳ ▼♦st ♣r♦❣r❛♠♠✐♥❣ ❧❛♥❣✉❛❣❡s ❝❛♥ r❡♣r❡s❡♥t s✉❝❤ ❝♦♥❝❡♣ts ✉s✐♥❣ s♦♠❡t❤✐♥❣ ❛♥❛❧♦❣♦✉s t♦ ❞❛t❛t②♣❡s✳ ✭❚❤❡② ❛r❡ s♦♠❡t✐♠❡s ❝❛❧❧❡❞ ✉♥✐♦♥ t②♣❡s ♦r ✈❛r✐❛♥t r❡❝♦r❞s✱ ✇❤♦s❡ t❛❣ ✜❡❧❞s ♣❧❛② t❤❡ r♦❧❡ ♦❢ t❤❡ ❝♦♥str✉❝t♦rs✳✮

❱■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✻✾

Slide 705

Nested Pattern-Matching

fun greener (_, Bike) = false | greener (Bike, _) = true | greener (_, Motorbike _) = false | greener (Motorbike _, _) = true | greener (_, Car _) = false | greener (Car _, _) = true | greener (_, Lorry _) = false;

note wildcards in patterns

• rder of evaluation is crucial!

❋♦r ❛♥♦t❤❡r ❡①❛♠♣❧❡ ♦❢ ♣❛tt❡r♥✲♠❛t❝❤✐♥❣✱ ❤❡r❡ ✐s ❛ ❢✉♥❝t✐♦♥ t♦ ❝♦♠♣❛r❡ ✈❡❤✐❝❧❡s ❢♦r ❡♥✈✐r♦♥♠❡♥t❛❧ ❢r✐❡♥❞❧✐♥❡ss✳ ❆ ❇✐❦❡ ✐s ❣r❡❡♥❡r t❤❛♥ ❛ ▼♦t♦r❜✐❦❡✱ ✇❤✐❝❤ ✐s ❣r❡❡♥❡r t❤❛♥ ❛ ❈❛r✱ ✇❤✐❝❤ ✐s ❣r❡❡♥❡r t❤❛♥ ❛ ▲♦rr②✳ ❚❤❡ ❝♦❞❡ s❤♦✇♥ ❛❜♦✈❡ ✐s ❝♦♠♣❧✐❝❛t❡❞ ❛♥❞ r❡❧✐❡s ❤❡❛✈✐❧② ♦♥ ▼▲✬s ♦r❞❡r ♦❢ ❡✈❛❧✉❛t✐♦♥✳ ◆♦t❤✲ ✐♥❣ ✐s ❣r❡❡♥❡r t❤❛♥ ❛ ❇✐❦❡❀ ❛ ❇✐❦❡ ✐s ❣r❡❡♥❡r t❤❛♥ ❡✈❡r②t❤✐♥❣ ❡❧s❡❀ ♥♦t❤✐♥❣ ❧❡❢t ✭❇✐❦❡s ❤❛✈❡ ❜❡❡♥ ❞❡❛❧t ✇✐t❤✮ ✐s ❣r❡❡♥❡r t❤❛♥ ❛ ▼♦t♦r❜✐❦❡✱ ❡t❝✳ ❚❤❡ ❛❧t❡r♥❛t✐♥❣ tr✉❡s ❛♥❞ ❢❛❧s❡s ♠❛❦❡ t❤❡ ❝♦❞❡ ❤❛r❞ t♦ r❡❛❞✳ ❈❧❡❛r❡r ✐s t♦ ❧✐st ❛❧❧ t❤❡ tr✉❡ ❝❛s❡s ❛♥❞ ❧❡t ♦♥❡ ✇✐❧❞❝❛r❞ ❝❛t❝❤ ❛❧❧ t❤❡ ❢❛❧s❡ ♦♥❡s✳ ❇✉t ✇❤❛t ❤❛♣♣❡♥s ✐♥ t❤✐s st②❧❡ ✐❢ ✇❡ ❛❞❞ ❛ ❢❡✇ ♠♦r❡ ❝♦♥str✉❝t♦rs❄

❢✉♥ ❣r❡❡♥❡r ✭❇✐❦❡✱ ▼♦t♦r❜✐❦❡ ❴✮ ❂ tr✉❡ ⑤ ❣r❡❡♥❡r ✭❇✐❦❡✱ ❈❛r ❴✮ ❂ tr✉❡ ⑤ ❣r❡❡♥❡r ✭❇✐❦❡✱ ▲♦rr② ❴✮ ❂ tr✉❡ ⑤ ❣r❡❡♥❡r ✭▼♦t♦r❜✐❦❡ ❴✱ ❈❛r ❴✮ ❂ tr✉❡ ⑤ ❣r❡❡♥❡r ✭▼♦t♦r❜✐❦❡ ❴✱ ▲♦rr② ❴✮ ❂ tr✉❡ ⑤ ❣r❡❡♥❡r ✭❈❛r ❴✱ ▲♦rr② ❴✮ ❂ tr✉❡ ⑤ ❣r❡❡♥❡r ❴ ❂ ❢❛❧s❡❀

❈❧❛✉s❡s t❤❛t ❞❡♣❡♥❞ ✉♣♦♥ t❤❡ ♦r❞❡r ♦❢ ❡✈❛❧✉❛t✐♦♥ ❛r❡ ♥♦t tr✉❡ ❡q✉❛t✐♦♥s✳ ■❢ t❤❡r❡ ❛r❡ ♠❛♥② ❝♦♥str✉❝t♦rs✱ t❤❡ ❜❡st ✇❛② ♦❢ ❝♦♠♣❛r✐♥❣ t❤❡♠ ✐s ❜② ♠❛♣♣✐♥❣ ❜♦t❤ t♦ ✐♥t❡❣❡rs ❛♥❞ ❝♦♠♣❛r✐♥❣ t❤♦s❡ ✭✉s✐♥❣ <✮✳ ❚❤❡ ♣♦✐♥t t♦ t❛❦❡ ❢r♦♠ t❤✐s ❡①❛♠♣❧❡ ✐s t❤❛t ♣❛tt❡r♥s ♠❛② ❝♦♠❜✐♥❡ ❞❛t❛t②♣❡ ❝♦♥str✉❝t♦rs ✇✐t❤ t✉♣❧❡s✱ ❧✐sts✱ ♥✉♠❜❡rs✱ str✐♥❣s✱ ❡t❝✳ ❚❤❡r❡ ✐s ♥♦ ❧✐♠✐t ♦♥ t❤❡ s✐③❡ ♦❢ ♣❛tt❡r♥s ♦r t❤❡ ♥✉♠❜❡r ♦❢ ❝❧❛✉s❡s ✐♥ ❛ ❢✉♥❝t✐♦♥ ❞❡❝❧❛r❛✲ t✐♦♥✳ ▼♦st ▼▲ s②st❡♠s ♣❡r❢♦r♠ ♣❛tt❡r♥✲♠❛t❝❤✐♥❣ ❡✣❝✐❡♥t❧②✳

❱■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✼✵

Slide 706

Error Handling: Exceptions

What if a FAULT occurs during a computation?

• (Arithmetic overflow or division by zero are hard to predict.)

Exception-handling lets us recover gracefully.

• Raising an exception abandons the current computation.
• Handling the exception attempts an alternative computation.
• The raising and handling can be far apart in the code.
• Errors of different sorts can be handled separately.

❊①❝❡♣t✐♦♥s ❛r❡ ♥❡❝❡ss❛r② ❜❡❝❛✉s❡ ✐t ✐s ♥♦t ❛❧✇❛②s ♣♦ss✐❜❧❡ t♦ t❡❧❧ ✐♥ ❛❞✲ ✈❛♥❝❡ ✇❤❡t❤❡r ♦r ♥♦t ❛ ❛ s❡❛r❝❤ ✇✐❧❧ ❧❡❛❞ t♦ ❛ ❞❡❛❞ ❡♥❞ ♦r ✇❤❡t❤❡r ❛ ♥✉♠❡r✐❝❛❧ ❝❛❧❝✉❧❛t✐♦♥ ✇✐❧❧ ❡♥❝♦✉♥t❡r ❡rr♦rs s✉❝❤ ❛s ♦✈❡r✢♦✇ ♦r ❞✐✈✐❞❡ ❜② ③❡r♦✳ ❘❛t❤❡r t❤❛♥ ❥✉st ❝r❛s❤✐♥❣✱ ♣r♦❣r❛♠s s❤♦✉❧❞ ❝❤❡❝❦ ✇❤❡t❤❡r t❤✐♥❣s ❤❛✈❡ ❣♦♥❡ ✇r♦♥❣✱ ❛♥❞ ♣❡r❤❛♣s ❛tt❡♠♣t ❛♥ ❛❧t❡r♥❛t✐✈❡ ❝♦♠♣✉t❛t✐♦♥ ✭♣❡r❤❛♣s ✉s✐♥❣ ❛ ❞✐✛❡r✲ ❡♥t ❛❧❣♦r✐t❤♠ ♦r ❤✐❣❤❡r ♣r❡❝✐s✐♦♥✮✳ ❆ ♥✉♠❜❡r ♦❢ ♠♦❞❡r♥ ❧❛♥❣✉❛❣❡s ♣r♦✈✐❞❡ ❡①❝❡♣t✐♦♥ ❤❛♥❞❧✐♥❣✳

❱■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✼✶

Slide 707

Exceptions in ML

exception Failure;

Declaring

exception NoChange of int; raise Failure

Raising

raise (NoChange n) E handle P1 => E1 | ... | Pn => En

Handling ❊❛❝❤ ❡①❝❡♣t✐♦♥ ❞❡❝❧❛r❛t✐♦♥ ✐♥tr♦❞✉❝❡s ❛ ❞✐st✐♥❝t s♦rt ♦❢ ❡①❝❡♣t✐♦♥✱ ✇❤✐❝❤ ❝❛♥ ❜❡ ❤❛♥❞❧❡❞ s❡♣❛r❛t❡❧② ❢r♦♠ ♦t❤❡rs✳ ❊①❝❡♣t✐♦♥ ♥❛♠❡s ❛r❡ ❝♦♥str✉❝t♦rs ♦❢ t❤❡ s♣❡❝✐❛❧ ❞❛t❛t②♣❡ ❡①♥✳ ❚❤✐s ✐s ❛ ♣❡❝✉❧✐❛r✐t② ♦❢ ▼▲ t❤❛t ❧❡ts ❡①❝❡♣t✐♦♥✲ ❤❛♥❞❧❡rs ✉s❡ ♣❛tt❡r♥✲♠❛t❝❤✐♥❣✳ ◆♦t❡ t❤❛t ❡①❝❡♣t✐♦♥ ❋❛✐❧✉r❡ ✐s ❥✉st ❛♥ ❡rr♦r ✐♥❞✐❝❛t✐♦♥✱ ✇❤✐❧❡ ◆♦❈❤❛♥❣❡ n ❝❛rr✐❡s ❢✉rt❤❡r ✐♥❢♦r♠❛t✐♦♥✿ t❤❡ ✐♥t❡❣❡r n✳ ❚❤❡ ❡✛❡❝t ♦❢ r❛✐s❡ E ✐s t♦ ❛❜♦rt ❢✉♥❝t✐♦♥ ❝❛❧❧s r❡♣❡❛t❡❞❧② ✉♥t✐❧ ❡♥❝♦✉♥✲ t❡r✐♥❣ ❛ ❤❛♥❞❧❡r t❤❛t ♠❛t❝❤❡s E✳ ❚❤❡ ♠❛t❝❤✐♥❣ ❤❛♥❞❧❡r ❝❛♥ ♦♥❧② ❜❡ ❢♦✉♥❞ ❞②✲ ♥❛♠✐❝❛❧❧② ✭❞✉r✐♥❣ ❡①❡❝✉t✐♦♥✮❀ ❝♦♥tr❛st ✇✐t❤ ❤♦✇ ▼▲ ❛ss♦❝✐❛t❡s ♦❝❝✉rr❡♥❝❡s ♦❢ ✐❞❡♥t✐✜❡rs ✇✐t❤ t❤❡✐r ♠❛t❝❤✐♥❣ ❞❡❝❧❛r❛t✐♦♥s✱ ✇❤✐❝❤ ❞♦❡s ♥♦t r❡q✉✐r❡ r✉♥✲ ♥✐♥❣ t❤❡ ♣r♦❣r❛♠✳ ❖♥❡ ❝r✐t✐❝✐s♠ ♦❢ ▼▲✬s ❡①❝❡♣t✐♦♥s ✐s t❤❛t✖✉♥❧✐❦❡ t❤❡ ❏❛✈❛ ❧❛♥❣✉❛❣❡ ✖ ♥♦t❤✐♥❣ ✐♥ ❛ ❢✉♥❝t✐♦♥ ❞❡❝❧❛r❛t✐♦♥ ✐♥❞✐❝❛t❡s ✇❤✐❝❤ ❡①❝❡♣t✐♦♥s ✐t ♠✐❣❤t r❛✐s❡✳ ❖♥❡ ❛❧t❡r♥❛t✐✈❡ t♦ ❡①❝❡♣t✐♦♥s ✐s t♦ ✐♥st❡❛❞ r❡t✉r♥ ❛ ✈❛❧✉❡ ♦❢ ❞❛t❛t②♣❡ ♦♣t✐♦♥✳

❞❛t❛t②♣❡ ✬❛ ♦♣t✐♦♥ ❂ ◆❖◆❊ ⑤ ❙❖▼❊ ♦❢ ✬❛❀

◆❖◆❊ s✐❣♥✐✜❡s ❡rr♦r✱ ✇❤✐❧❡ ❙❖▼❊ x r❡t✉r♥s t❤❡ s♦❧✉t✐♦♥ x✳ ❚❤✐s ❛♣♣r♦❛❝❤ ❧♦♦❦s ❝❧❡❛♥✱ ❜✉t t❤❡ ❞r❛✇❜❛❝❦ ✐s t❤❛t ♠❛♥② ♣❧❛❝❡s ✐♥ t❤❡ ❝♦❞❡ ✇♦✉❧❞ ❤❛✈❡ t♦ ❝❤❡❝❦ ❢♦r ◆❖◆❊✳

❱■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✼✷

Slide 708

Making Change with Exceptions

exception Change; fun change (till, 0) = [] | change ([], amt) = raise Change | change (c::till, amt) = if amt<0 then raise Change else (c :: change(c::till, amt-c)) handle Change => change(till, amt); > val change = fn : int list * int -> int list

■♥ ▲❡❝t✳ ✺ ✇❡ ❝♦♥s✐❞❡r❡❞ t❤❡ ♣r♦❜❧❡♠ ♦❢ ♠❛❦✐♥❣ ❝❤❛♥❣❡✳ ❚❤❡ ❣r❡❡❞② ❛❧❣♦r✐t❤♠ ♣r❡s❡♥t❡❞ t❤❡r❡ ❝♦✉❧❞ ♥♦t ❡①♣r❡ss ✻ ✉s✐♥❣ ✺ ❛♥❞ ✷ ❜❡❝❛✉s❡ ✐t ❛❧✇❛②s t♦♦❦ t❤❡ ❧❛r❣❡st ❝♦✐♥✳ ❘❡t✉r♥✐♥❣ t❤❡ ❧✐st ♦❢ ❛❧❧ ♣♦ss✐❜❧❡ s♦❧✉t✐♦♥s ❛✈♦✐❞s t❤❛t ♣r♦❜❧❡♠ r❛t❤❡r ❡①♣❡♥s✐✈❡❧②✿ ✇❡ ♦♥❧② ♥❡❡❞ ♦♥❡ s♦❧✉t✐♦♥✳ ❯s✐♥❣ ❡①❝❡♣t✐♦♥s✱ ✇❡ ❝❛♥ ❝♦❞❡ ❛ ❜❛❝❦tr❛❝❦✐♥❣ ❛❧❣♦r✐t❤♠✿ ♦♥❡ t❤❛t ❝❛♥ ✉♥❞♦ ♣❛st ❞❡❝✐s✐♦♥s ✐❢ ✐t ❝♦♠❡s t♦ ❛ ❞❡❛❞ ❡♥❞✳ ❚❤❡ ❡①❝❡♣t✐♦♥ ❈❤❛♥❣❡ ✐s r❛✐s❡❞ ✐❢ ✇❡ r✉♥ ♦✉t ♦❢ ❝♦✐♥s ✭✇✐t❤ ❛ ♥♦♥✲③❡r♦ ❛♠♦✉♥t✮ ♦r ✐❢ t❤❡ ❛♠♦✉♥t ❣♦❡s ♥❡❣❛t✐✈❡✳ ❲❡ ❛❧✇❛②s tr② t❤❡ ❧❛r❣❡st ❝♦✐♥✱ ❜✉t ❡♥❝❧♦s❡ t❤❡ r❡❝✉rs✐✈❡ ❝❛❧❧ ✐♥ ❛♥ ❡①❝❡♣t✐♦♥ ❤❛♥❞❧❡r✱ ✇❤✐❝❤ ✉♥❞♦❡s t❤❡ ❝❤♦✐❝❡ ✐❢ ✐t ❣♦❡s ✇r♦♥❣✳ ❈❛r❡❢✉❧❧② ♦❜s❡r✈❡ ❤♦✇ ❡①❝❡♣t✐♦♥s ✐♥t❡r❛❝t ✇✐t❤ r❡❝✉rs✐♦♥✳ ❚❤❡ ❡①❝❡♣t✐♦♥ ❤❛♥❞❧❡r ❛❧✇❛②s ✉♥❞♦❡s t❤❡ ♠♦st r❡❝❡♥t ❝❤♦✐❝❡✱ ❧❡❛✈✐♥❣ ♦t❤❡rs ♣♦ss✐❜❧② t♦ ❜❡ ✉♥❞♦♥❡ ❧❛t❡r✳ ■❢ ♠❛❦✐♥❣ ❝❤❛♥❣❡ r❡❛❧❧② ✐s ✐♠♣♦ss✐❜❧❡✱ t❤❡♥ ❡✈❡♥t✉❛❧❧② ❡①❝❡♣✲ t✐♦♥ ❈❤❛♥❣❡ ✇✐❧❧ ❜❡ r❛✐s❡❞ ✇✐t❤ ♥♦ ❤❛♥❞❧❡r t♦ ❝❛t❝❤ ✐t✱ ❛♥❞ ✐t ✇✐❧❧ ❜❡ r❡♣♦rt❡❞ ❛t t♦♣ ❧❡✈❡❧✳

❱■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✼✸

Slide 709

Binary Trees, a Recursive Datatype

datatype ’a tree = Lf | Br of ’a * ’a tree * ’a tree

1 2 3 4 5

Br(1, Br(2, Br(4, Lf, Lf), Br(5, Lf, Lf)), Br(3, Lf, Lf))

❆ ❞❛t❛ str✉❝t✉r❡ ✇✐t❤ ♠✉❧t✐♣❧❡ ❜r❛♥❝❤✐♥❣ ✐s ❝❛❧❧❡❞ ❛ tr❡❡✳ ❚r❡❡s ❝❛♥ r❡♣r❡s❡♥t ♠❛t❤❡♠❛t✐❝❛❧ ❡①♣r❡ss✐♦♥s✱ ❧♦❣✐❝❛❧ ❢♦r♠✉❧❛❡✱ ❝♦♠♣✉t❡r ♣r♦❣r❛♠s✱ t❤❡ ♣❤r❛s❡ str✉❝t✉r❡ ♦❢ ❊♥❣❧✐s❤ s❡♥t❡♥❝❡s✱ ❡t❝✳ ❇✐♥❛r② tr❡❡s ❛r❡ ♥❡❛r❧② ❛s ❢✉♥❞❛♠❡♥t❛❧ ❛s ❧✐sts✳ ❚❤❡② ❝❛♥ ♣r♦✈✐❞❡ ❡✣❝✐❡♥t st♦r❛❣❡ ❛♥❞ r❡tr✐❡✈❛❧ ♦❢ ✐♥❢♦r♠❛t✐♦♥✳ ■♥ ❛ ❜✐♥❛r② tr❡❡✱ ❡❛❝❤ ♥♦❞❡ ✐s ❡♠♣t② ✭Lf✮✱ ♦r ✐s ❛ ❜r❛♥❝❤ ✭Br✮ ✇✐t❤ ❛ ❧❛❜❡❧ ❛♥❞ t✇♦ s✉❜tr❡❡s✳ ▲✐sts t❤❡♠s❡❧✈❡s ❝♦✉❧❞ ❜❡ ❞❡❝❧❛r❡❞ ✉s✐♥❣ ❞❛t❛t②♣❡✿ ❞❛t❛t②♣❡ ✬❛ ❧✐st ❂ ♥✐❧ ⑤ ❝♦♥s ♦❢ ✬❛ ✯ ✬❛ ❧✐st ❲❡ ❝♦✉❧❞ ❡✈❡♥ ❞❡❝❧❛r❡ ✿✿ ❛s ❛♥ ✐♥✜① ❝♦♥str✉❝t♦r✳ ❚❤❡ ♦♥❧② t❤✐♥❣ ✇❡ ❝♦✉❧❞ ♥♦t ❞❡✜♥❡ ✐s t❤❡ ❬✳ ✳ ✳ ❪ ♥♦t❛t✐♦♥✱ ✇❤✐❝❤ ✐s ♣❛rt ♦❢ t❤❡ ▼▲ ❣r❛♠♠❛r✳

❱■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✼✹

Slide 710

Basic Properties of Binary Trees

fun count Lf = 0

# of branch nodes

| count(Br(v,t1,t2)) = 1 + count t1 + count t2 fun depth Lf = 0

length of longest path

| depth(Br(v,t1,t2)) = 1 + max(depth t1, depth t2)

count(t) ≤ 2depth(t) − 1

❋✉♥❝t✐♦♥s ♦♥ tr❡❡s ❛r❡ ❡①♣r❡ss❡❞ r❡❝✉rs✐✈❡❧② ✉s✐♥❣ ♣❛tt❡r♥✲♠❛t❝❤✐♥❣✳ ❇♦t❤ ❢✉♥❝t✐♦♥s ❛❜♦✈❡ ❛r❡ ❛♥❛❧♦❣♦✉s t♦ ❧❡♥❣t❤ ♦♥ ❧✐sts✳ ❍❡r❡ ✐s ❛ t❤✐r❞ ♠❡❛s✉r❡ ♦❢ ❛ tr❡❡✬s s✐③❡✿

❢✉♥ ❧❡❛✈❡s ▲❢ ❂ ✶ ⑤ ❧❡❛✈❡s ✭❇r✭✈✱t✶✱t✷✮✮ ❂ ❧❡❛✈❡s t✶ ✰ ❧❡❛✈❡s t✷❀

❚❤✐s ❢✉♥❝t✐♦♥ ✐s r❡❞✉♥❞❛♥t ❜❡❝❛✉s❡ ♦❢ ❛ ❜❛s✐❝ ❢❛❝t ❛❜♦✉t tr❡❡s✱ ✇❤✐❝❤ ❝❛♥ ❜❡ ♣r♦✈❡❞ ❜② ✐♥❞✉❝t✐♦♥✿ ❢♦r ❡✈❡r② tr❡❡ t✱ ✇❡ ❤❛✈❡ ❧❡❛✈❡s(t) = ❝♦✉♥t(t)+1✳ ❚❤❡ ✐♥❡q✉❛❧✐t② s❤♦✇♥ ♦♥ t❤❡ s❧✐❞❡ ❛❧s♦ ❤❛s ❛♥ ❡❧❡♠❡♥t❛r② ♣r♦♦❢ ❜② ✐♥❞✉❝t✐♦♥✳ ❆ tr❡❡ ♦❢ ❞❡♣t❤ ✷✵ ❝❛♥ st♦r❡ 220−1 ♦r ❛♣♣r♦①✐♠❛t❡❧② ♦♥❡ ♠✐❧❧✐♦♥ ❡❧❡♠❡♥ts✳ ❚❤❡ ❛❝❝❡ss ♣❛t❤s t♦ t❤❡s❡ ❡❧❡♠❡♥ts ❛r❡ s❤♦rt✱ ♣❛rt✐❝✉❧❛r❧② ✇❤❡♥ ❝♦♠♣❛r❡❞ ✇✐t❤ ❛ ♠✐❧❧✐♦♥✲❡❧❡♠❡♥t ❧✐st✦

❱■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✼✺

Slide 711

Traversing Trees (3 Methods)

fun preorder Lf = [] | preorder(Br(v,t1,t2)) = [v] @ preorder t1 @ preorder t2; fun inorder Lf = [] | inorder(Br(v,t1,t2)) = inorder t1 @ [v] @ inorder t2; fun postorder Lf = [] | postorder(Br(v,t1,t2)) = postorder t1 @ postorder t2 @ [v];

❚r❡❡ tr❛✈❡rs❛❧ ♠❡❛♥s ❡①❛♠✐♥✐♥❣ ❡❛❝❤ ♥♦❞❡ ♦❢ ❛ tr❡❡ ✐♥ s♦♠❡ ♦r❞❡r✳ ❉✳ ❊✳ ❑♥✉t❤ ❤❛s ✐❞❡♥t✐✜❡❞ t❤r❡❡ ❢♦r♠s ♦❢ tr❡❡ tr❛✈❡rs❛❧✿ ♣r❡♦r❞❡r✱ ✐♥♦r❞❡r ❛♥❞ ♣♦st♦r❞❡r ❬✶✵❪✳ ❲❡ ❝❛♥ ❝♦❞❡ t❤❡s❡ ❵✈✐s✐t✐♥❣ ♦r❞❡rs✬ ❛s ❢✉♥❝t✐♦♥s t❤❛t ❝♦♥✈❡rt tr❡❡s ✐♥t♦ ❧✐sts ♦❢ ❧❛❜❡❧s✳ ❆❧❣♦r✐t❤♠s ❜❛s❡❞ ♦♥ t❤❡s❡ ♥♦t✐♦♥s t②♣✐❝❛❧❧② ♣❡r❢♦r♠ s♦♠❡ ❛❝t✐♦♥ ❛t ❡❛❝❤ ♥♦❞❡❀ t❤❡ ❢✉♥❝t✐♦♥s ❛❜♦✈❡ s✐♠♣❧② ❝♦♣② t❤❡ ♥♦❞❡s ✐♥t♦ ❧✐sts✳ ❈♦♥s✐❞❡r t❤❡ tr❡❡ ❆ ✴ ❭ ❇ ❈ ✴ ❭ ✴ ❭ ❉ ❊ ❋ ●

• ♣r❡♦r❞❡r ✈✐s✐ts t❤❡ ❧❛❜❡❧ ✜rst ✭❵P♦❧✐s❤ ♥♦t❛t✐♦♥✬✮✱ ②✐❡❧❞✐♥❣ ❆❇❉❊❈❋●
• ✐♥♦r❞❡r ✈✐s✐ts t❤❡ ❧❛❜❡❧ ♠✐❞✇❛②✱ ②✐❡❧❞✐♥❣ ❉❇❊❆❋❈●
• ♣♦st♦r❞❡r ✈✐s✐ts t❤❡ ❧❛❜❡❧ ❧❛st ✭❵❘❡✈❡rs❡ P♦❧✐s❤✬✮✱ ②✐❡❧❞✐♥❣ ❉❊❇❋●❈❆

❱■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✼✻

Slide 712

Efficiently Traversing Trees

fun preord (Lf, vs) = vs | preord (Br(v,t1,t2), vs) = v :: preord (t1, preord (t2, vs)); fun inord (Lf, vs) = vs | inord (Br(v,t1,t2), vs) = inord (t1, v::inord (t2, vs)); fun postord (Lf, vs) = vs | postord (Br(v,t1,t2), vs) = postord (t1, postord (t2, v::vs));

❯♥❢♦rt✉♥❛t❡❧②✱ t❤❡ ❢✉♥❝t✐♦♥s s❤♦✇♥ ♦♥ t❤❡ ♣r❡✈✐♦✉s s❧✐❞❡ ❛r❡ q✉❛❞r❛t✐❝ ✐♥ t❤❡ ✇♦rst ❝❛s❡✿ t❤❡ ❛♣♣❡♥❞s ✐♥ t❤❡ r❡❝✉rs✐✈❡ ❝❛❧❧s ❛r❡ ✐♥❡✣❝✐❡♥t✳ ❚♦ ❝♦rr❡❝t t❤❛t ♣r♦❜❧❡♠✱ ✇❡ ✭❛s ✉s✉❛❧✮ ❛❞❞ ❛♥ ❛❝❝✉♠✉❧❛t✐♥❣ ❛r❣✉♠❡♥t✳ ❖❜s❡r✈❡ ❤♦✇ ❡❛❝❤ ❢✉♥❝t✐♦♥ ❝♦♥str✉❝ts ✐ts r❡s✉❧t ❧✐st ❛♥❞ ❝♦♠♣❛r❡ ✇✐t❤ ❤♦✇ ❛♣♣❡♥❞s ✇❡r❡ ❡❧✐♠✐♥❛t❡❞ ❢r♦♠ q✉✐❝❦s♦rt ✐♥ ▲❡❝t✳ ✻✳ ❖♥❡ ❝❛♥ ♣r♦✈❡ ❡q✉❛t✐♦♥s r❡❧❛t✐♥❣ ❡❛❝❤ ♦❢ t❤❡s❡ ❢✉♥❝t✐♦♥s t♦ ✐ts ❝♦✉♥t❡r♣❛rt ♦♥ t❤❡ ♣r❡✈✐♦✉s s❧✐❞❡✳ ❋♦r ❡①❛♠♣❧❡✱ ✐♥♦r❞(t, vs) = ✐♥♦r❞❡r(t)@vs

❱■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✼✼ ▲❡❛r♥✐♥❣ ❣✉✐❞❡✳ ❘❡❧❛t❡❞ ♠❛t❡r✐❛❧ ✐s ✐♥ ▼▲ ❢♦r t❤❡ ❲♦r❦✐♥❣ Pr♦❣r❛♠♠❡r✱ ♣❛❣❡s ✶✷✸✕✶✹✼✳ ❊①❡r❝✐s❡ ✼✳✶ ❙❤♦✇ t❤❛t t❤❡ ❢✉♥❝t✐♦♥s ♣r❡♦r❞❡r✱ ✐♥♦r❞❡r ❛♥❞ ♣♦st♦r❞❡r ❛❧❧ r❡q✉✐r❡ O(n2) t✐♠❡ ✐♥ t❤❡ ✇♦rst ❝❛s❡✱ ✇❤❡r❡ n ✐s t❤❡ s✐③❡ ♦❢ t❤❡ tr❡❡✳ ❊①❡r❝✐s❡ ✼✳✷ ❙❤♦✇ t❤❛t t❤❡ ❢✉♥❝t✐♦♥s ♣r❡♦r❞✱ ✐♥♦r❞ ❛♥❞ ♣♦st♦r❞ ❛❧❧ t❛❦❡ ❧✐♥❡❛r t✐♠❡ ✐♥ t❤❡ s✐③❡ ♦❢ t❤❡ tr❡❡✳

❱■■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✼✽

Slide 801

Dictionaries

• lookup: find an item in the dictionary
• update: store an item in the dictionary
• delete: remove an item from the dictionary
• empty: the null dictionary
• Missing: exception for errors in lookup and delete

Our abstract type supports these operations

. . . but hides the implementation! ❆ ❞✐❝t✐♦♥❛r② ✐s ❛ ❞❛t❛ str✉❝t✉r❡ t❤❛t ❛ss♦❝✐❛t❡s ✈❛❧✉❡s t♦ ❝❡rt❛✐♥ ✐❞❡♥✲ t✐✜❡rs✱ ❝❛❧❧❡❞ ❦❡②s✳ ❲❤❡♥ ❝❤♦♦s✐♥❣ t❤❡ ✐♥t❡r♥❛❧ r❡♣r❡s❡♥t❛t✐♦♥ ❢♦r ❛ ❞❛t❛ str✉❝t✉r❡✱ ✐t ✐s ❡ss❡♥t✐❛❧ t♦ s♣❡❝✐❢② t❤❡ ❢✉❧❧ s❡t ♦❢ ♦♣❡r❛t✐♦♥s t❤❛t ♠✉st ❜❡ s✉♣♣♦rt❡❞✳ ❙❡❧❞♦♠ ✐s ♦♥❡ r❡♣r❡s❡♥t❛t✐♦♥ ❜❡st ❢♦r ❛❧❧ ♣♦ss✐❜❧❡ ❛♣♣❧✐❝❛t✐♦♥s ♦❢ ❛ ❞❛t❛ str✉❝t✉r❡❀ ❡❛❝❤ ✇✐❧❧ s✉♣♣♦rt s♦♠❡ ♦♣❡r❛t✐♦♥s ✇❡❧❧ ❛♥❞ ♦t❤❡rs ❜❛❞❧②✳ ❲❡ ❝♦♥s✐❞❡r s✐♠♣❧❡ ❞✐❝t✐♦♥❛r✐❡s t❤❛t s✉♣♣♦rt ♦♥❧② ✉♣❞❛t❡ ✭❛ss♦❝✐❛t✐♥❣ ❛ ✈❛❧✉❡ ✇✐t❤ ❛♥ ✐❞❡♥t✐✜❡r✮ ❛♥❞ ❧♦♦❦✉♣ ✭s❡❛r❝❤✐♥❣ ❢♦r t❤❡ ✈❛❧✉❡ ❛ss♦❝✐❛t❡❞ ✇✐t❤ ❛♥ ✐❞❡♥t✐✜❡r✮✳ ❖t❤❡r ♦♣❡r❛t✐♦♥s t❤❛t ❝♦✉❧❞ ❜❡ ❝♦♥s✐❞❡r❡❞ ❛r❡ ❞❡❧❡t❡ ✭r❡♠♦✈✐♥❣ ❛♥ ❛ss♦❝✐❛t✐♦♥✮ ❛♥❞ ♠❡r❣❡ ✭❝♦♠❜✐♥✐♥❣ t✇♦ ❞✐❝t✐♦♥❛r✐❡s✮✳ ❙✐♥❝❡ ✇❡ ❛r❡ ♣r♦❣r❛♠♠✐♥❣ ✐♥ ❛ ❢✉♥❝t✐♦♥❛❧ st②❧❡✱ ✉♣❞❛t❡ ✇✐❧❧ ♥♦t ♠♦❞✐❢② t❤❡ ❞❛t❛ str✉❝t✉r❡✳ ■♥st❡❛❞✱ ✐t ✇✐❧❧ r❡t✉r♥ ❛ ♠♦❞✐✜❡❞ ❞❛t❛ str✉❝t✉r❡✳ ❚❤✐s ❝❛♥ ❜❡ ❞♦♥❡ ❡✣❝✐❡♥t❧② ✐❢ ✇❡ ❛r❡ ❝❛r❡❢✉❧ t♦ ❛✈♦✐❞ ❡①❝❡ss✐✈❡ ❝♦♣②✐♥❣✳ ▲♦♦❦✉♣ ❛♥❞ ❞❡❧❡t❡ ❢❛✐❧ ✉♥❧❡ss t❤❡② ✜♥❞ t❤❡ ❞❡s✐r❡❞ ❦❡②✳ ❲❡ ✉s❡ ▼▲✬s ❡①❝❡♣t✐♦♥s t♦ s✐❣♥❛❧ ❢❛✐❧✉r❡✳ ▼♦❞❡r♥ ♣r♦❣r❛♠♠✐♥❣ ❧❛♥❣✉❛❣❡s ♣r♦✈✐❞❡ ❛ ♠❡❛♥s ♦❢ ❞❡❝❧❛r✐♥❣ ❛❜str❛❝t t②♣❡s t❤❛t ❡①♣♦rt ✇❡❧❧✲❞❡✜♥❡❞ ♦♣❡r❛t✐♦♥s ✇❤✐❧❡ ❤✐❞✐♥❣ ❧♦✇✲❧❡✈❡❧ ✐♠♣❧❡♠❡♥✲ t❛t✐♦♥ ❞❡t❛✐❧s s✉❝❤ ❛s t❤❡ ❞❛t❛ str✉❝t✉r❡ ✉s❡❞ t♦ r❡♣r❡s❡♥t ❞✐❝t✐♦♥❛r✐❡s✳ ▼▲ ♣r♦✈✐❞❡s ♠♦❞✉❧❡s ❢♦r t❤✐s ♣✉r♣♦s❡✱ ❜✉t t❤✐s ❝♦✉rs❡ ❞♦❡s ♥♦t ❝♦✈❡r t❤❡♠✳ ✭❚❤❡ ❏❛✈❛ ❝♦✉rs❡ ❝♦✈❡rs ♠♦❞✉❧❛r✐t②✳✮ ❚❤❡r❡❢♦r❡✱ ✇❡ s❤❛❧❧ s✐♠♣❧② ❞❡❝❧❛r❡ t❤❡ ❞✐❝t✐♦✲ ♥❛r② ♦♣❡r❛t✐♦♥s ✐♥❞✐✈✐❞✉❛❧❧② ❛t t♦♣ ❧❡✈❡❧✳ ❲❡ s❤❛❧❧ ❡♥❝♦✉♥t❡r ♠❛♥② ✈❡rs✐♦♥s ♦❢ ❧♦♦❦✉♣✱ ❢♦r ❡①❛♠♣❧❡✱ t❤❛t ♦✉❣❤t t♦ ❜❡ ♣❛❝❦❛❣❡❞ ✐♥ s❡♣❛r❛t❡ ♠♦❞✉❧❡s t♦ ♣r❡✈❡♥t ❝❧❛s❤❡s✳

❱■■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✼✾

Slide 802

Association Lists: Lists of Pairs

exception Missing; fun lookup ([], a) = raise Missing | lookup ((x,y)::pairs, a) = if a=x then y else lookup(pairs, a); > val lookup = fn : (’’a * ’b) list * ’’a -> ’b fun update(l, b, y) = (b,y)::l

PROBLEMS: Linear search is slow. The lists get too long!

❆ ❧✐st ♦❢ ♣❛✐rs ✐s t❤❡ ♠♦st ♦❜✈✐♦✉s r❡♣r❡s❡♥t❛t✐♦♥ ❢♦r ❛ ❞✐❝t✐♦♥❛r②✳ ▲♦♦❦✉♣ ✐s ❜② ❧✐♥❡❛r s❡❛r❝❤✱ ✇❤✐❝❤ ✇❡ ❦♥♦✇ t♦ ❜❡ ♣r♦❤✐❜✐t✐✈❡❧② s❧♦✇✿ O(n)✳ ❆ss♦❝✐❛t✐♦♥ ❧✐sts ❛r❡ ♦♥❧② ✉s❛❜❧❡ ✐❢ t❤❡r❡ ❛r❡ ❢❡✇ ❦❡②s ♦❢ ✐♥t❡r❡st✱ ❛❧✇❛②s ♥❡❛r t❤❡ ❢r♦♥t✳ ❍♦✇❡✈❡r✱ ♥♦t❡ ❧♦♦❦✉♣✬s t②♣❡✿ ❛ss♦❝✐❛t✐♦♥ ❧✐sts ✇♦r❦ ❢♦r ❛♥② ❡q✉❛❧✐t② t②♣❡✳ ❚❤✐s ❣❡♥❡r❛❧✐t② ✐s t❤❡✐r ♠❛✐♥ ❛❞✈❛♥t❛❣❡✳ ❚♦ ❡♥t❡r ❛ ♥❡✇ ✭❦❡②✱ ✈❛❧✉❡✮ ❛ss♦❝✐❛t✐♦♥✱ s✐♠♣❧② ♣✉t ❛ ♥❡✇ ♣❛✐r ✐♥t♦ t❤❡ ❧✐st✳ ❚❤✐s t❛❦❡s ❝♦♥st❛♥t t✐♠❡✱ ✇❤✐❝❤ ✐s t❤❡ ❜❡st ✇❡ ❝♦✉❧❞ ❤♦♣❡ ❢♦r✳ ❇✉t t❤❡ s♣❛❝❡ r❡q✉✐r❡♠❡♥t ✐s ❤✉❣❡✳ ■t ✐s ❧✐♥❡❛r ✐♥ t❤❡ ♥✉♠❜❡r ♦❢ ✉♣❞❛t❡s✱ ♥♦t ✐♥ t❤❡ ♥✉♠❜❡r ♦❢ ❞✐st✐♥❝t ❦❡②s✱ ❜❡❝❛✉s❡ ♦❜s♦❧❡t❡ ❡♥tr✐❡s ❛r❡ ♥❡✈❡r ❞❡❧❡t❡❞✳ ❚♦ ❞❡❧❡t❡ ♦❧❞ ❡♥tr✐❡s ✇♦✉❧❞ r❡q✉✐r❡ ✜rst ✜♥❞✐♥❣ t❤❡♠✱ ✐♥❝r❡❛s✐♥❣ t❤❡ ✉♣❞❛t❡ t✐♠❡ ❢r♦♠ O(1) t♦ O(n)✳ ❋✉♥❝t✐♦♥ ❧♦♦❦✉♣ ✐s tr❛❞✐t✐♦♥❛❧❧② ❝❛❧❧❡❞ ❛ss♦❝ ❛❢t❡r ❛ s✐♠✐❧❛r ❢✉♥❝t✐♦♥ ✐♥ t❤❡ ❧❛♥❣✉❛❣❡ ▲✐s♣✱ ✇❤✐❝❤ ♣❧❛②❡❞ ❛ ❤✐st♦r✐❝ r♦❧❡ ✐♥ t❤❡ ❞❡✜♥✐t✐♦♥ ♦❢ t❤❡ ▲✐s♣ ❡✈❛❧✉❛t♦r✳

❱■■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✽✵

Slide 803

Binary Search Trees

A dictionary associates values (here, numbers) with keys

James, 5 Gordon, 4 Edward, 2 Thomas, 1 Percy, 6 Henry, 3 ❇✐♥❛r② s❡❛r❝❤ tr❡❡s ❛r❡ ❛♥ ✐♠♣♦rt❛♥t ❛♣♣❧✐❝❛t✐♦♥ ♦❢ ❜✐♥❛r② tr❡❡s✳ ❚❤❡② ✇♦r❦ ❢♦r ❦❡②s t❤❛t ❤❛✈❡ ❛ t♦t❛❧ ♦r❞❡r✐♥❣✱ s✉❝❤ ❛s str✐♥❣s✳ ❊❛❝❤ ❜r❛♥❝❤ ♦❢ t❤❡ tr❡❡ ❝❛rr✐❡s ❛ (key, value) ♣❛✐r❀ ✐ts ❧❡❢t s✉❜tr❡❡ ❤♦❧❞s s♠❛❧❧❡r ❦❡②s❀ t❤❡ r✐❣❤t s✉❜tr❡❡ ❤♦❧❞s ❣r❡❛t❡r ❦❡②s✳ ■❢ t❤❡ tr❡❡ r❡♠❛✐♥s r❡❛s♦♥❛❜❧② ❜❛❧❛♥❝❡❞✱ t❤❡♥ ✉♣❞❛t❡ ❛♥❞ ❧♦♦❦✉♣ ❜♦t❤ t❛❦❡ O(log n) ❢♦r ❛ tr❡❡ ♦❢ s✐③❡ n✳ ❚❤❡s❡ t✐♠❡s ❤♦❧❞ ✐♥ t❤❡ ❛✈❡r❛❣❡ ❝❛s❡❀ ❣✐✈❡♥ r❛♥❞♦♠ ❞❛t❛✱ t❤❡ tr❡❡ ✐s ❧✐❦❡❧② t♦ r❡♠❛✐♥ ❜❛❧❛♥❝❡❞✳ ❆t ❛ ❣✐✈❡♥ ♥♦❞❡✱ ❛❧❧ ❦❡②s ✐♥ t❤❡ ❧❡❢t s✉❜tr❡❡ ❛r❡ s♠❛❧❧❡r ✭♦r ❡q✉❛❧✮ ✇❤✐❧❡ ❛❧❧ tr❡❡s ✐♥ t❤❡ r✐❣❤t s✉❜tr❡❡ ❛r❡ ❣r❡❛t❡r✳ ❆♥ ✉♥❜❛❧❛♥❝❡❞ tr❡❡ ❤❛s ❛ ❧✐♥❡❛r ❛❝❝❡ss t✐♠❡ ✐♥ t❤❡ ✇♦rst ❝❛s❡✳ ❊①❛♠♣❧❡s ✐♥❝❧✉❞❡ ❜✉✐❧❞✐♥❣ ❛ tr❡❡ ❜② r❡♣❡❛t❡❞ ✐♥s❡rt✐♦♥s ♦❢ ❡❧❡♠❡♥ts ✐♥ ✐♥❝r❡❛s✐♥❣ ♦r ❞❡❝r❡❛s✐♥❣ ♦r❞❡r❀ t❤❡r❡ ✐s ❛ ❝❧♦s❡ r❡s❡♠❜❧❛♥❝❡ t♦ q✉✐❝❦s♦rt✳ ❇✉✐❧❞✐♥❣ ❛ ❜✐♥❛r② s❡❛r❝❤ tr❡❡✱ t❤❡♥ ❝♦♥✈❡rt✐♥❣ ✐t t♦ ✐♥♦r❞❡r✱ ②✐❡❧❞s ❛ s♦rt✐♥❣ ❛❧❣♦r✐t❤♠ ❝❛❧❧❡❞ tr❡❡s♦rt✳ ❙❡❧❢✲❜❛❧❛♥❝✐♥❣ tr❡❡s✱ s✉❝❤ ❛s ❘❡❞✲❇❧❛❝❦ tr❡❡s✱ ❛tt❛✐♥ O(log n) ✐♥ t❤❡ ✇♦rst ❝❛s❡✳ ❚❤❡② ❛r❡ ❝♦♠♣❧✐❝❛t❡❞ t♦ ✐♠♣❧❡♠❡♥t✳

❱■■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✽✶

Slide 804

Lookup: Seeks Left or Right

exception Missing of string; fun lookup (Br ((a,x),t1,t2), b) = if b < a then lookup(t1, b) else if a < b then lookup(t2, b) else x | lookup (Lf, b) = raise Missing b; > val lookup = fn : (string * ’a) tree * string >

• > ’a

Guaranteed O(log n) access time if the tree is balanced!

▲♦♦❦✉♣ ✐♥ t❤❡ ❜✐♥❛r② s❡❛r❝❤ tr❡❡ ❣♦❡s t♦ t❤❡ ❧❡❢t s✉❜tr❡❡ ✐❢ t❤❡ ❞❡s✐r❡❞ ❦❡② ✐s s♠❛❧❧❡r t❤❛♥ t❤❡ ❝✉rr❡♥t ♦♥❡ ❛♥❞ t♦ t❤❡ r✐❣❤t ✐❢ ✐t ✐s ❣r❡❛t❡r✳ ■t r❛✐s❡s ❡①❝❡♣t✐♦♥ ▼✐ss✐♥❣ ✐❢ ✐t ❡♥❝♦✉♥t❡rs ❛♥ ❡♠♣t② tr❡❡✳ ❙✐♥❝❡ ❛♥ ♦r❞❡r✐♥❣ ✐s ✐♥✈♦❧✈❡❞✱ ✇❡ ❤❛✈❡ t♦ ❞❡❝❧❛r❡ t❤❡ ❢✉♥❝t✐♦♥s ❢♦r ❛ s♣❡❝✐✜❝ t②♣❡✱ ❤❡r❡ str✐♥❣✳ ◆♦✇ ❡①❝❡♣t✐♦♥ ▼✐ss✐♥❣ ♠❡♥t✐♦♥s t❤❛t t②♣❡✿ ✐❢ ❧♦♦❦✉♣ ❢❛✐❧s✱ t❤❡ ❡①❝❡♣t✐♦♥ r❡t✉r♥s t❤❡ ♠✐ss✐♥❣ ❦❡②✳ ❚❤❡ ❡①❝❡♣t✐♦♥ ❝♦✉❧❞ ❜❡ ❡❧✐♠✐♥❛t❡❞ ✉s✐♥❣ t②♣❡ ♦♣t✐♦♥ ♦❢ ▲❡❝t✳ ✼✱ ✉s✐♥❣ t❤❡ ❝♦♥str✉❝t♦r ◆❖◆❊ ❢♦r ❢❛✐❧✉r❡✳

❱■■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✽✷

Slide 805

Update

fun update (Lf, b:string, y) = Br((b,y), Lf, Lf) | update (Br((a,x),t1,t2), b, y) = if b<a then Br ((a,x), update(t1,b,y), t2) else if a<b then Br ((a,x), t1, update(t2,b,y)) else (*a=b*) Br ((a,y),t1,t2);

Also O(log n): it copies the path only, not whole subtrees!

❚❤❡ ✉♣❞❛t❡ ♦♣❡r❛t✐♦♥ ✐s ❛ ♥✐❝❡ ♣✐❡❝❡ ♦❢ ❢✉♥❝t✐♦♥❛❧ ♣r♦❣r❛♠♠✐♥❣✳ ■t s❡❛r❝❤❡s ✐♥ t❤❡ s❛♠❡ ♠❛♥♥❡r ❛s ❧♦♦❦✉♣✱ ❜✉t t❤❡ r❡❝✉rs✐✈❡ ❝❛❧❧s r❡❝♦♥str✉❝t ❛ ♥❡✇ tr❡❡ ❛r♦✉♥❞ t❤❡ r❡s✉❧t ♦❢ t❤❡ ✉♣❞❛t❡✳ ❖♥❡ s✉❜tr❡❡ ✐s ✉♣❞❛t❡❞ ❛♥❞ t❤❡ ♦t❤❡r ❧❡❢t ✉♥❝❤❛♥❣❡❞✳ ❚❤❡ ✐♥t❡r♥❛❧ r❡♣r❡s❡♥t❛t✐♦♥ ♦❢ tr❡❡s ❡♥s✉r❡s t❤❛t ✉♥❝❤❛♥❣❡❞ ♣❛rts ♦❢ t❤❡ tr❡❡ ❛r❡ ♥♦t ❝♦♣✐❡❞✱ ❜✉t s❤❛r❡❞✳ ✭▲❡❝t✳ ✶✺ ✇✐❧❧ ❞✐s❝✉ss ✉s✐♥❣ r❡❢❡r❡♥❝❡s t♦ ❝r❡❛t❡ ❧✐♥❦❡❞ str✉❝t✉r❡s✳✮ ❚❤❡r❡❢♦r❡✱ ✉♣❞❛t❡ ❝♦♣✐❡s ♦♥❧② t❤❡ ♣❛t❤ ❢r♦♠ t❤❡ r♦♦t t♦ t❤❡ ♥❡✇ ♥♦❞❡✳ ■ts t✐♠❡ ❛♥❞ s♣❛❝❡ r❡q✉✐r❡♠❡♥ts✱ ❢♦r ❛ r❡❛s♦♥❛❜❧② ❜❛❧❛♥❝❡❞ tr❡❡✱ ❛r❡ ❜♦t❤ O(log n)✳ ❚❤❡ ❝♦♠♣❛r✐s♦♥ ❜❡t✇❡❡♥ b ❛♥❞ a ❛❧❧♦✇s t❤r❡❡ ❝❛s❡s✿

• s♠❛❧❧❡r✿ ✉♣❞❛t❡ t❤❡ ❧❡❢t s✉❜tr❡❡❀ s❤❛r❡ t❤❡ r✐❣❤t
• ❣r❡❛t❡r✿ ✉♣❞❛t❡ t❤❡ r✐❣❤t s✉❜tr❡❡❀ s❤❛r❡ t❤❡ ❧❡❢t
• ❡q✉❛❧✿ ✉♣❞❛t❡ t❤❡ ❧❛❜❡❧ ❛♥❞ s❤❛r❡ ❜♦t❤ s✉❜tr❡❡s

◆♦t❡✿ ✐♥ t❤❡ ❢✉♥❝t✐♦♥ ❞❡✜♥✐t✐♦♥✱ ✭✯❛❂❜✯✮ ✐s ❛ ❝♦♠♠❡♥t✳ ❈♦♠♠❡♥ts ✐♥ ▼▲ ❛r❡ ❡♥❝❧♦s❡❞ ✐♥ t❤❡ ❜r❛❝❦❡ts ✭✯ ❛♥❞ ✯✮✳

❱■■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✽✸

Slide 806

Arrays

A conventional array is an indexed storage area.

• It is updated in place by the command A[k] := x
• The concept is inherently imperative: updating is an action.

A functional Array is a finite map from integers to data.

• Updating is copying in update(A,k,x)
• The new array equals A except at position k.

Can we do updates efficiently?

❚❤❡ ❡❧❡♠❡♥ts ♦❢ ❛ ❧✐st ❝❛♥ ♦♥❧② ❜❡ r❡❛❝❤❡❞ ❜② ❝♦✉♥t✐♥❣ ❢r♦♠ t❤❡ ❢r♦♥t✳ ❊❧❡♠❡♥ts ♦❢ ❛ tr❡❡ ❛r❡ r❡❛❝❤❡❞ ❜② ❢♦❧❧♦✇✐♥❣ ❛ ♣❛t❤ ❢r♦♠ t❤❡ r♦♦t✳ ❆♥ ❛r✲ r❛② ❤✐❞❡s s✉❝❤ str✉❝t✉r❛❧ ♠❛tt❡rs❀ ✐ts ❡❧❡♠❡♥ts ❛r❡ ✉♥✐❢♦r♠❧② ❞❡s✐❣♥❛t❡❞ ❜② ♥✉♠❜❡r✳ ■♠♠❡❞✐❛t❡ ❛❝❝❡ss t♦ ❛r❜✐tr❛r② ♣❛rts ♦❢ ❛ ❞❛t❛ str✉❝t✉r❡ ✐s ❝❛❧❧❡❞ r❛♥❞♦♠ ❛❝❝❡ss✳ ❆rr❛②s ❛r❡ t❤❡ ❞♦♠✐♥❛♥t ❞❛t❛ str✉❝t✉r❡ ✐♥ ❝♦♥✈❡♥t✐♦♥❛❧ ♣r♦❣r❛♠♠✐♥❣ ❧❛♥❣✉❛❣❡s✳ ❚❤❡ ✐♥❣❡♥✐♦✉s ✉s❡ ♦❢ ❛rr❛②s ✐s t❤❡ ❦❡② t♦ ♠❛♥② ♦❢ t❤❡ ❣r❡❛t ❝❧❛ss✐❝❛❧ ❛❧❣♦r✐t❤♠s✱ s✉❝❤ ❛s ❍♦❛r❡✬s ♦r✐❣✐♥❛❧ q✉✐❝❦s♦rt ✭t❤❡ ♣❛rt✐t✐♦♥ st❡♣✮ ❛♥❞ ❲❛rs❤❛❧❧✬s tr❛♥s✐t✐✈❡✲❝❧♦s✉r❡ ❛❧❣♦r✐t❤♠✳ ❚❤❡ ❞r❛✇❜❛❝❦ ✐s t❤❛t s✉❜s❝r✐♣t✐♥❣ ✐s ❛ ❝❤✐❡❢ ❝❛✉s❡ ♦❢ ♣r♦❣r❛♠♠❡r ❡rr♦r✳ ❚❤❛t ✐s ✇❤② ❛rr❛②s ♣❧❛② ❧✐tt❧❡ r♦❧❡ ✐♥ t❤✐s ✐♥tr♦❞✉❝t♦r② ❝♦✉rs❡✳ ❋✉♥❝t✐♦♥❛❧ ❛rr❛②s ❛r❡ ❞❡s❝r✐❜❡❞ ❜❡❧♦✇ ✐♥ ♦r❞❡r t♦ ✐❧❧✉str❛t❡ ❛♥♦t❤❡r ✇❛② ♦❢ ✉s✐♥❣ tr❡❡s t♦ ♦r❣❛♥✐③❡ ❞❛t❛✳ ❍❡r❡ ✐s ❛ s✉♠♠❛r② ♦❢ ♦✉r ❞✐❝t✐♦♥❛r② ❞❛t❛ str✉❝t✉r❡s ✐♥ ♦r❞❡r ♦❢ ❞❡❝r❡❛s✐♥❣ ❣❡♥❡r❛❧✐t② ❛♥❞ ✐♥❝r❡❛s✐♥❣ ❡✣❝✐❡♥❝②✿

• ▲✐♥❡❛r s❡❛r❝❤✿ ▼♦st ❣❡♥❡r❛❧✱ ♥❡❡❞✐♥❣ ♦♥❧② ❡q✉❛❧✐t② ♦♥ ❦❡②s✱ ❜✉t ✐♥❡✣✲

❝✐❡♥t✿ ❧✐♥❡❛r t✐♠❡✳

• ❇✐♥❛r② s❡❛r❝❤✿ ◆❡❡❞s ❛♥ ♦r❞❡r✐♥❣ ♦♥ ❦❡②s✳ ▲♦❣❛r✐t❤♠✐❝ ❛❝❝❡ss t✐♠❡ ✐♥

t❤❡ ❛✈❡r❛❣❡ ❝❛s❡✱ ❧✐♥❡❛r ✐♥ t❤❡ ✇♦rst ❝❛s❡✳

• ❆rr❛② s✉❜s❝r✐♣t✐♥❣✿ ▲❡❛st ❣❡♥❡r❛❧✱ r❡q✉✐r✐♥❣ ❦❡②s t♦ ❜❡ ✐♥t❡❣❡rs✱ ❜✉t

❡✈❡♥ ✇♦rst✲❝❛s❡ t✐♠❡ ✐s ❧♦❣❛r✐t❤♠✐❝✳

❱■■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✽✹

Slide 807

Functional Arrays as Binary Trees

The path to an element follows the binary code for its subscript. 2 4 6 8 12 10 14 3 5 7 9 13 11 15 1

❚❤✐s s✐♠♣❧❡ r❡♣r❡s❡♥t❛t✐♦♥ ✭❝r❡❞✐t❡❞ t♦ ❲✳ ❇r❛✉♥✮ ❡♥s✉r❡s t❤❛t t❤❡ tr❡❡ ✐s ❜❛❧❛♥❝❡❞✳ ❈♦♠♣❧❡①✐t② ♦❢ ❛❝❝❡ss ✐s ❛❧✇❛②s O(log n)✱ ✇❤✐❝❤ ✐s ♦♣t✐♠❛❧✳ ❋♦r ❛❝t✉❛❧ r✉♥♥✐♥❣ t✐♠❡✱ ❛❝❝❡ss t♦ ❝♦♥✈❡♥t✐♦♥❛❧ ❛rr❛②s ✐s ♠✉❝❤ ❢❛st❡r✿ ✐t r❡q✉✐r❡s ♦♥❧② ❛ ❢❡✇ ❤❛r❞✇❛r❡ ✐♥str✉❝t✐♦♥s✳ ❆rr❛② ❛❝❝❡ss ✐s ♦❢t❡♥ t❛❦❡♥ t♦ ❜❡ O(1)✱ ✇❤✐❝❤ ✭❛s ❛❧✇❛②s✮ ♣r❡s✉♠❡s t❤❛t ❤❛r❞✇❛r❡ ❧✐♠✐ts ❛r❡ ♥❡✈❡r ❡①❝❡❡❞❡❞✳ ❚❤❡ ❧♦✇❡r ❜♦✉♥❞ ❢♦r ❛rr❛② ✐♥❞✐❝❡s ✐s ♦♥❡✳ ❚❤❡ ✉♣♣❡r ❜♦✉♥❞ st❛rts ❛t ③❡r♦ ✭✇❤✐❝❤ s✐❣♥✐✜❡s t❤❡ ❡♠♣t② ❛rr❛②✮ ❛♥❞ ❝❛♥ ❣r♦✇ ✇✐t❤♦✉t ❧✐♠✐t✳ ❚❤✐s ❞❛t❛ str✉❝t✉r❡ ❝❛♥ ❜❡ ✉s❡❞ t♦ ✐♠♣❧❡♠❡♥t ❛rr❛②s t❤❛t ❣r♦✇ ❛♥❞ s❤r✐♥❦ ❜② ❛❞❞✐♥❣ ❛♥❞ ❞❡❧❡t✐♥❣ ❡❧❡♠❡♥ts ❛t ❡✐t❤❡r ❡♥❞✳

❱■■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✽✺

Slide 808

The Lookup Function

exception Subscript; fun sub (Lf, _) = raise Subscript

(*Not found!*)

| sub (Br(v,t1,t2), k) = if k=1 then v else if k mod 2 = 0 then sub (t1, k div 2) else sub (t2, k div 2);

❚❤❡ ❧♦♦❦✉♣ ❢✉♥❝t✐♦♥✱ s✉❜✱ ❞✐✈✐❞❡s t❤❡ s✉❜s❝r✐♣t ❜② ✷ ✉♥t✐❧ ✶ ✐s r❡❛❝❤❡❞✳ ■❢ t❤❡ r❡♠❛✐♥❞❡r ✐s ✵ t❤❡♥ t❤❡ ❢✉♥❝t✐♦♥ ❢♦❧❧♦✇s t❤❡ ❧❡❢t s✉❜tr❡❡✱ ♦t❤❡r✇✐s❡ t❤❡ r✐❣❤t✳ ■❢ ✐t r❡❛❝❤❡s ❛ ❧❡❛❢✱ ✐t s✐❣♥❛❧s ❡rr♦r ❜② r❛✐s✐♥❣ ❡①❝❡♣t✐♦♥ ❙✉❜s❝r✐♣t✳ ❆rr❛② ❛❝❝❡ss ❝❛♥ ❛❧s♦ ❜❡ ✉♥❞❡rst❛♥❞ ✐♥ t❡r♠s ♦❢ t❤❡ s✉❜s❝r✐♣t✬s ❜✐♥❛r② ❝♦❞❡✳ ❇❡❝❛✉s❡ t❤❡ s✉❜s❝r✐♣t ♠✉st ❜❡ ❛ ♣♦s✐t✐✈❡ ✐♥t❡❣❡r✱ ✐♥ ❜✐♥❛r② ✐t ❤❛s ❛ ❧❡❛❞✐♥❣ ♦♥❡✳ ❉✐s❝❛r❞ t❤✐s ♦♥❡ ❛♥❞ r❡✈❡rs❡ t❤❡ r❡♠❛✐♥✐♥❣ ❜✐ts✳ ■♥t❡r♣r❡t✐♥❣ ③❡r♦ ❛s ❧❡❢t ❛♥❞ ♦♥❡ ❛s r✐❣❤t ②✐❡❧❞s t❤❡ ♣❛t❤ ❢r♦♠ t❤❡ r♦♦t t♦ t❤❡ s✉❜s❝r✐♣t✳ P♦♣✉❧❛r ❧✐t❡r❛t✉r❡ ♦❢t❡♥ ❡①♣❧❛✐♥s t❤❡ ✐♠♣♦rt❛♥❝❡ ♦❢ ❜✐♥❛r② ❛s ❜❡✐♥❣ ❧❡❞ ❜② ❤❛r❞✇❛r❡✿ ❜❡❝❛✉s❡ ❛ ❝✐r❝✉✐t ✐s ❡✐t❤❡r ♦♥ ♦r ♦✛✳ ❚❤❡ tr✉t❤ ✐s ❛❧♠♦st t❤❡ ♦♣♣♦s✐t❡✳ ❉❡s✐❣♥❡rs ♦❢ ❞✐❣✐t❛❧ ❡❧❡❝tr♦♥✐❝s ❣♦ t♦ ❛ ❧♦t ♦❢ tr♦✉❜❧❡ t♦ s✉♣♣r❡ss t❤❡ ❝♦♥t✐♥✉♦✉s ❜❡❤❛✈✐♦✉r t❤❛t ✇♦✉❧❞ ♥❛t✉r❛❧❧② ❛r✐s❡✳ ❚❤❡ r❡❛❧ r❡❛s♦♥ ✇❤② ❜✐♥❛r② ✐s ✐♠♣♦rt❛♥t ✐s ✐ts r♦❧❡ ✐♥ ❛❧❣♦r✐t❤♠s✿ ❛♥ ✐❢✲t❤❡♥✲❡❧s❡ ❞❡❝✐s✐♦♥ ❧❡❛❞s t♦ ❜✐♥❛r② ❜r❛♥❝❤✐♥❣✳ ❉❛t❛ str✉❝t✉r❡s✱ s✉❝❤ ❛s tr❡❡s✱ ❛♥❞ ❛❧❣♦r✐t❤♠s✱ s✉❝❤ ❛s ♠❡r❣❡s♦rt✱ ✉s❡ ❜✐♥❛r② ❜r❛♥❝❤✐♥❣ ✐♥ ♦r❞❡r t♦ r❡❞✉❝❡ ❛ ❝♦st ❢r♦♠ O(n) t♦ O(log n)✳ ❚✇♦ ✐s t❤❡ s♠❛❧❧❡st ✐♥t❡❣❡r ❞✐✈✐s♦r t❤❛t ❛❝❤✐❡✈❡s t❤✐s r❡❞✉❝t✐♦♥✳ ✭▲❛r❣❡r ❞✐✈✐s♦rs ❛r❡ ♦♥❧② ♦❝❝❛s✐♦♥❛❧❧② ❤❡❧♣❢✉❧✱ ❛s ✐♥ t❤❡ ❝❛s❡ ♦❢ ❇✲tr❡❡s✱ ✇❤❡r❡ t❤❡② r❡❞✉❝❡ t❤❡ ❝♦♥st❛♥t ❢❛❝t♦r✳✮ ❚❤❡ s✐♠♣❧✐❝✐t② ♦❢ ❜✐♥❛r② ❛r✐t❤♠❡t✐❝ ❝♦♠♣❛r❡❞ ✇✐t❤ ❞❡❝✐♠❛❧ ❛r✐t❤♠❡t✐❝ ✐s ❥✉st ❛♥♦t❤❡r ✐♥st❛♥❝❡ ♦❢ t❤❡ s✐♠♣❧✐❝✐t② ♦❢ ❛❧❣♦r✐t❤♠s ❜❛s❡❞ ♦♥ ❜✐♥❛r② ❝❤♦✐❝❡s✳

❱■■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✽✻

Slide 809

The Update Function

fun update (Lf, k, w) = if k = 1 then Br (w, Lf, Lf) else raise Subscript

(*Gap in tree!*)

| update (Br(v,t1,t2), k, w) = if k = 1 then Br (w, t1, t2) else if k mod 2 = 0 then Br (v, update(t1, k div 2, w), t2) else Br (v, t1, update(t2, k div 2, w))

❚❤❡ ✉♣❞❛t❡ ❢✉♥❝t✐♦♥✱ ✉♣❞❛t❡✱ ❛❧s♦ ❞✐✈✐❞❡s t❤❡ s✉❜s❝r✐♣t r❡♣❡❛t❡❞❧② ❜② t✇♦✳ ❲❤❡♥ ✐t r❡❛❝❤❡s ❛ ✈❛❧✉❡ ♦❢ ♦♥❡✱ ✐t ❤❛s ✐❞❡♥t✐✜❡❞ t❤❡ ❡❧❡♠❡♥t ♣♦s✐t✐♦♥✳ ❚❤❡♥ ✐t r❡♣❧❛❝❡s t❤❡ ❜r❛♥❝❤ ♥♦❞❡ ❜② ❛♥♦t❤❡r ❜r❛♥❝❤ ✇✐t❤ t❤❡ ♥❡✇ ❧❛❜❡❧✳ ❆ ❧❡❛❢ ♠❛② ❜❡ r❡♣❧❛❝❡❞ ❜② ❛ ❜r❛♥❝❤✱ ❡①t❡♥❞✐♥❣ t❤❡ ❛rr❛②✱ ♣r♦✈✐❞❡❞ ♥♦ ✐♥t❡r✈❡♥✐♥❣ ♥♦❞❡s ❤❛✈❡ t♦ ❜❡ ❣❡♥❡r❛t❡❞✳ ❚❤✐s s✉✣❝❡s ❢♦r ❛rr❛②s ✇✐t❤♦✉t ❣❛♣s ✐♥ t❤❡✐r s✉❜s❝r✐♣t✐♥❣✳ ✭❚❤❡ ❞❛t❛ str✉❝t✉r❡ ❝❛♥ ❜❡ ♠♦❞✐✜❡❞ t♦ ❛❧❧♦✇ s♣❛rs❡ ❛rr❛②s✱ ✇❤❡r❡ ♠♦st s✉❜s❝r✐♣t ♣♦s✐t✐♦♥s ❛r❡ ✉♥❞❡✜♥❡❞✳✮ ❊①❝❡♣t✐♦♥ ❙✉❜s❝r✐♣t ✐♥❞✐❝❛t❡s t❤❛t t❤❡ s✉❜s❝r✐♣t ♣♦s✐t✐♦♥ ❞♦❡s ♥♦t ❡①✐st ❛♥❞ ❝❛♥♥♦t ❜❡ ❝r❡❛t❡❞✳ ❚❤✐s ✉s❡ ♦❢ ❡①❝❡♣t✐♦♥s ✐s ♥♦t ❡❛s✐❧② r❡♣❧❛❝❡❞ ❜② ◆❖◆❊ ❛♥❞ ❙❖▼❊✳ ◆♦t❡ t❤❛t t❤❡r❡ ❛r❡ t✇♦ t❡sts ✐♥✈♦❧✈✐♥❣ k = 1✳ ■❢ ✇❡ ❤❛✈❡ r❡❛❝❤❡❞ ❛ ❧❡❛❢❀ ✐t r❡t✉r♥s ❛ ❜r❛♥❝❤✱ ❡①t❡♥❞✐♥❣ t❤❡ ❛rr❛② ❜② ♦♥❡✳ ■❢ ✇❡ ❛r❡ st✐❧❧ ❛t ❛ ❜r❛♥❝❤ ♥♦❞❡✱ t❤❡♥ t❤❡ ❡✛❡❝t ✐s t♦ ✉♣❞❛t❡ ❛♥ ❡①✐st✐♥❣ ❛rr❛② ❡❧❡♠❡♥t✳ ❆ s✐♠✐❧❛r ❢✉♥❝t✐♦♥ ❝❛♥ s❤r✐♥❦ ❛♥ ❛rr❛② ❜② ♦♥❡✳ ▲❡❛r♥✐♥❣ ❣✉✐❞❡✳ ❘❡❧❛t❡❞ ♠❛t❡r✐❛❧ ✐s ✐♥ ▼▲ ❢♦r t❤❡ ❲♦r❦✐♥❣ Pr♦❣r❛♠♠❡r✱ ♣❛❣❡s ✶✹✽✕✶✺✾✳

■❳ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✽✼

Slide 901

Breadth-First v Depth-First Tree Traversal

binary trees as decision trees Look for solution nodes

• Depth-first: search one subtree in full before moving on
• Breadth-first: search all nodes at level k before moving to k + 1

Finds all solutions — nearest first!

Pr❡♦r❞❡r✱ ✐♥♦r❞❡r ❛♥❞ ♣♦st♦r❞❡r tr❡❡ tr❛✈❡rs❛❧s ❛❧❧ ❤❛✈❡ s♦♠❡t❤✐♥❣ ✐♥ ❝♦♠♠♦♥✿ t❤❡② ❛r❡ ❞❡♣t❤✲✜rst✳ ❆t ❡❛❝❤ ♥♦❞❡✱ t❤❡ ❧❡❢t s✉❜tr❡❡ ✐s ❡♥t✐r❡❧② tr❛✈❡rs❡❞ ❜❡❢♦r❡ t❤❡ r✐❣❤t s✉❜tr❡❡✳ ❉❡♣t❤✲✜rst tr❛✈❡rs❛❧s ❛r❡ ❡❛s② t♦ ❝♦❞❡ ❛♥❞ ❝❛♥ ❜❡ ❡✣❝✐❡♥t✱ ❜✉t t❤❡② ❛r❡ ✐❧❧✲s✉✐t❡❞ ❢♦r s♦♠❡ ♣r♦❜❧❡♠s✳ ❙✉♣♣♦s❡ t❤❡ tr❡❡ r❡♣r❡s❡♥ts t❤❡ ♣♦ss✐❜❧❡ ♠♦✈❡s ✐♥ ❛ ♣✉③③❧❡✱ ❛♥❞ t❤❡ ♣✉r✲ ♣♦s❡ ♦❢ t❤❡ tr❛✈❡rs❛❧ ✐s t♦ s❡❛r❝❤ ❢♦r ❛ ♥♦❞❡ ❝♦♥t❛✐♥✐♥❣ ❛ s♦❧✉t✐♦♥✳ ❚❤❡♥ ❛ ❞❡♣t❤✲✜rst tr❛✈❡rs❛❧ ♠❛② ✜♥❞ ♦♥❡ s♦❧✉t✐♦♥ ♥♦❞❡ ❞❡❡♣ ✐♥ t❤❡ ❧❡❢t s✉❜tr❡❡✱ ✇❤❡♥ ❛♥♦t❤❡r s♦❧✉t✐♦♥ ✐s ❛t t❤❡ ✈❡r② t♦♣ ♦❢ t❤❡ r✐❣❤t s✉❜tr❡❡✳ ❖❢t❡♥ ✇❡ ✇❛♥t t❤❡ s❤♦rt❡st ♣❛t❤ t♦ ❛ s♦❧✉t✐♦♥✳ ❙✉♣♣♦s❡ t❤❡ tr❡❡ ✐s ✐♥✜♥✐t❡✳ ✭❚❤❡ ▼▲ ❞❛t❛t②♣❡ tr❡❡ ❝♦♥t❛✐♥s ♦♥❧② ✜♥✐t❡ tr❡❡s✱ ❜✉t ▼▲ ❝❛♥ r❡♣r❡s❡♥t ✐♥✜♥✐t❡ tr❡❡s ❜② ♠❡❛♥s ❞✐s❝✉ss❡❞ ✐♥ ▲❡❝t✳ ✶✸✳✮ ❉❡♣t❤✲✜rst s❡❛r❝❤ ✐s ❛❧♠♦st ✉s❡❧❡ss ✇✐t❤ ✐♥✜♥✐t❡ tr❡❡s✱ ❢♦r ✐❢ t❤❡ ❧❡❢t s✉❜tr❡❡ ✐s ✐♥✜♥✐t❡ t❤❡♥ ✐t ✇✐❧❧ ♥❡✈❡r r❡❛❝❤ t❤❡ r✐❣❤t s✉❜tr❡❡✳ ❆ ❜r❡❛❞t❤✲✜rst tr❛✈❡rs❛❧ ❡①♣❧♦r❡s t❤❡ ♥♦❞❡s ❤♦r✐③♦♥t❛❧❧② r❛t❤❡r t❤❛♥ ✈❡r✲ t✐❝❛❧❧②✳ ❲❤❡♥ ✈✐s✐t✐♥❣ ❛ ♥♦❞❡✱ ✐t ❞♦❡s ♥♦t tr❛✈❡rs❡ t❤❡ s✉❜tr❡❡s ✉♥t✐❧ ✐t ❤❛s ✈✐s✐t❡❞ ❛❧❧ ♦t❤❡r ♥♦❞❡s ❛t t❤❡ ❝✉rr❡♥t ❞❡♣t❤✳ ❚❤✐s ✐s ❡❛s✐❧② ✐♠♣❧❡♠❡♥t❡❞ ❜② ❦❡❡♣✐♥❣ ❛ ❧✐st ♦❢ tr❡❡s t♦ ✈✐s✐t✳ ■♥✐t✐❛❧❧②✱ t❤✐s ❧✐st ❝♦♥s✐sts ♦❢ ♦♥❡ ❡❧❡♠❡♥t✿ t❤❡ ❡♥t✐r❡ tr❡❡✳ ❊❛❝❤ ✐t❡r❛t✐♦♥ r❡♠♦✈❡s ❛ tr❡❡ ❢r♦♠ t❤❡ ❤❡❛❞ ♦❢ t❤❡ ❧✐st ❛♥❞ ❛❞❞s ✐ts s✉❜tr❡❡s ❛❢t❡r t❤❡ ❡♥❞ ♦❢ t❤❡ ❧✐st✳

■❳ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✽✽

Slide 902

Breadth-First Tree Traversal — Using Append

fun nbreadth [] = [] | nbreadth (Lf :: ts) = nbreadth ts | nbreadth (Br(v,t,u) :: ts) = v :: nbreadth(ts @ [t,u])

Keeps an enormous queue of nodes of search Wasteful use of append 25 SECS to search depth 12 binary tree (4095 labels)

❇r❡❛❞t❤✲✜rst s❡❛r❝❤ ❝❛♥ ❜❡ ✐♥❡✣❝✐❡♥t✱ t❤✐s ♥❛✐✈❡ ✐♠♣❧❡♠❡♥t❛t✐♦♥ ❡s♣❡✲ ❝✐❛❧❧② s♦✳ ❲❤❡♥ t❤❡ s❡❛r❝❤ ✐s ❛t ❞❡♣t❤ d ♦❢ t❤❡ tr❡❡✱ t❤❡ ❧✐st ❝♦♥t❛✐♥s ❛❧❧ t❤❡ r❡♠❛✐♥✐♥❣ tr❡❡s ❛t ❞❡♣t❤ d✱ ❢♦❧❧♦✇❡❞ ❜② t❤❡ s✉❜tr❡❡s ✭❛❧❧ ❛t ❞❡♣t❤ d + 1✮ ♦❢ t❤❡ tr❡❡s t❤❛t ❤❛✈❡ ❛❧r❡❛❞② ❜❡❡♥ ✈✐s✐t❡❞✳ ❆t ❞❡♣t❤ ✶✵✱ t❤❡ ❧✐st ❝♦✉❧❞ ❛❧r❡❛❞② ❝♦♥t❛✐♥ ✶✵✷✹ ❡❧❡♠❡♥ts✳ ■t r❡q✉✐r❡s ❛ ❧♦t ♦❢ s♣❛❝❡✱ ❛♥❞ ❛❣❣r❛✈❛t❡s t❤✐s ✇✐t❤ ❛ ❣r♦ss ♠✐s✉s❡ ♦❢ ❛♣♣❡♥❞✳ ❊✈❛❧✉❛t✐♥❣ ts❅❬t✱✉❪ ❝♦♣✐❡s t❤❡ ❧♦♥❣ ❧✐st ts ❥✉st t♦ ✐♥s❡rt t✇♦ ❡❧❡♠❡♥ts✳

■❳ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✽✾

Slide 903

An Abstract Data Type: Queues

• qempty is the empty queue
• qnull tests whether a queue is empty
• qhd returns the element at the head of a queue
• deq discards the element at the head of a queue
• enq adds an element at the end of a queue

❇r❡❛❞t❤✲✜rst s❡❛r❝❤ ❜❡❝♦♠❡s ♠✉❝❤ ❢❛st❡r ✐❢ ✇❡ r❡♣❧❛❝❡ t❤❡ ❧✐sts ❜② q✉❡✉❡s✳ ❆ q✉❡✉❡ r❡♣r❡s❡♥ts ❛ s❡q✉❡♥❝❡✱ ❛❧❧♦✇✐♥❣ ❡❧❡♠❡♥ts t♦ ❜❡ t❛❦❡♥ ❢r♦♠ t❤❡ ❤❡❛❞ ❛♥❞ ❛❞❞❡❞ t♦ t❤❡ t❛✐❧✳ ❚❤✐s ✐s ❛ ❋✐rst✲■♥✲❋✐rst✲❖✉t ✭❋■❋❖✮ ❞✐s❝✐♣❧✐♥❡✿ t❤❡ ✐t❡♠ ♥❡①t t♦ ❜❡ r❡♠♦✈❡❞ ✐s t❤❡ ♦♥❡ t❤❛t ❤❛s ❜❡❡♥ ✐♥ t❤❡ q✉❡✉❡ ❢♦r t❤❡ ❧♦♥❣❡st t✐♠❡✳ ▲✐sts ❝❛♥ ✐♠♣❧❡♠❡♥t q✉❡✉❡s✱ ❜✉t ❛♣♣❡♥❞ ✐s ❛ ♣♦♦r ♠❡❛♥s ♦❢ ❛❞❞✐♥❣ ❡❧❡♠❡♥ts t♦ t❤❡ t❛✐❧✳ ❖✉r ❢✉♥❝t✐♦♥❛❧ ❛rr❛②s ✭▲❡❝t✳ ✽✮ ❛r❡ s✉✐t❛❜❧❡✱ ♣r♦✈✐❞❡❞ ✇❡ ❛✉❣♠❡♥t t❤❡♠ ✇✐t❤ ❛ ❢✉♥❝t✐♦♥ t♦ ❞❡❧❡t❡ t❤❡ ✜rst ❛rr❛② ❡❧❡♠❡♥t✳ ✭❙❡❡ ▼▲ ❢♦r t❤❡ ❲♦r❦✐♥❣ Pr♦❣r❛♠♠❡r✱ ♣❛❣❡ ✶✺✻✳✮ ❊❛❝❤ ♦♣❡r❛t✐♦♥ ✇♦✉❧❞ t❛❦❡ O(log n) t✐♠❡ ❢♦r ❛ q✉❡✉❡ ♦❢ ❧❡♥❣t❤ n✳ ❲❡ s❤❛❧❧ ❞❡s❝r✐❜❡ ❛ r❡♣r❡s❡♥t❛t✐♦♥ ♦❢ q✉❡✉❡s t❤❛t ✐s ♣✉r❡❧② ❢✉♥❝t✐♦♥❛❧✱ ❜❛s❡❞ ✉♣♦♥ ❧✐sts✱ ❛♥❞ ❡✣❝✐❡♥t✳ ❖♣❡r❛t✐♦♥s t❛❦❡ O(1) t✐♠❡ ✇❤❡♥ ❛♠♦rt✐③❡❞✿ ❛✈❡r❛❣❡❞ ♦✈❡r t❤❡ ❧✐❢❡t✐♠❡ ♦❢ ❛ q✉❡✉❡✳ ❆ ❝♦♥✈❡♥t✐♦♥❛❧ ♣r♦❣r❛♠♠✐♥❣ t❡❝❤♥✐q✉❡ ✐s t♦ r❡♣r❡s❡♥t ❛ q✉❡✉❡ ❜② ❛♥ ❛rr❛②✳ ❚✇♦ ✐♥❞✐❝❡s ♣♦✐♥t t♦ t❤❡ ❢r♦♥t ❛♥❞ ❜❛❝❦ ♦❢ t❤❡ q✉❡✉❡✱ ✇❤✐❝❤ ♠❛② ✇r❛♣ ❛r♦✉♥❞ t❤❡ ❡♥❞ ♦❢ t❤❡ ❛rr❛②✳ ❚❤❡ ❝♦❞✐♥❣ ✐s s♦♠❡✇❤❛t tr✐❝❦②✳ ❲♦rs❡✱ t❤❡ ❧❡♥❣t❤ ♦❢ t❤❡ q✉❡✉❡ ♠✉st ❜❡ ❣✐✈❡♥ ❛ ✜①❡❞ ✉♣♣❡r ❜♦✉♥❞✳

■❳ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✾✵

Slide 904

Efficient Functional Queues: Idea

Represent the queue x1 x2 . . . xm yn . . . y1 by any pair of lists

([x1, x2, . . . , xm], [y1, y2, . . . , yn])

Add new items to rear list Remove items from front list; if empty move rear to front Amortized time per operation is O(1)

◗✉❡✉❡s r❡q✉✐r❡ ❡✣❝✐❡♥t ❛❝❝❡ss ❛t ❜♦t❤ ❡♥❞s✿ ❛t t❤❡ ❢r♦♥t✱ ❢♦r r❡♠♦✈❛❧✱ ❛♥❞ ❛t t❤❡ ❜❛❝❦✱ ❢♦r ✐♥s❡rt✐♦♥✳ ■❞❡❛❧❧②✱ ❛❝❝❡ss s❤♦✉❧❞ t❛❦❡ ❝♦♥st❛♥t t✐♠❡✱ O(1)✳ ■t ♠❛② ❛♣♣❡❛r t❤❛t ❧✐sts ❝❛♥♥♦t ♣r♦✈✐❞❡ s✉❝❤ ❛❝❝❡ss✳ ■❢ ❡♥q✭q✱①✮ ♣❡r❢♦r♠s q❅❬①❪✱ t❤❡♥ t❤✐s ♦♣❡r❛t✐♦♥ ✇✐❧❧ ❜❡ O(n)✳ ❲❡ ❝♦✉❧❞ r❡♣r❡s❡♥t q✉❡✉❡s ❜② r❡✈❡rs❡❞ ❧✐sts✱ ✐♠♣❧❡♠❡♥t✐♥❣ ❡♥q✭q✱①✮ ❜② ①✿✿q✱ ❜✉t t❤❡♥ t❤❡ ❞❡q ❛♥❞ q❤❞ ♦♣❡r❛t✐♦♥s ✇♦✉❧❞ ❜❡ O(n)✳ ▲✐♥❡❛r t✐♠❡ ✐s ✐♥t♦❧❡r❛❜❧❡✿ ❛ s❡r✐❡s ♦❢ n q✉❡✉❡ ♦♣❡r❛t✐♦♥s ❝♦✉❧❞ t❤❡♥ r❡q✉✐r❡ O(n2) t✐♠❡✳ ❚❤❡ s♦❧✉t✐♦♥ ✐s t♦ r❡♣r❡s❡♥t ❛ q✉❡✉❡ ❜② ❛ ♣❛✐r ♦❢ ❧✐sts✱ ✇❤❡r❡ ([x1, x2, . . . , xm], [y1, y2, . . . , yn]) r❡♣r❡s❡♥ts t❤❡ q✉❡✉❡ x1x2 . . . xmyn . . . y1✳ ❚❤❡ ❢r♦♥t ♣❛rt ♦❢ t❤❡ q✉❡✉❡ ✐s st♦r❡❞ ✐♥ ♦r❞❡r✱ ❛♥❞ t❤❡ r❡❛r ♣❛rt ✐s st♦r❡❞ ✐♥ r❡✈❡rs❡ ♦r❞❡r✳ ❚❤❡ ❡♥q ♦♣❡r❛t✐♦♥ ❛❞❞s ❡❧❡♠❡♥ts t♦ t❤❡ r❡❛r ♣❛rt ✉s✐♥❣ ❝♦♥s✱ s✐♥❝❡ t❤✐s ❧✐st ✐s r❡✈❡rs❡❞❀ t❤✉s✱ ❡♥q t❛❦❡s ❝♦♥st❛♥t t✐♠❡✳ ❚❤❡ ❞❡q ❛♥❞ q❤❞ ♦♣❡r❛t✐♦♥s ❧♦♦❦ ❛t t❤❡ ❢r♦♥t ♣❛rt✱ ✇❤✐❝❤ ♥♦r♠❛❧❧② t❛❦❡s ❝♦♥st❛♥t t✐♠❡✱ s✐♥❝❡ t❤✐s ❧✐st ✐s st♦r❡❞ ✐♥ ♦r❞❡r✳ ❇✉t s♦♠❡t✐♠❡s ❞❡q r❡♠♦✈❡s t❤❡ ❧❛st ❡❧❡♠❡♥t ❢r♦♠ t❤❡ ❢r♦♥t ♣❛rt❀ ✇❤❡♥ t❤✐s ❤❛♣♣❡♥s✱ ✐t r❡✈❡rs❡s t❤❡ r❡❛r ♣❛rt✱ ✇❤✐❝❤ ❜❡❝♦♠❡s t❤❡ ♥❡✇ ❢r♦♥t ♣❛rt✳ ❆♠♦rt✐③❡❞ t✐♠❡ r❡❢❡rs t♦ t❤❡ ❝♦st ♣❡r ♦♣❡r❛t✐♦♥ ❛✈❡r❛❣❡❞ ♦✈❡r t❤❡ ❧✐❢❡t✐♠❡ ♦❢ ❛♥② ❝♦♠♣❧❡t❡ ❡①❡❝✉t✐♦♥✳ ❊✈❡♥ ❢♦r t❤❡ ✇♦rst ♣♦ss✐❜❧❡ ❡①❡❝✉t✐♦♥✱ t❤❡ ❛✈❡r❛❣❡ ❝♦st ♣❡r ♦♣❡r❛t✐♦♥ t✉r♥s ♦✉t t♦ ❜❡ ❝♦♥st❛♥t❀ s❡❡ t❤❡ ❛♥❛❧②s✐s ❜❡❧♦✇✳

■❳ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✾✶

Slide 905

Efficient Functional Queues: Code

datatype ’a queue = Q of ’a list * ’a list fun norm(Q([],tls)) = Q(rev tls, []) | norm q = q fun qnull(Q([],[])) = true | qnull _ = false fun enq(Q(hds,tls), x) = norm(Q(hds, x::tls)) fun deq(Q(x::hds, tls)) = norm(Q(hds, tls))

❚❤❡ ❞❛t❛t②♣❡ ♦❢ q✉❡✉❡s ♣r❡✈❡♥ts ❝♦♥❢✉s✐♦♥ ✇✐t❤ ♦t❤❡r ♣❛✐rs ♦❢ ❧✐sts✳ ❚❤❡ ❡♠♣t② q✉❡✉❡✱ ♦♠✐tt❡❞ t♦ s❛✈❡ s♣❛❝❡ ♦♥ t❤❡ s❧✐❞❡✱ ❤❛s ❜♦t❤ ♣❛rts ❡♠♣t②✳

✈❛❧ q❡♠♣t② ❂ ◗✭❬❪✱❬❪✮❀

❚❤❡ ❢✉♥❝t✐♦♥ ♥♦r♠ ♣✉ts ❛ q✉❡✉❡ ✐♥t♦ ♥♦r♠❛❧ ❢♦r♠✱ ❡♥s✉r✐♥❣ t❤❛t t❤❡ ❢r♦♥t ♣❛rt ✐s ♥❡✈❡r ❡♠♣t② ✉♥❧❡ss t❤❡ ❡♥t✐r❡ q✉❡✉❡ ✐s ❡♠♣t②✳ ❋✉♥❝t✐♦♥s ❞❡q ❛♥❞ ❡♥q ❝❛❧❧ ♥♦r♠ t♦ ♥♦r♠❛❧✐③❡ t❤❡✐r r❡s✉❧t✳ ❇❡❝❛✉s❡ q✉❡✉❡s ❛r❡ ✐♥ ♥♦r♠❛❧ ❢♦r♠✱ t❤❡✐r ❤❡❛❞ ✐s ❝❡rt❛✐♥ t♦ ❜❡ ✐♥ t❤❡✐r ❢r♦♥t ♣❛rt✱ s♦ q❤❞ ✭❛❧s♦ ♦♠✐tt❡❞ ❢r♦♠ t❤❡ s❧✐❞❡✮ ❧♦♦❦s t❤❡r❡✳

❢✉♥ q❤❞✭◗✭①✿✿❴✱❴✮✮ ❂ ①

▲❡t ✉s ❛♥❛❧②s❡ t❤❡ ❝♦st ♦❢ ❛♥ ❡①❡❝✉t✐♦♥ ❝♦♠♣r✐s✐♥❣ ✭✐♥ ❛♥② ♣♦ss✐❜❧❡ ♦r❞❡r✮ n ❡♥q ♦♣❡r❛t✐♦♥s ❛♥❞ n ❞❡q ♦♣❡r❛t✐♦♥s✱ st❛rt✐♥❣ ✇✐t❤ ❛♥ ❡♠♣t② q✉❡✉❡✳ ❊❛❝❤ ❡♥q ♦♣❡r❛t✐♦♥ ✇✐❧❧ ♣❡r❢♦r♠ ♦♥❡ ❝♦♥s✱ ❛❞❞✐♥❣ ❛♥ ❡❧❡♠❡♥t t♦ t❤❡ r❡❛r ♣❛rt✳ ❙✐♥❝❡ t❤❡ ✜♥❛❧ q✉❡✉❡ ♠✉st ❜❡ ❡♠♣t②✱ ❡❛❝❤ ❡❧❡♠❡♥t ♦❢ t❤❡ r❡❛r ♣❛rt ❣❡ts tr❛♥s❢❡rr❡❞ t♦ t❤❡ ❢r♦♥t ♣❛rt✳ ❚❤❡ ❝♦rr❡s♣♦♥❞✐♥❣ r❡✈❡rs❛❧s ♣❡r❢♦r♠ ♦♥❡ ❝♦♥s ♣❡r ❡❧❡♠❡♥t✳ ❚❤✉s✱ t❤❡ t♦t❛❧ ❝♦st ♦❢ t❤❡ s❡r✐❡s ♦❢ q✉❡✉❡ ♦♣❡r❛t✐♦♥s ✐s 2n ❝♦♥s ♦♣❡r❛t✐♦♥s✱ ❛♥ ❛✈❡r❛❣❡ ♦❢ ✷ ♣❡r ♦♣❡r❛t✐♦♥✳ ❚❤❡ ❛♠♦rt✐③❡❞ t✐♠❡ ✐s O(1)✳ ❚❤❡r❡ ✐s ❛ ❝❛t❝❤✳ ❚❤❡ ❝♦♥s❡s ♥❡❡❞ ♥♦t ❜❡ ❞✐str✐❜✉t❡❞ ❡✈❡♥❧②❀ r❡✈❡rs✐♥❣ ❛ ❧♦♥❣ ❧✐st ❝♦✉❧❞ t❛❦❡ ✉♣ t♦ n − 1 ♦❢ t❤❡♠✳ ❯♥♣r❡❞✐❝t❛❜❧❡ ❞❡❧❛②s ♠❛❦❡ t❤❡ ❛♣♣r♦❛❝❤ ✉♥s✉✐t❛❜❧❡ ❢♦r r❡❛❧✲t✐♠❡ ♣r♦❣r❛♠♠✐♥❣✱ ✇❤❡r❡ ❞❡❛❞❧✐♥❡s ♠✉st ❜❡ ♠❡t✳

■❳ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✾✷

Slide 906

Aside: The case Expression

fun wheels v = case v of Bike => 2 | Motorbike _ => 2 | Car robin => if robin then 3 else 4 | Lorry w => w;

❚❤❡ ❝❛s❡ ❡①♣r❡ss✐♦♥ ❤❛s t❤❡ ❢♦r♠ ❝❛s❡ E ♦❢ P1 ❂❃ E1 ⑤ · · · ⑤ Pn ❂❃ En ■t tr✐❡s t❤❡ ♣❛tt❡r♥s ♦♥❡ ❛❢t❡r t❤❡ ♦t❤❡r✳ ❲❤❡♥ ♦♥❡ ♠❛t❝❤❡s✱ ✐t ❡✈❛❧✉❛t❡s t❤❡ ❝♦rr❡s♣♦♥❞✐♥❣ ❡①♣r❡ss✐♦♥✳ ■t ❜❡❤❛✈❡s ♣r❡❝✐s❡❧② ❧✐❦❡ t❤❡ ❜♦❞② ♦❢ ❛ ❢✉♥❝t✐♦♥ ❞❡❝❧❛r❛t✐♦♥✳ ❲❡ ❝♦✉❧❞ ❤❛✈❡ ❞❡✜♥❡❞ ❢✉♥❝t✐♦♥ ✇❤❡❡❧s ✭❢r♦♠ ▲❡❝t✳ ✼✮ ❛s s❤♦✇♥ ❛❜♦✈❡✳ ❆ ♣r♦❣r❛♠ ♣❤r❛s❡ ♦❢ t❤❡ ❢♦r♠ P1 ❂❃ E1 ⑤ · · · ⑤ Pn ❂❃ En ✐s ❝❛❧❧❡❞ ❛ ▼❛t❝❤✳ ❆ ♠❛t❝❤ ♠❛② ❛❧s♦ ❛♣♣❡❛r ❛❢t❡r ❛♥ ❡①❝❡♣t✐♦♥ ❤❛♥❞❧❡r ✭▲❡❝t✳ ✼✮ ❛♥❞ ✇✐t❤ ❢♥✲♥♦t❛t✐♦♥ t♦ ❡①♣r❡ss✐♦♥ ❢✉♥❝t✐♦♥s ❞✐r❡❝t❧② ✭▲❡❝t✳ ✶✵✮✳

■❳ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✾✸

Slide 907

Breadth-First Tree Traversal — Using Queues

fun breadth q = if qnull q then [] else case qhd q of Lf => breadth (deq q) | Br(v,t,u) => v :: breadth(enq(enq(deq q, t), u))

0.14 secs to search depth 12 binary tree (4095 labels) 200 times faster!

❚❤✐s ❢✉♥❝t✐♦♥ ✐♠♣❧❡♠❡♥ts t❤❡ s❛♠❡ ❛❧❣♦r✐t❤♠ ❛s ♥❜r❡❛❞t❤ ❜✉t ✉s❡s ❛ ❞✐✛❡r❡♥t ❞❛t❛ str✉❝t✉r❡✳ ■t r❡♣r❡s❡♥ts q✉❡✉❡s ✉s✐♥❣ t②♣❡ q✉❡✉❡ ✐♥st❡❛❞ ♦❢ t②♣❡ ❧✐st✳ ❚♦ ❝♦♠♣❛r❡ t❤❡✐r ❡✣❝✐❡♥❝②✱ ■ ❛♣♣❧✐❡❞ ❜♦t❤ ❢✉♥❝t✐♦♥s t♦ t❤❡ ❢✉❧❧ ❜✐♥❛r② tr❡❡ ♦❢ ❞❡♣t❤ ✶✷✱ ✇❤✐❝❤ ❝♦♥t❛✐♥s ✹✵✾✺ ❧❛❜❡❧s✳ ❚❤❡ ❢✉♥❝t✐♦♥ ♥❜r❡❛❞t❤ t♦♦❦ ✸✵ s❡❝♦♥❞s ✇❤✐❧❡ ❜r❡❛❞t❤ t♦♦❦ ♦♥❧② ✵✳✶✺ s❡❝♦♥❞s✿ ❢❛st❡r ❜② ❛ ❢❛❝t♦r ♦❢ ✷✵✵✳ ❋♦r ❧❛r❣❡r tr❡❡s✱ t❤❡ s♣❡❡❞✉♣ ✇♦✉❧❞ ❜❡ ❣r❡❛t❡r✳ ❈❤♦♦s✐♥❣ t❤❡ r✐❣❤t ❞❛t❛ str✉❝t✉r❡ ♣❛②s ❤❛♥❞s♦♠❡❧②✳

■❳ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✾✹

Slide 908

Iterative deepening: Another Exhaustive Search

Breadth-first search examines O(bd) nodes:

1 + b + · · · + bd = bd+1 − 1 b − 1 b = branching factor d = depth

Recompute nodes at depth d instead of storing them Time factor is b/(b − 1) if b > 1; complexity is still O(bd) Space required at depth d drops from bd to d

❇r❡❛❞t❤✲✜rst s❡❛r❝❤ ✐s ♥♦t ♣r❛❝t✐❝❛❧ ❢♦r ❜✐❣ ♣r♦❜❧❡♠s✿ ✐t ✉s❡s t♦♦ ♠✉❝❤ s♣❛❝❡✳ ❈♦♥s✐❞❡r t❤❡ s❧✐❣❤t❧② ♠♦r❡ ❣❡♥❡r❛❧ ♣r♦❜❧❡♠ ♦❢ s❡❛r❝❤✐♥❣ tr❡❡s ✇❤♦s❡ ❜r❛♥❝❤✐♥❣ ❢❛❝t♦r ✐s b ✭❢♦r ❜✐♥❛r② tr❡❡s✱ b = 2✮✳ ❚❤❡♥ ❜r❡❛❞t❤✲✜rst s❡❛r❝❤ t♦ ❞❡♣t❤ d ❡①❛♠✐♥❡s (bd+1 − 1)/(b − 1) ♥♦❞❡s✱ ✇❤✐❝❤ ✐s O(bd)✱ ✐❣♥♦r✐♥❣ t❤❡ ❝♦♥st❛♥t ❢❛❝t♦r ♦❢ b/(b − 1)✳✮ ❙✐♥❝❡ ❛❧❧ ♥♦❞❡s t❤❛t ❛r❡ ❡①❛♠✐♥❡❞ ❛r❡ ❛❧s♦ st♦r❡❞✱ t❤❡ s♣❛❝❡ ❛♥❞ t✐♠❡ r❡q✉✐r❡♠❡♥ts ❛r❡ ❜♦t❤ O(bd)✳ ❉❡♣t❤✲✜rst ✐t❡r❛t✐✈❡ ❞❡❡♣❡♥✐♥❣ ❝♦♠❜✐♥❡s t❤❡ s♣❛❝❡ ❡✣❝✐❡♥❝② ♦❢ ❞❡♣t❤✲✜rst ✇✐t❤ t❤❡ ❵♥❡❛r❡st✲✜rst✬ ♣r♦♣❡rt② ♦❢ ❜r❡❛❞t❤✲✜rst s❡❛r❝❤✳ ■t ♣❡r❢♦r♠s r❡♣❡❛t❡❞ ❞❡♣t❤✲✜rst s❡❛r❝❤❡s ✇✐t❤ ✐♥❝r❡❛s✐♥❣ ❞❡♣t❤ ❜♦✉♥❞s✱ ❡❛❝❤ t✐♠❡ ❞✐s❝❛r❞✐♥❣ t❤❡ r❡s✉❧t ♦❢ t❤❡ ♣r❡✈✐♦✉s s❡❛r❝❤✳ ❚❤✉s ✐t s❡❛r❝❤❡s t♦ ❞❡♣t❤ ✶✱ t❤❡♥ t♦ ❞❡♣t❤ ✷✱ ❛♥❞ s♦ ♦♥ ✉♥t✐❧ ✐t ✜♥❞s ❛ s♦❧✉t✐♦♥✳ ❲❡ ❝❛♥ ❛✛♦r❞ t♦ ❞✐s❝❛r❞ ♣r❡✈✐♦✉s r❡s✉❧ts ❜❡❝❛✉s❡ t❤❡ ♥✉♠❜❡r ♦❢ ♥♦❞❡s ✐s ❣r♦✇✐♥❣ ❡①♣♦♥❡♥t✐❛❧❧②✳ ❚❤❡r❡ ❛r❡ bd+1 ♥♦❞❡s ❛t ❧❡✈❡❧ d + 1❀ ✐❢ b ≥ 2✱ t❤✐s ♥✉♠❜❡r ❛❝t✉❛❧❧② ❡①❝❡❡❞s t❤❡ t♦t❛❧ ♥✉♠❜❡r ♦❢ ♥♦❞❡s ♦❢ ❛❧❧ ♣r❡✈✐♦✉s ❧❡✈❡❧s ♣✉t t♦❣❡t❤❡r✱ ♥❛♠❡❧② (bd+1 − 1)/(b − 1)✳ ❑♦r❢ ❬✶✶❪ s❤♦✇s t❤❛t t❤❡ t✐♠❡ ♥❡❡❞❡❞ ❢♦r ✐t❡r❛t✐✈❡ ❞❡❡♣❡♥✐♥❣ t♦ r❡❛❝❤ ❞❡♣t❤ d ✐s ♦♥❧② b/(b − 1) t✐♠❡s t❤❛t ❢♦r ❜r❡❛❞t❤✲✜rst s❡❛r❝❤✱ ✐❢ b > 1✳ ❚❤✐s ✐s ❛ ❝♦♥st❛♥t ❢❛❝t♦r❀ ❜♦t❤ ❛❧❣♦r✐t❤♠s ❤❛✈❡ t❤❡ s❛♠❡ t✐♠❡ ❝♦♠♣❧❡①✐t②✱ O(bd)✳ ■♥ t②♣✐❝❛❧ ❛♣♣❧✐❝❛t✐♦♥s ✇❤❡r❡ b ≥ 2 t❤❡ ❡①tr❛ ❢❛❝t♦r ♦❢ b/(b − 1) ✐s q✉✐t❡ t♦❧❡r❛❜❧❡✳ ❚❤❡ r❡❞✉❝t✐♦♥ ✐♥ t❤❡ s♣❛❝❡ r❡q✉✐r❡♠❡♥t ✐s ❡①♣♦♥❡♥t✐❛❧✱ ❢r♦♠ O(bd) ❢♦r ❜r❡❛❞t❤✲✜rst t♦ O(d) ❢♦r ✐t❡r❛t✐✈❡ ❞❡❡♣❡♥✐♥❣✳

■❳ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✾✺

Slide 909

Another Abstract Data Type: Stacks

• empty is the empty stack
• null tests whether a stack is empty
• top returns the element at the top of a stack
• pop discards the element at the top of a stack
• push adds an element at the top of a stack

❆ st❛❝❦ ✐s ❛ s❡q✉❡♥❝❡ s✉❝❤ t❤❛t ✐t❡♠s ❝❛♥ ❜❡ ❛❞❞❡❞ ♦r r❡♠♦✈❡❞ ❢r♦♠ t❤❡ ❤❡❛❞ ♦♥❧②✳ ❆ st❛❝❦ ♦❜❡②s ❛ ▲❛st✲■♥✲❋✐rst✲❖✉t ✭▲■❋❖✮ ❞✐s❝✐♣❧✐♥❡✿ t❤❡ ✐t❡♠ ♥❡①t t♦ ❜❡ r❡♠♦✈❡❞ ✐s t❤❡ ♦♥❡ t❤❛t ❤❛s ❜❡❡♥ ✐♥ t❤❡ q✉❡✉❡ ❢♦r t❤❡ s❤♦rt❡st t✐♠❡✳ ▲✐sts ❝❛♥ ❡❛s✐❧② ✐♠♣❧❡♠❡♥t st❛❝❦s ❜❡❝❛✉s❡ ❜♦t❤ ❝♦♥s ❛♥❞ ❤❞ ❛✛❡❝t t❤❡ ❤❡❛❞✳ ❇✉t ✉♥❧✐❦❡ ❧✐sts✱ st❛❝❦s ❛r❡ ♦❢t❡♥ r❡❣❛r❞❡❞ ❛s ❛♥ ✐♠♣❡r❛t✐✈❡ ❞❛t❛ str✉❝t✉r❡✿ t❤❡ ❡✛❡❝t ♦❢ ♣✉s❤ ♦r ♣♦♣ ✐s t♦ ❝❤❛♥❣❡ ❛♥ ❡①✐st✐♥❣ st❛❝❦✱ ♥♦t r❡t✉r♥ ❛ ♥❡✇ ♦♥❡✳ ■♥ ❝♦♥✈❡♥t✐♦♥❛❧ ♣r♦❣r❛♠♠✐♥❣ ❧❛♥❣✉❛❣❡s✱ ❛ st❛❝❦ ✐s ♦❢t❡♥ ✐♠♣❧❡♠❡♥t❡❞ ❜② st♦r✐♥❣ t❤❡ ❡❧❡♠❡♥ts ✐♥ ❛♥ ❛rr❛②✱ ✉s✐♥❣ ❛ ✈❛r✐❛❜❧❡ ✭t❤❡ st❛❝❦ ♣♦✐♥t❡r✮ t♦ ❝♦✉♥t t❤❡♠✳ ▼♦st ❧❛♥❣✉❛❣❡ ♣r♦❝❡ss♦rs ❦❡❡♣ tr❛❝❦ ♦❢ r❡❝✉rs✐✈❡ ❢✉♥❝t✐♦♥ ❝❛❧❧s ✉s✐♥❣ ❛♥ ✐♥t❡r♥❛❧ st❛❝❦✳

■❳ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✾✻

Slide 910

A Survey of Search Methods

• 1. Depth-first: use a stack

(efficient but incomplete)

• 2. Breadth-first: use a queue

(uses too much space!)

• 3. Iterative deepening: use (1) to get benefits of (2)

(trades time for space)

• 4. Best-first: use a priority queue

(heuristic search) The data structure determines the search!

❙❡❛r❝❤ ♣r♦❝❡❞✉r❡s ❝❛♥ ❜❡ ❝❧❛ss✐✜❡❞ ❜② t❤❡ ❞❛t❛ str✉❝t✉r❡ ✉s❡❞ t♦ st♦r❡ ♣❡♥❞✐♥❣ s✉❜tr❡❡s✳ ❉❡♣t❤✲✜rst s❡❛r❝❤ st♦r❡s t❤❡♠ ♦♥ ❛ st❛❝❦✱ ✇❤✐❝❤ ✐s ✐♠♣❧✐❝✐t ✐♥ ❢✉♥❝t✐♦♥s ❧✐❦❡ ✐♥♦r❞❡r✱ ❜✉t ❝❛♥ ❜❡ ♠❛❞❡ ❡①♣❧✐❝✐t✳ ❇r❡❛❞t❤✲✜rst s❡❛r❝❤ st♦r❡s s✉❝❤ ♥♦❞❡s ✐♥ ❛ q✉❡✉❡✳ ❆♥ ✐♠♣♦rt❛♥t ✈❛r✐❛t✐♦♥ ✐s t♦ st♦r❡ t❤❡ ♥♦❞❡s ✐♥ ❛ ♣r✐♦r✐t② q✉❡✉❡✱ ✇❤✐❝❤ ✐s ❛♥ ♦r❞❡r❡❞ s❡q✉❡♥❝❡✳ ❚❤❡ ♣r✐♦r✐t② q✉❡✉❡ ❛♣♣❧✐❡s s♦♠❡ s♦rt ♦❢ r❛♥❦✐♥❣ ❢✉♥❝t✐♦♥ t♦ t❤❡ ♥♦❞❡s✱ ♣❧❛❝✐♥❣ ❤✐❣❤❡r✲r❛♥❦❡❞ ♥♦❞❡s ❜❡❢♦r❡ ❧♦✇❡r✲r❛♥❦❡❞ ♦♥❡s✳ ❚❤❡ r❛♥❦✐♥❣ ❢✉♥❝t✐♦♥ t②♣✐❝❛❧❧② ❡st✐♠❛t❡s t❤❡ ❞✐st❛♥❝❡ ❢r♦♠ t❤❡ ♥♦❞❡ t♦ ❛ s♦❧✉t✐♦♥✳ ■❢ t❤❡ ❡st✐♠❛t❡ ✐s ❣♦♦❞✱ t❤❡ s♦❧✉t✐♦♥ ✐s ❧♦❝❛t❡❞ s✇✐❢t❧②✳ ❚❤✐s ♠❡t❤♦❞ ✐s ❝❛❧❧❡❞ ❜❡st✲✜rst s❡❛r❝❤✳ ❚❤❡ ♣r✐♦r✐t② q✉❡✉❡ ❝❛♥ ❜❡ ❦❡♣t ❛s ❛ s♦rt❡❞ ❧✐st✱ ❛❧t❤♦✉❣❤ t❤✐s ✐s s❧♦✇✳ ❇✐♥❛r② s❡❛r❝❤ tr❡❡s ✇♦✉❧❞ ❜❡ ♠✉❝❤ ❜❡tt❡r ♦♥ ❛✈❡r❛❣❡✱ ❛♥❞ ❢❛♥❝✐❡r ❞❛t❛ str✉❝✲ t✉r❡s ✐♠♣r♦✈❡ ♠❛tt❡rs ❢✉rt❤❡r✳ ▲❡❛r♥✐♥❣ ❣✉✐❞❡✳ ❘❡❧❛t❡❞ ♠❛t❡r✐❛❧ ✐s ✐♥ ▼▲ ❢♦r t❤❡ ❲♦r❦✐♥❣ Pr♦❣r❛♠♠❡r✱ ♣❛❣❡s ✷✺✽✕✷✻✸✳ ❋♦r ♣r✐♦r✐t② q✉❡✉❡s✱ s❡❡ ✶✺✾✕✶✻✹✳

❳ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✾✼

Slide 1001

Functions as Values

In ML, functions can be

• passed as arguments to other functions,
• returned as results,
• put into lists, trees, etc.,
• but not tested for equality.

Functions represent algorithms and infinite data structures.

Pr♦❣r❡ss ✐♥ ♣r♦❣r❛♠♠✐♥❣ ❧❛♥❣✉❛❣❡s ❝❛♥ ❜❡ ♠❡❛s✉r❡❞ ❜② ✇❤❛t ❛❜str❛❝✲ t✐♦♥s t❤❡② ❛❞♠✐t✳ ❈♦♥❞✐t✐♦♥❛❧ ❡①♣r❡ss✐♦♥s ✭❞❡s❝❡♥❞❡❞ ❢r♦♠ ❝♦♥❞✐t✐♦♥❛❧ ❥✉♠♣s ❜❛s❡❞ ♦♥ t❤❡ s✐❣♥ ♦❢ s♦♠❡ ♥✉♠❡r✐❝ ✈❛r✐❛❜❧❡✮ ❛♥❞ ♣❛r❛♠❡tr✐❝ t②♣❡s s✉❝❤ ❛s α ❧✐st ❛r❡ ❡①❛♠♣❧❡s✳ ❚❤❡ ✐❞❡❛ t❤❛t ❢✉♥❝t✐♦♥s ❝♦✉❧❞ ❜❡ ✉s❡❞ ❛s ✈❛❧✉❡s ✐♥ ❛ ❝♦♠♣✉t❛t✐♦♥ ❛r♦s❡ ❡❛r❧②✱ ❜✉t ✐t t♦♦❦ s♦♠❡ t✐♠❡ ❜❡❢♦r❡ t❤❡ ✐❞❡❛ ✇❛s ❢✉❧❧② r❡❛❧✐③❡❞✳ ▼❛♥② ♣r♦❣r❛♠♠✐♥❣ ❧❛♥❣✉❛❣❡s ❧❡t ❢✉♥❝t✐♦♥s ❜❡ ♣❛ss❡❞ ❛s ❛r❣✉♠❡♥ts t♦ ♦t❤❡r ❢✉♥❝t✐♦♥s✱ ❜✉t ❢❡✇ t❛❦❡ t❤❡ tr♦✉❜❧❡ ♥❡❡❞❡❞ t♦ ❛❧❧♦✇ ❢✉♥❝t✐♦♥s t♦ ❜❡ r❡t✉r♥❡❞ ❛s r❡s✉❧ts✳ ■♥ ♠❛t❤❡♠❛t✐❝s✱ ❛ ❢✉♥❝t✐♦♥❛❧ ♦r ❤✐❣❤❡r✲♦r❞❡r ❢✉♥❝t✐♦♥ ✐s ❛ ❢✉♥❝t✐♦♥ t❤❛t tr❛♥s❢♦r♠s ♦t❤❡r ❢✉♥❝t✐♦♥s✳ ▼❛♥② ❢✉♥❝t✐♦♥❛❧s ❛r❡ ❢❛♠✐❧✐❛r ❢r♦♠ ♠❛t❤❡♠❛t✐❝s✱ s✉❝❤ ❛s ✐♥t❡❣r❛❧ ❛♥❞ ❞✐✛❡r❡♥t✐❛❧ ♦♣❡r❛t♦rs ♦❢ t❤❡ ❝❛❧❝✉❧✉s✳ ❚♦ ❛ ♠❛t❤❡♠❛t✐✲ ❝✐❛♥✱ ❛ ❢✉♥❝t✐♦♥ ✐s t②♣✐❝❛❧❧② ❛♥ ✐♥✜♥✐t❡✱ ✉♥❝♦♠♣✉t❛❜❧❡ ♦❜❥❡❝t✳ ❲❡ ✉s❡ ▼▲ ❢✉♥❝t✐♦♥s t♦ r❡♣r❡s❡♥t ❛❧❣♦r✐t❤♠s✳ ❙♦♠❡t✐♠❡s t❤❡② r❡♣r❡s❡♥t ✐♥✜♥✐t❡ ❝♦❧❧❡❝✲ t✐♦♥s ♦❢ ❞❛t❛ ❣✐✈❡♥ ❜② ❝♦♠♣✉t❛t✐♦♥ r✉❧❡s✳ ❋✉♥❝t✐♦♥s ❝❛♥♥♦t ❜❡ ❝♦♠♣❛r❡❞ ❢♦r ❡q✉❛❧✐t②✳ ❚❤❡ ❜❡st ✇❡ ❝♦✉❧❞ ❞♦✱ ✇✐t❤ r❡❛s♦♥❛❜❧❡ ❡✣❝✐❡♥❝②✱ ✇♦✉❧❞ ❜❡ t♦ t❡st ✐❞❡♥t✐t② ♦❢ ♠❛❝❤✐♥❡ ❛❞❞r❡ss❡s✳ ❚✇♦ s❡♣❛r❛t❡ ♦❝❝✉rr❡♥❝❡s ♦❢ t❤❡ s❛♠❡ ❢✉♥❝t✐♦♥ ❞❡❝❧❛r❛t✐♦♥ ✇♦✉❧❞ ❜❡ r❡❣❛r❞❡❞ ❛s ✉♥❡q✉❛❧ ❜❡❝❛✉s❡ t❤❡② ✇♦✉❧❞ ❜❡ ❝♦♠♣✐❧❡❞ t♦ ❞✐✛❡r❡♥t ♠❛❝❤✐♥❡ ❛❞❞r❡ss❡s✳ ❙✉❝❤ ❛ ❧♦✇✲❧❡✈❡❧ ❢❡❛t✉r❡ ❤❛s ♥♦ ♣❧❛❝❡ ✐♥ ❛ ❧❛♥❣✉❛❣❡ ❧✐❦❡ ▼▲✳

❳ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✾✽

Slide 1002

Functions Without Names fn x => E is the function f such that f(x) = E

The function (fn n => n*2) is a doubling function.

(fn n => n*2); > val it = fn : int -> int (fn n => n*2) 17; > val it = 34 : int

■❢ ❢✉♥❝t✐♦♥s ❛r❡ t♦ ❜❡ r❡❣❛r❞❡❞ ❛s ❝♦♠♣✉t❛t✐♦♥❛❧ ✈❛❧✉❡s✱ t❤❡♥ ✇❡ ♥❡❡❞ ❛ ♥♦t❛t✐♦♥ ❢♦r t❤❡♠✳ ❚❤❡ ❢♥✲♥♦t❛t✐♦♥ ❡①♣r❡ss❡s ❛ ❢✉♥❝t✐♦♥ ✈❛❧✉❡ ✇✐t❤♦✉t ❣✐✈✐♥❣ t❤❡ ❢✉♥❝t✐♦♥ ❛ ♥❛♠❡✳ ✭❙♦♠❡ ♣❡♦♣❧❡ ♣r♦♥♦✉♥❝❡ ❢♥ ❛s ❵❧❛♠❜❞❛✬ ❜❡❝❛✉s❡ ✐t ♦r✐❣✐♥❛t❡❞ ✐♥ t❤❡ λ✲❝❛❧❝✉❧✉s✳✮ ■t ❝❛♥♥♦t ❡①♣r❡ss r❡❝✉rs✐♦♥✳ ■ts ♠❛✐♥ ♣✉r♣♦s❡ ✐s t♦ ♣❛❝❦❛❣❡ ✉♣ s♠❛❧❧ ❡①♣r❡ss✐♦♥s t❤❛t ❛r❡ t♦ ❜❡ ❛♣♣❧✐❡❞ r❡♣❡❛t❡❞❧② ✉s✐♥❣ s♦♠❡ ♦t❤❡r ❢✉♥❝t✐♦♥✳ ❚❤❡ ❡①♣r❡ss✐♦♥ ✭❢♥ ♥ ❂❃ ♥✯✷✮ ❤❛s t❤❡ s❛♠❡ ✈❛❧✉❡ ❛s t❤❡ ✐❞❡♥t✐✜❡r ❞♦✉❜❧❡✱ ❞❡❝❧❛r❡❞ ❛s ❢♦❧❧♦✇s✿

❢✉♥ ❞♦✉❜❧❡ ♥ ❂ ♥✯✷

❚❤❡ ❢♥✲♥♦t❛t✐♦♥ ❛❧❧♦✇s ♣❛tt❡r♥✲♠❛t❝❤✐♥❣✱ ❧✐❦❡ ❝❛s❡ ❡①♣r❡ss✐♦♥s ❛♥❞ ❡①✲ ❝❡♣t✐♦♥ ❤❛♥❞❧❡rs✱ t♦ ❡①♣r❡ss ❢✉♥❝t✐♦♥s ✇✐t❤ ♠✉❧t✐♣❧❡ ❝❧❛✉s❡s✿

❢♥ P1 ❂❃ E1 ⑤ ✳✳✳ ⑤ Pn ❂❃ En

❚❤✐s r❛r❡❧②✲✉s❡❞ ❡①♣r❡ss✐♦♥ ❛❜❜r❡✈✐❛t❡s t❤❡ ❧♦❝❛❧ ❞❡❝❧❛r❛t✐♦♥

❧❡t ❢✉♥ f(P1) ❂ E1 ⑤ ✳✳✳ ⑤ f(Pn) ❂ En ✐♥ f ❡♥❞

❋♦r ❡①❛♠♣❧❡✱ t❤❡ ❢♦❧❧♦✇✐♥❣ ❞❡❝❧❛r❛t✐♦♥s ❛r❡ ❡q✉✐✈❛❧❡♥t✿

✈❛❧ ♥♦t ❂ ✭❢♥ ❢❛❧s❡ ❂❃ tr✉❡ ⑤ tr✉❡ ❂❃ ❢❛❧s❡✮ ❢✉♥ ♥♦t ❢❛❧s❡ ❂ tr✉❡ ⑤ ♥♦t tr✉❡ ❂ ❢❛❧s❡

❳ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✾✾

Slide 1003

Curried Functions

A curried function returns another function as its result.

val prefix = (fn a => (fn b => a^b)); > val prefix = fn: string -> (string -> string)

prefix yields functions of type string -> string.

Each of these refers to some value of the argument a.

❚❤❡ ❢♥✲♥♦t❛t✐♦♥ ❧❡ts ✉s ♣❛❝❦❛❣❡ ♥✯✷ ❛s t❤❡ ❢✉♥❝t✐♦♥ ✭❢♥ ♥ ❂❃ ♥✯✷✮✱ ❜✉t ✇❤❛t ✐❢ t❤❡r❡ ❛r❡ s❡✈❡r❛❧ ✈❛r✐❛❜❧❡s✱ ❛s ✐♥ ✭♥✯✷✰❦✮❄ ■❢ t❤❡ ✈❛r✐❛❜❧❡ ❦ ✐s ❞❡✜♥❡❞ ✐♥ t❤❡ ❝✉rr❡♥t ❝♦♥t❡①t✱ t❤❡♥

❢♥ ♥ ❂❃ ♥✯✷✰❦

✐s st✐❧❧ ♠❡❛♥✐♥❣❢✉❧✳ ❚♦ ♠❛❦❡ ❛ ❢✉♥❝t✐♦♥ ♦❢ t✇♦ ❛r❣✉♠❡♥ts✱ ✇❡ ♠❛② ✉s❡ ♣❛tt❡r♥✲ ♠❛t❝❤✐♥❣ ♦♥ ♣❛✐rs✱ ✇r✐t✐♥❣

❢♥ ✭♥✱❦✮ ❂❃ ♥✯✷✰❦

❆ ♠♦r❡ ✐♥t❡r❡st✐♥❣ ❛❧t❡r♥❛t✐✈❡ ✐s t♦ ♥❡st t❤❡ ❢♥✲♥♦t❛t✐♦♥✿

❢♥ ❦ ❂❃ ✭❢♥ ♥ ❂❃ ♥✯✷✰❦✮

❆♣♣❧②✐♥❣ t❤✐s ❢✉♥❝t✐♦♥ t♦ t❤❡ ❛r❣✉♠❡♥t ✶ ②✐❡❧❞s ❛♥♦t❤❡r ❢✉♥❝t✐♦♥✱

❢♥ ♥ ❂❃ ♥✯✷✰✶

✇❤✐❝❤✱ ✇❤❡♥ ❛♣♣❧✐❡❞ t♦ ✸✱ ②✐❡❧❞s t❤❡ r❡s✉❧t ✼✳ ❚❤❡ ❡①❛♠♣❧❡ ♦♥ t❤❡ s❧✐❞❡ ✐s s✐♠✐❧❛r ❜✉t r❡❢❡rs t♦ t❤❡ ❡①♣r❡ss✐♦♥ ❛❫❜✱ ✇❤❡r❡ ❫ ✐s t❤❡ ✐♥✜① ♦♣❡r❛t♦r ❢♦r str✐♥❣ ❝♦♥❝❛t❡♥❛t✐♦♥✳

❳ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✵✵

Slide 1004

Using a Curried Function

Let’s give one of these functions the name promote.

val promote = prefix "Professor "; > val promote = fn: string -> string promote "Mop"; > "Professor Mop" : string

Or we can apply prefix to two arguments at once:

(prefix "Doctor ") "Who"; > val "Doctor Who" : string

❋✉♥❝t✐♦♥ ♣r♦♠♦t❡ ❜✐♥❞s t❤❡ ✜rst ❛r❣✉♠❡♥t ♦❢ ♣r❡❢✐① t♦ t❤❡ str✐♥❣ ✧Pr♦❢❡ss♦r ✧❀ t❤❡ r❡s✉❧t✐♥❣ ❢✉♥❝t✐♦♥ ♣r❡✜①❡s t❤❛t t✐t❧❡ t♦ ❛♥② str✐♥❣ t♦ ✇❤✐❝❤ ✐t ✐s ❛♣♣❧✐❡❞✳ ◆♦t❡✿ ❚❤❡ ♣❛r❡♥t❤❡s❡s ♠❛② ❜❡ ♦♠✐tt❡❞ ✐♥ ✭❢♥ ❛ ❂❃ ✭❢♥ ❜ ❂❃ E✮✮✳ ❚❤❡② ♠❛② ❛❧s♦ ❜❡ ♦♠✐tt❡❞ ✐♥ ✭♣r❡❢✐① ✧❉♦❝t♦r ✧✮ ✧❲❤♦✧✳

❳ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✵✶

Slide 1005

Shorthand for Curried Functions

A function-returning function is just a function of two arguments. This syntax is nicer than nested fn binders:

fun prefix a b = a^b; > val prefix = ...

as before

val dub = prefix "Sir "; > val dub = fn: string -> string

Curried functions allows partial application (to the first argument).

❚❤❡ n✲❛r❣✉♠❡♥t ❝✉rr✐❡❞ ❢✉♥❝t✐♦♥ ❢ ✐s ❝♦♥✈❡♥✐❡♥t❧② ❞❡❝❧❛r❡❞ ✉s✐♥❣ t❤❡ s②♥t❛① ❢✉♥ ❢ ①1 ✳✳✳①n ❂ ✳✳✳ ❛♥❞ ❛♣♣❧✐❡❞ ✉s✐♥❣ t❤❡ s②♥t❛① ❢ ❊1 ✳✳✳❊n✳ ❲❡ ♥♦✇ ❤❛✈❡ t✇♦ ✇❛②s✖♣❛✐rs ❛♥❞ ❝✉rr②✐♥❣✖♦❢ ❡①♣r❡ss✐♥❣ ❢✉♥❝t✐♦♥s ♦❢ ♠✉❧t✐♣❧❡ ❛r❣✉♠❡♥ts✳ ❈✉rr②✐♥❣ ❛❧❧♦✇s ♣❛rt✐❛❧ ❛♣♣❧✐❝❛t✐♦♥✱ ✇❤✐❝❤ ✐s ✉s❡❢✉❧ ✇❤❡♥ ✜①✐♥❣ t❤❡ ✜rst ❛r❣✉♠❡♥t ②✐❡❧❞s ❛ ❢✉♥❝t✐♦♥ t❤❛t ✐s ✐♥t❡r❡st✐♥❣ ✐♥ ✐ts ♦✇♥ r✐❣❤t✳ ❆♥ ❡①❛♠♣❧❡ ❢r♦♠ ♠❛t❤❡♠❛t✐❝s ✐s t❤❡ ❞❡✜♥✐t❡ ✐♥t❡❣r❛❧ y

x f(z) dz✱

✇❤❡r❡ ✜①✐♥❣ x = x0 ②✐❡❧❞s ❛ ❢✉♥❝t✐♦♥ ✐♥ y ❛❧♦♥❡✳ ❚❤♦✉❣❤ t❤❡ ❢✉♥❝t✐♦♥ ❤❞ ✭✇❤✐❝❤ r❡t✉r♥s t❤❡ ❤❡❛❞ ♦❢ ❛ ❧✐st✮ ✐s ♥♦t ❝✉rr✐❡❞✱ ✐t ♠❛② ❜❡ ✉s❡❞ ✇✐t❤ t❤❡ ❝✉rr✐❡❞ ❛♣♣❧✐❝❛t✐♦♥ s②♥t❛① ✐♥ s♦♠❡ ❡①♣r❡ss✐♦♥s✿

❤❞ ❬❞✉❜✱ ♣r♦♠♦t❡❪ ✧❍❛♠✐❧t♦♥✧❀ ❃ ✈❛❧ ✧❙✐r ❍❛♠✐❧t♦♥✧ ✿ str✐♥❣

❍❡r❡ ❤❞ ✐s ❛♣♣❧✐❡❞ t♦ ❛ ❧✐st ♦❢ ❢✉♥❝t✐♦♥s✱ ❛♥❞ t❤❡ r❡s✉❧t✐♥❣ ❢✉♥❝t✐♦♥ ✭❞✉❜✮ ✐s t❤❡♥ ❛♣♣❧✐❡❞ t♦ t❤❡ str✐♥❣ ✧❍❛♠✐❧t♦♥✧✳ ❚❤❡ ✐❞❡❛ ♦❢ ❡①❡❝✉t✐♥❣ ❝♦❞❡ st♦r❡❞ ✐♥ ❞❛t❛ str✉❝t✉r❡s r❡❛❝❤❡s ✐ts ❢✉❧❧ ❞❡✈❡❧♦♣♠❡♥t ✐♥ ♦❜❥❡❝t✲♦r✐❡♥t❡❞ ♣r♦❣r❛♠♠✐♥❣✱ ❛s ❢♦✉♥❞ ✐♥ ❧❛♥❣✉❛❣❡s ❧✐❦❡ ❏❛✈❛ ❛♥❞ ❈✰✰✳

❳ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✵✷

Slide 1006

Partial Application: A Curried Insertion Sort

fun insort lessequal = let fun ins (x, []) = [x] | ins (x, y::ys) = if lessequal(x,y) then x::y::ys else y :: ins (x,ys) fun sort [] = [] | sort (x::xs) = ins (x, sort xs) in sort end; > val insort = fn : (’a * ’a -> bool) >

• > (’a list -> ’a list)

❚❤❡ s♦rt✐♥❣ ❢✉♥❝t✐♦♥s ♦❢ ▲❡❝t✳ ✻ ❛r❡ ❝♦❞❡❞ t♦ s♦rt r❡❛❧ ♥✉♠❜❡rs✳ ❚❤❡② ❝❛♥ ❜❡ ❣❡♥❡r❛❧✐③❡❞ t♦ ❛♥ ❛r❜✐tr❛r② ♦r❞❡r❡❞ t②♣❡ ❜② ♣❛ss✐♥❣ t❤❡ ♦r❞❡r✐♥❣ ♣r❡❞✐❝❛t❡ ✭≤✮ ❛s ❛♥ ❛r❣✉♠❡♥t✳ ❋✉♥❝t✐♦♥s ✐♥s ❛♥❞ s♦rt ❛r❡ ❞❡❝❧❛r❡❞ ❧♦❝❛❧❧②✱ r❡❢❡rr✐♥❣ t♦ ❧❡ss❡q✉❛❧✳ ❚❤♦✉❣❤ ✐t ♠❛② ♥♦t ❜❡ ♦❜✈✐♦✉s✱ ✐♥s♦rt ✐s ❛ ❝✉rr✐❡❞ ❢✉♥❝t✐♦♥✳ ●✐✈❡♥ ✐ts ✜rst ❛r❣✉♠❡♥t✱ ❛ ♣r❡❞✐❝❛t❡ ❢♦r ❝♦♠♣❛r✐♥❣ s♦♠❡ ♣❛rt✐❝✉❧❛r t②♣❡ ♦❢ ✐t❡♠s✱ ✐t r❡t✉r♥s t❤❡ ❢✉♥❝t✐♦♥ s♦rt ❢♦r s♦rt✐♥❣ ❧✐sts ♦❢ t❤❛t t②♣❡ ♦❢ ✐t❡♠s✳

❳ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✵✸

Slide 1007

Examples of Generic Sorting

insort (op<=) [5,3,9,8]; > val it = [3, 5, 8, 9] : int list insort (op<=) ["bitten","on","a","bee"]; > val it = ["a", "bee", "bitten", "on"] > : string list insort (op>=) [5,3,9,8]; > val it = [9, 8, 5, 3] : int list

◆♦t❡✿ ♦♣❁❂ st❛♥❞s ❢♦r t❤❡ ❁❂ ♦♣❡r❛t♦r r❡❣❛r❞❡❞ ❛s ❛ ✈❛❧✉❡✳ ❆❧t❤♦✉❣❤ ✐♥✜①❡s ❛r❡ ❢✉♥❝t✐♦♥s✱ ♥♦r♠❛❧❧② t❤❡② ❝❛♥ ♦♥❧② ❛♣♣❡❛r ✐♥ ❡①♣r❡ss✐♦♥s s✉❝❤ ❛s ♥❁❂✾✳ ❚❤❡ ♦♣ s②♥t❛① ❧❡ts ✉s ✇r✐t❡ ♦♣❁❂✭♥✱✾✮✱ ❜✉t ♦♥ t❤❡ s❧✐❞❡ ✇❡ ✉s❡ ♦♣❁❂ t♦ ♣❛ss t❤❡ ❝♦♠♣❛r✐s♦♥ ♦♣❡r❛t♦r t♦ ❢✉♥❝t✐♦♥ ✐♥s♦rt✳ ❚♦ ❡①♣❧♦✐t s♦rt✐♥❣ t♦ ✐ts ❢✉❧❧ ❡①t❡♥t✱ ✇❡ ♥❡❡❞ t❤❡ ❣r❡❛t❡st ✢❡①✐❜✐❧✐t② ✐♥ ❡①♣r❡ss✐♥❣ ♦r❞❡r✐♥❣s✳ ❚❤❡r❡ ❛r❡ ♠❛♥② t②♣❡s ♦❢ ❜❛s✐❝ ❞❛t❛✱ s✉❝❤ ❛s ✐♥t❡❣❡rs✱ r❡❛❧s ❛♥❞ str✐♥❣s✳ ❖♥ t❤❡ ♦✈❡r❤❡❛❞✱ ✇❡ s♦rt ✐♥t❡❣❡rs ❛♥❞ str✐♥❣s✳ ❚❤❡ ♦♣✲ ❡r❛t♦r ❁❂ ✐s ♦✈❡r❧♦❛❞❡❞✱ ✇♦r❦✐♥❣ ❢♦r t②♣❡s ✐♥t✱ r❡❛❧ ❛♥❞ str✐♥❣✳ ❚❤❡ ❧✐st s✉♣♣❧✐❡❞ ❛s ✐♥s♦rt✬s s❡❝♦♥❞ ❛r❣✉♠❡♥t r❡s♦❧✈❡s t❤❡ ♦✈❡r❧♦❛❞✐♥❣ ❛♠❜✐❣✉✐t②✳ P❛ss✐♥❣ t❤❡ r❡❧❛t✐♦♥ ≥ ❢♦r ❧❡ss❡q✉❛❧ ❣✐✈❡s ❛ ❞❡❝r❡❛s✐♥❣ s♦rt✳ ❚❤✐s ✐s ♥♦ ❝♦❞✐♥❣ tr✐❝❦❀ ✐t ✐s ❥✉st✐✜❡❞ ✐♥ ♠❛t❤❡♠❛t✐❝s✳ ■❢ ≤ ✐s ❛ ♣❛rt✐❛❧ ♦r❞❡r✐♥❣ t❤❡♥ s♦ ✐s ≥✳ ❚❤❡r❡ ❛r❡ ♠❛♥② ✇❛②s ♦❢ ❝♦♠❜✐♥✐♥❣ ♦r❞❡r✐♥❣s✳ ▼♦st ✐♠♣♦rt❛♥t ✐s t❤❡ ❧❡①✐❝♦❣r❛♣❤✐❝ ♦r❞❡r✐♥❣✱ ✐♥ ✇❤✐❝❤ t✇♦ ❦❡②s ❛r❡ ✉s❡❞ ❢♦r ❝♦♠♣❛r✐s♦♥s✳ ■t ✐s s♣❡❝✐✜❡❞ ❜② (x′, y′) < (x, y) ⇐ ⇒ x′ < x ∨ (x′ = x ∧ y′ < y)✳ ❖❢t❡♥ ♣❛rt ♦❢ t❤❡ ❞❛t❛ ♣❧❛②s ♥♦ r♦❧❡ ✐♥ t❤❡ ♦r❞❡r✐♥❣❀ ❝♦♥s✐❞❡r t❤❡ t❡①t ♦❢ t❤❡ ❡♥tr✐❡s ✐♥ ❛♥ ❡♥❝②❝❧♦♣❡❞✐❛✳ ▼❛t❤❡♠❛t✐❝❛❧❧②✱ ✇❡ ❤❛✈❡ ❛♥ ♦r❞❡r✐♥❣ ♦♥ ♣❛✐rs s✉❝❤ t❤❛t (x′, y′) < (x, y) ⇐ ⇒ x′ < x✳ ❚❤❡s❡ ✇❛②s ♦❢ ❝♦♠❜✐♥✐♥❣ ♦r❞❡r✐♥❣s ❝❛♥ ❜❡ ❡①♣r❡ss❡❞ ✐♥ ▼▲ ❛s ❢✉♥❝t✐♦♥s t❤❛t t❛❦❡ ♦r❞❡r✐♥❣s ❛s ❛r❣✉♠❡♥ts ❛♥❞ r❡t✉r♥ ♦t❤❡r ♦r❞❡r✐♥❣s ❛s r❡s✉❧ts✳

❳ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✵✹

Slide 1008

A Summation Functional

Sums the values of f(i) for 1 ≤ i ≤ m.

fun sum f 0 = 0.0 | sum f m = f(m) + sum f (m-1); > val sum = fn: (int -> real) -> (int -> real) sum (fn k => real (k*k)) 5; > val it = 55.0 : real sum f m =

m

• i=1

f(i) ❆❜♦✈❡ ✇❡ s❡❡ t❤❛t 1 + 4 + 9 + 16 + 25 = 55✳ ◆✉♠❡r✐❝❛❧ ♣r♦❣r❛♠♠✐♥❣ ❧❛♥❣✉❛❣❡s✱ s✉❝❤ ❛s ❋♦rtr❛♥✱ ❛❧❧♦✇ ❢✉♥❝t✐♦♥s t♦ ❜❡ ♣❛ss❡❞ ❛s ❛r❣✉♠❡♥ts ✐♥ t❤✐s ♠❛♥♥❡r✳ ❈❧❛ss✐❝❛❧ ❛♣♣❧✐❝❛t✐♦♥s ✐♥❝❧✉❞❡ ♥✉♠❡r✐❝❛❧ ✐♥t❡❣r❛t✐♦♥ ❛♥❞ r♦♦t✲✜♥❞✐♥❣✳ ❚❤❛♥❦s t♦ ❝✉rr②✐♥❣✱ ▼▲ s✉r♣❛ss❡s ❋♦rtr❛♥✳ ◆♦t ♦♥❧② ❝❛♥ ❢ ❜❡ ♣❛ss❡❞ ❛s ❛♥ ❛r❣✉♠❡♥t t♦ s✉♠✱ ❜✉t t❤❡ r❡s✉❧t ♦❢ ❞♦✐♥❣ s♦ ❝❛♥ ✐ts❡❧❢ ❜❡ r❡t✉r♥❡❞ ❛s ❛♥♦t❤❡r ❢✉♥❝t✐♦♥✳ ●✐✈❡♥ ❛♥ ✐♥t❡❣❡r ❛r❣✉♠❡♥t✱ t❤❛t ❢✉♥❝t✐♦♥ r❡t✉r♥s t❤❡ r❡s✉❧t ♦❢ s✉♠♠✐♥❣ ✈❛❧✉❡s ♦❢ ❢ ✉♣ t♦ t❤❡ s♣❡❝✐✜❡❞ ❜♦✉♥❞✳

❳ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✵✺

Slide 1009

Nesting the Summation Functional

sum (fn i=> sum (fn j=>h(i,j)) n =

m

X

i=1 n

X

j=1

h(i, j) ) m sum (sum f) m =

m

• i=1

i

• j=1

f(j) ❚❤❡s❡ ❡①❛♠♣❧❡s ❞❡♠♦♥str❛t❡ ❤♦✇ ❢♥✲♥♦t❛t✐♦♥ ❡①♣r❡ss❡s ❞❡♣❡♥❞❡♥❝❡ ♦♥ ❜♦✉♥❞ ✈❛r✐❛❜❧❡s✱ ❥✉st ❛s ✐♥ ♦r❞✐♥❛r② ♠❛t❤❡♠❛t✐❝s✳ ❚❤❡ ❢✉♥❝t✐♦♥❛❧ s✉♠ ❝❛♥ ❜❡ r❡♣❡❛t❡❞ ❧✐❦❡ t❤❡ tr❛❞✐t✐♦♥❛❧ Σ s✐❣♥✳ ▲❡t ✉s ❡①❛♠✐♥❡ t❤❡ ✜rst ❡①❛♠♣❧❡ ✐♥ ❞❡t❛✐❧✿

• ❤✭✐✱❥✮ ❞❡♣❡♥❞s ✉♣♦♥ t❤❡ ✈❛r✐❛❜❧❡s ✐ ❛♥❞ ❥
• ❢♥ ❥❂❃❤✭✐✱❥✮ ❞❡♣❡♥❞s ✉♣♦♥ ✐ ❛❧♦♥❡✱ ②✐❡❧❞✐♥❣ ❛ ❢✉♥❝t✐♦♥ ♦✈❡r ❥
• s✉♠ ✭❢♥ ❥❂❃❤✭✐✱❥✮✮ ♥ ❞❡♣❡♥❞s ✉♣♦♥ ✐ ❛♥❞ ♥✱ s✉♠♠✐♥❣ t❤❡ ❢✉♥❝t✐♦♥

♦✈❡r ❥ ♠❡♥t✐♦♥❡❞ ❛❜♦✈❡

• ❢♥ ✐ ❂❃ s✉♠ · · · ♥ ❞❡♣❡♥❞s ✉♣♦♥ ♥ ❛❧♦♥❡✱ ②✐❡❧❞✐♥❣ ❛ ❢✉♥❝t✐♦♥ ♦✈❡r ✐

❚❤❡ ❡①♣r❡ss✐♦♥ ❛s ❛ ✇❤♦❧❡ ❞❡♣❡♥❞s ✉♣♦♥ t❤❡ t❤r❡❡ ✈❛r✐❛❜❧❡s ❢✱ ♠ ❛♥❞ ♥✳ ❋✉♥❝t✐♦♥❛❧s✱ ❝✉rr②✐♥❣ ❛♥❞ ❢♥✲♥♦t❛t✐♦♥ ②✐❡❧❞ ❛ ❧❛♥❣✉❛❣❡ ❢♦r ❡①♣r❡ss✐♦♥s t❤❛t ✐s ❣r♦✉♥❞❡❞ ✐♥ ♠❛t❤❡♠❛t✐❝s✱ ❝♦♥❝✐s❡ ❛♥❞ ♣♦✇❡r❢✉❧✳

❳ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✵✻

Slide 1010

Historical Remarks

Frege (1893): if functions are values, we need unary functions only Schöfinkel (1924): with the right combinators, we don’t need variables! Church (1936): the λ-calculus & unsolvable problems Landin (1964-6): ISWIM: a language based on the λ-calculus Turner (1979): combinators as an implementation technique

❚❤❡ ✐❞❡❛ t❤❛t ❢✉♥❝t✐♦♥s ❝♦✉❧❞ ❜❡ r❡❣❛r❞❡❞ ❛s ✈❛❧✉❡s ✐♥ t❤❡♠s❡❧✈❡s ❣❛✐♥❡❞ ❛❝❝❡♣t❛♥❝❡ ✐♥ t❤❡ ✶✾t❤ ❝❡♥t✉r②✳ ❋r❡❣❡✬s ♠❛♠♠♦t❤ ✭❜✉t ✉❧t✐♠❛t❡❧② ❞♦♦♠❡❞✮ ❧♦❣✐❝❛❧ s②st❡♠ ✇❛s ❜❛s❡❞ ✉♣♦♥ t❤✐s ♥♦t✐♦♥✳ ❋r❡❣❡ ❞✐s❝♦✈❡r❡❞ ✇❤❛t ✇❡ ♥♦✇ ❝❛❧❧ ❈✉rr②✐♥❣✿ t❤❛t ❤❛✈✐♥❣ ❢✉♥❝t✐♦♥s ❛s ✈❛❧✉❡s ♠❡❛♥t t❤❛t ❢✉♥❝t✐♦♥s ♦❢ s❡✈❡r❛❧ ❛r❣✉♠❡♥ts ❝♦✉❧❞ ❜❡ ❢♦r♠❛❧✐③❡❞ ✉s✐♥❣ s✐♥❣❧❡✲❛r❣✉♠❡♥t ❢✉♥❝t✐♦♥s ♦♥❧②✳ ❆♥♦t❤❡r ❧♦❣✐❝✐❛♥✱ ❙❝❤ö♥✜♥❦❡❧✱ r❡❞✐s❝♦✈❡r❡❞ t❤✐s ❢❛❝t ❛♥❞ ❞❡✈❡❧♦♣❡❞ ❝♦♠✲ ❜✐♥❛t♦rs ❛s ❛ ♠❡❛♥s ♦❢ ❡❧✐♠✐♥❛t✐♥❣ ✈❛r✐❛❜❧❡s ❢r♦♠ ❡①♣r❡ss✐♦♥s✳ ●✐✈❡♥ K ❛♥❞ S s✉❝❤ t❤❛t Kxy = x ❛♥❞ Sxyz = xz(yz)✱ ❛♥② ❢✉♥❝t✐♦♥❛❧ ❡①♣r❡ss✐♦♥ ❝♦✉❧❞ ❜❡ ✇r✐tt❡♥ ✇✐t❤♦✉t ✉s✐♥❣ ❜♦✉♥❞ ✈❛r✐❛❜❧❡s✳ ❈✉rr②✐♥❣ ✐s ♥❛♠❡❞ ❛❢t❡r ❍❛s❦❡❧❧ ❇✳ ❈✉rr②✱ ✇❤♦ ♠❛❞❡ ❞❡❡♣ ✐♥✈❡st✐❣❛t✐♦♥s ✐♥t♦ t❤❡ t❤❡♦r② ♦❢ ❝♦♠❜✐♥❛t♦rs✳ ❆❧♦♥③♦ ❈❤✉r❝❤✬s λ✲❝❛❧❝✉❧✉s ❣❛✈❡ ❛ s✐♠♣❧❡ s②♥t❛①✱ λ✲♥♦t❛t✐♦♥✱ ❢♦r ❡①♣r❡ss✲ ✐♥❣ ❢✉♥❝t✐♦♥s✳ ■t ✐s t❤❡ ❞✐r❡❝t ♣r❡❝✉rs♦r ♦❢ ▼▲✬s ❢♥✲♥♦t❛t✐♦♥✳ ■t ✇❛s s♦♦♥ s❤♦✇♥ t❤❛t ❤✐s s②st❡♠ ✇❛s ❡q✉✐✈❛❧❡♥t ✐♥ ❝♦♠♣✉t❛t✐♦♥❛❧ ♣♦✇❡r t♦ ❚✉r✐♥❣ ♠❛❝❤✐♥❡s✱ ❛♥❞ ❈❤✉r❝❤✬s t❤❡s✐s st❛t❡s t❤❛t t❤✐s ❞❡✜♥❡s ♣r❡❝✐s❡❧② t❤❡ s❡t ♦❢ ❢✉♥❝t✐♦♥s t❤❛t ❝❛♥ ❜❡ ❝♦♠♣✉t❡❞ ❡✛❡❝t✐✈❡❧②✳ ❚❤❡ λ✲❝❛❧❝✉❧✉s ❤❛❞ ❛ tr❡♠❡♥❞♦✉s ✐♥✢✉❡♥❝❡ ♦♥ t❤❡ ❞❡s✐❣♥ ♦❢ ❢✉♥❝t✐♦♥❛❧ ♣r♦❣r❛♠♠✐♥❣ ❧❛♥❣✉❛❣❡s✳ ▼❝❈❛rt❤②✬s ▲✐s♣ ✇❛s s♦♠❡t❤✐♥❣ ♦❢ ❛ ❢❛❧s❡ st❛rt❀ ✐t ✐♥t❡r♣r❡t❡❞ ✈❛r✐❛❜❧❡ ❜✐♥❞✐♥❣ ✐♥❝♦rr❡❝t❧②✱ ❛♥ ❡rr♦r t❤❛t st♦♦❞ ❢♦r s♦♠❡ ✷✵ ②❡❛rs✳ ❍♦✇❡✈❡r✱ ▲❛♥❞✐♥ s❦❡t❝❤❡❞ ♦✉t t❤❡ ♠❛✐♥ ❢❡❛t✉r❡s ♦❢ ❢✉♥❝t✐♦♥❛❧ ❧❛♥❣✉❛❣❡s✳ ❚✉r♥❡r ♠❛❞❡ t❤❡ r❡♠❛r❦❛❜❧❡ ❞✐s❝♦✈❡r② t❤❛t ❝♦♠❜✐♥❛t♦rs ✭❤✐t❤❡rt♦ t❤♦✉❣❤t t♦ ❜❡ ♦❢ t❤❡♦r❡t✐❝❛❧ ✈❛❧✉❡ ♦♥❧②✮ ❝♦✉❧❞ ❛♥ ❡✛❡❝t✐✈❡ ♠❡❛♥s ♦❢ ✐♠♣❧❡♠❡♥t✐♥❣ ❢✉♥❝t✐♦♥❛❧ ❧❛♥❣✉❛❣❡s t❤❛t ❡♠♣❧♦②❡❞ ❧❛③② ❡✈❛❧✉❛t✐♦♥✳

❳ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✵✼ ▲❡❛r♥✐♥❣ ❣✉✐❞❡✳ ❘❡❧❛t❡❞ ♠❛t❡r✐❛❧ ✐s ✐♥ ▼▲ ❢♦r t❤❡ ❲♦r❦✐♥❣ Pr♦❣r❛♠♠❡r✱ ♣❛❣❡s ✶✼✶✕✶✼✾✳ ❈❤❛♣t❡r ✾ ❝♦♥t❛✐♥s ❛♥ ✐♥tr♦❞✉❝t✐♦♥ t♦ t❤❡ λ✲❝❛❧❝✉❧✉s✱ ✇❤❝❤ ✇✐❧❧ ❜❡ ❝♦✈❡r❡❞ ✐♥ t❤❡ s❡❝♦♥❞✲②❡❛r ❝♦✉rs❡ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❋✉♥❝t✐♦♥❛❧ Pr♦✲ ❣r❛♠♠✐♥❣✳ ❊①❡r❝✐s❡ ✶✵✳✶ ❲r✐t❡ ❛♥ ▼▲ ❢✉♥❝t✐♦♥ t♦ ❝♦♠❜✐♥❡ t✇♦ ♦r❞❡r✐♥❣s ❧❡①✐❝♦✲ ❣r❛♣❤✐❝❛❧❧②✳ ❊①♣❧❛✐♥ ❤♦✇ ✐t ❛❧❧♦✇s ❢✉♥❝t✐♦♥ ✐♥s♦rt t♦ s♦rt ❛ ❧✐st ♦❢ ♣❛✐rs✱ ✉s✐♥❣ ❜♦t❤ ❝♦♠♣♦♥❡♥ts ✐♥ t❤❡ ❝♦♠♣❛r✐s♦♥s✳ ❊①❡r❝✐s❡ ✶✵✳✷ ❈♦❞❡ ❛♥ ✐t❡r❛t✐✈❡ ✈❡rs✐♦♥ ♦❢ s✉♠✱ ❛ ❝✉rr✐❡❞ ❢✉♥❝t✐♦♥ ♦❢ t❤r❡❡ ❛r❣✉♠❡♥ts✳ ❉♦❡s ✐t ♠❛tt❡r ✇❤❡t❤❡r t❤❡ ❛❝❝✉♠✉❧❛t♦r ✐s t❤❡ ✜rst✱ s❡❝♦♥❞ ♦r t❤✐r❞ ❛r❣✉♠❡♥t❄ ❊①❡r❝✐s❡ ✶✵✳✸ ❊①♣❧❛✐♥ t❤❡ s❡❝♦♥❞ ❡①❛♠♣❧❡ ♦❢ s✉♠ ♦♥ t❤❡ ♦✈❡r❤❡❛❞✳ ❲❤❛t ✐s ✭s✉♠ ❢✮❄

❳■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✵✽

Slide 1101

map: the ‘Apply to All’ Functional

fun map f [] = [] | map f (x::xs) = (f x) :: map f xs > val map = fn: (’a -> ’b) -> ’a list -> ’b list map (fn s => s ^ "ppy") ["Hi", "Ho"]; > val it = ["Hippy", "Hoppy"] : string list map (map double) [[1], [2,3]]; > val it = [[2], [4, 6]] : int list list

❚❤❡ ❢✉♥❝t✐♦♥❛❧ ♠❛♣ ❛♣♣❧✐❡s ❛ ❢✉♥❝t✐♦♥ t♦ ❡✈❡r② ❡❧❡♠❡♥t ♦❢ ❛ ❧✐st✱ r❡t✉r♥✐♥❣ ❛ ❧✐st ♦❢ t❤❡ ❢✉♥❝t✐♦♥✬s r❡s✉❧ts✳ ✏❆♣♣❧② t♦ ❛❧❧✑ ✐s ❛ ❢✉♥❞❛♠❡♥t❛❧ ♦♣❡r❛t✐♦♥ ❛♥❞ ✇❡ s❤❛❧❧ s❡❡ s❡✈❡r❛❧ ❛♣♣❧✐❝❛t✐♦♥s ♦❢ ✐t ✐♥ t❤✐s ❧❡❝t✉r❡✳ ❲❡ ❛❣❛✐♥ s❡❡ t❤❡ ❛❞✈❛♥t❛❣❡s ♦❢ ❢♥✲♥♦t❛t✐♦♥✱ ❝✉rr②✐♥❣ ❛♥❞ ♠❛♣✳ ■❢ ✇❡ ❞✐❞ ♥♦t ❤❛✈❡ t❤❡♠✱ t❤❡ ✜rst ❡①❛♠♣❧❡ ♦♥ t❤❡ s❧✐❞❡ ✇♦✉❧❞ r❡q✉✐r❡ ❛ ♣r❡❧✐♠✐♥❛r② ❢✉♥❝t✐♦♥ ❞❡❝❧❛r❛t✐♦♥✿

❢✉♥ s✐❧❧②❧✐st ❬❪ ❂ ❬❪ ⑤ s✐❧❧②❧✐st ✭s✿✿ss✮ ❂ ✭s ❫ ✧♣♣②✧✮ ✿✿ s✐❧❧②❧✐st ss❀

❆♥ ❡①♣r❡ss✐♦♥ ❝♦♥t❛✐♥✐♥❣ s❡✈❡r❛❧ ❛♣♣❧✐❝❛t✐♦♥s ♦❢ ❢✉♥❝t✐♦♥❛❧s✖s✉❝❤ ❛s ♦✉r s❡❝♦♥❞ ❡①❛♠♣❧❡✖❝❛♥ ❛❜❜r❡✈✐❛t❡ ❛ ❧♦♥❣ s❡r✐❡s ♦❢ ❞❡❝❧❛r❛t✐♦♥s✳ ❙♦♠❡t✐♠❡s t❤✐s ❝♦❞✐♥❣ st②❧❡ ✐s ❝r②♣t✐❝✱ ❜✉t ✐t ❝❛♥ ❜❡ ❝❧❡❛r ❛s ❝r②st❛❧✳ ❚r❡❛t✐♥❣ ❢✉♥❝t✐♦♥s ❛s ✈❛❧✉❡s ❧❡ts ✉s ❝❛♣t✉r❡ ❝♦♠♠♦♥ ♣r♦❣r❛♠ str✉❝t✉r❡s ♦♥❝❡ ❛♥❞ ❢♦r ❛❧❧✳ ■♥ t❤❡ s❡❝♦♥❞ ❡①❛♠♣❧❡✱ ❞♦✉❜❧❡ ✐s t❤❡ ♦❜✈✐♦✉s ✐♥t❡❣❡r ❞♦✉❜❧✐♥❣ ❢✉♥❝t✐♦♥✿

❢✉♥ ❞♦✉❜❧❡ ♥ ❂ ♥✯✷❀

◆♦t❡ t❤❛t ♠❛♣ ✐s ❛ ❜✉✐❧t✲✐♥ ▼▲ ❢✉♥❝t✐♦♥✳ ❙t❛♥❞❛r❞ ▼▲✬s ❧✐❜r❛r② ✐♥❝❧✉❞❡s✱ ❛♠♦♥❣ ♠✉❝❤ ❡❧s❡✱ ♠❛♥② ❧✐st ❢✉♥❝t✐♦♥s✳

❳■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✵✾

Slide 1102

Example: Matrix Transpose  a b c d e f  

T

=     a d b e c f    

fun hd (x::_) = x; fun tl (_::xs) = xs; fun transp ([]::_) = [] | transp rows = (map hd rows) :: (transp (map tl rows))

❆ ♠❛tr✐① ❝❛♥ ❜❡ ✈✐❡✇❡❞ ❛s ❛ ❧✐st ♦❢ r♦✇s✱ ❡❛❝❤ r♦✇ ❛ ❧✐st ♦❢ ♠❛tr✐① ❡❧❡♠❡♥ts✳ ❚❤✐s r❡♣r❡s❡♥t❛t✐♦♥ ✐s ♥♦t ❡s♣❡❝✐❛❧❧② ❡✣❝✐❡♥t ❝♦♠♣❛r❡❞ ✇✐t❤ t❤❡ ❝♦♥✈❡♥t✐♦♥❛❧ ♦♥❡ ✭✉s✐♥❣ ❛rr❛②s✮✳ ▲✐sts ♦❢ ❧✐sts t✉r♥ ✉♣ ♦❢t❡♥✱ t❤♦✉❣❤✱ ❛♥❞ ✇❡ ❝❛♥ s❡❡ ❤♦✇ t♦ ❞❡❛❧ ✇✐t❤ t❤❡♠ ❜② t❛❦✐♥❣ ❢❛♠✐❧✐❛r ♠❛tr✐① ♦♣❡r❛t✐♦♥s ❛s ❡①❛♠♣❧❡s✳ ▼▲ ❢♦r t❤❡ ❲♦r❦✐♥❣ Pr♦❣r❛♠♠❡r ❣♦❡s ❛s ❢❛r ❛s ●❛✉ss✐❛♥ ❡❧✐♠✐♥❛t✐♦♥✱ ✇❤✐❝❤ ♣r❡s❡♥ts s✉r♣r✐s✐♥❣❧② ❢❡✇ ❞✐✣❝✉❧t✐❡s✳ ❚❤❡ tr❛♥s♣♦s❡ ♦❢ t❤❡ ♠❛tr✐① a b c

d e f

• ✐s

a d

b e c f

• ✱ ✇❤✐❝❤ ✐♥ ▼▲ ❝♦rr❡s♣♦♥❞s

t♦ t❤❡ ❢♦❧❧♦✇✐♥❣ tr❛♥s❢♦r♠❛t✐♦♥ ♦♥ ❧✐sts ♦❢ ❧✐sts✿

❬❬❛✱❜✱❝❪✱ ❬❞✱❡✱❢❪❪ → ❬❬❛✱❞❪✱ ❬❜✱❡❪✱ ❬❝✱❢❪❪

❚❤❡ ✇♦r❦✐♥❣s ♦❢ ❢✉♥❝t✐♦♥ tr❛♥s♣ ❛r❡ s✐♠♣❧❡✳ ■❢ r♦✇s ✐s t❤❡ ♠❛tr✐① t♦ ❜❡ tr❛♥s♣♦s❡❞✱ t❤❡♥ ♠❛♣ ❤❞ ❡①tr❛❝ts ✐ts ✜rst ❝♦❧✉♠♥ ❛♥❞ ♠❛♣ t❧ ❡①tr❛❝ts ✐ts s❡❝♦♥❞ ❝♦❧✉♠♥✿

♠❛♣ ❤❞ r♦✇s → ❬❛✱❞❪ ♠❛♣ t❧ r♦✇s → ❬❬❜✱❝❪✱ ❬❡✱❢❪❪

❆ r❡❝✉rs✐✈❡ ❝❛❧❧ tr❛♥s♣♦s❡s t❤❡ ❧❛tt❡r ♠❛tr✐①✱ ✇❤✐❝❤ ✐s t❤❡♥ ❣✐✈❡♥ t❤❡ ❝♦❧✉♠♥ ❬❛✱❞❪ ❛s ✐ts ✜rst r♦✇✳ ❚❤❡ t✇♦ ❢✉♥❝t✐♦♥s ❡①♣r❡ss❡❞ ✉s✐♥❣ ♠❛♣ ✇♦✉❧❞ ♦t❤❡r✇✐s❡ ❤❛✈❡ t♦ ❜❡ ❞❡✲ ❝❧❛r❡❞ s❡♣❛r❛t❡❧②✳

❳■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✶✵

Slide 1103

Review of Matrix Multiplication

• A1

· · · Ak

• ·

     B1

. . .

Bk      =

• A1B1 + · · · + AkBk
• The right side is the vector dot product

A · B

Repeat for each row of A and column of B

❚❤❡ ❞♦t ♣r♦❞✉❝t ♦❢ t✇♦ ✈❡❝t♦rs ✐s (a1, . . . , ak) · (b1, . . . , bk) = a1b1 + · · · + akbk. ❆ s✐♠♣❧❡ ❝❛s❡ ♦❢ ♠❛tr✐① ♠✉❧t✐♣❧✐❝❛t✐♦♥ ✐s ✇❤❡♥ A ❝♦♥s✐sts ♦❢ ❛ s✐♥❣❧❡ r♦✇ ❛♥❞ B ❝♦♥s✐sts ♦❢ ❛ s✐♥❣❧❡ ❝♦❧✉♠♥✳ Pr♦✈✐❞❡❞ A ❛♥❞ B ❝♦♥t❛✐♥ t❤❡ s❛♠❡ ♥✉♠❜❡r k ♦❢ ❡❧❡♠❡♥ts✱ ♠✉❧t✐♣❧②✐♥❣ t❤❡♠ ②✐❡❧❞s ❛ 1 × 1 ♠❛tr✐① ✇❤♦s❡ s✐♥❣❧❡ ❡❧❡♠❡♥t ✐s t❤❡ ❞♦t ♣r♦❞✉❝t s❤♦✇♥ ❛❜♦✈❡✳ ■❢ A ✐s ❛♥ m × k ♠❛tr✐① ❛♥❞ B ✐s ❛ k × n ♠❛tr✐① t❤❡♥ A × B ✐s ❛♥ m × n ♠❛tr✐①✳ ❋♦r ❡❛❝❤ i ❛♥❞ j✱ t❤❡ (i, j) ❡❧❡♠❡♥t ♦❢ A × B ✐s t❤❡ ❞♦t ♣r♦❞✉❝t ♦❢ r♦✇ i ♦❢ A ✇✐t❤ ❝♦❧✉♠♥ j ♦❢ B✳     2 3 −1 1 1 1    

• 1

2 4 −1

• =

    2 4 −1 1 6 4 −1 5 −1 2     ❚❤❡ ✭✶✱✶✮ ❡❧❡♠❡♥t ❛❜♦✈❡ ✐s ❝♦♠♣✉t❡❞ ❜② (2, 0) · (1, 4) = 2 × 1 + 0 × 4 = 2. ❈♦❞✐♥❣ ♠❛tr✐① ♠✉❧t✐♣❧✐❝❛t✐♦♥ ✐♥ ❛ ❝♦♥✈❡♥t✐♦♥❛❧ ♣r♦❣r❛♠♠✐♥❣ ❧❛♥❣✉❛❣❡ ✉s✉❛❧❧② ✐♥✈♦❧✈❡s t❤r❡❡ ♥❡st❡❞ ❧♦♦♣s✳ ■t ✐s ❤❛r❞ t♦ ❛✈♦✐❞ ♠✐st❛❦❡s ✐♥ t❤❡ s✉❜✲ s❝r✐♣t✐♥❣✱ ✇❤✐❝❤ ♦❢t❡♥ r✉♥s s❧♦✇❧② ❞✉❡ t♦ r❡❞✉♥❞❛♥t ✐♥t❡r♥❛❧ ❝❛❧❝✉❧❛t✐♦♥s✳

❳■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✶✶

Slide 1104

Matrix Multiplication in ML

Dot product of two vectors—a curried function

fun dotprod [] [] = 0.0 | dotprod(x::xs)(y::ys) = x*y + dotprod xs ys

Matrix product

fun matprod(Arows,Brows) = let val cols = transp Brows in map (fn row => map (dotprod row) cols) Arows end

❚❤❡ tr❛♥s♣ ❇r♦✇s ❝♦♥✈❡rts B ✐♥t♦ ❛ ❧✐st ♦❢ ❝♦❧✉♠♥s✳ ■t ②✐❡❧❞s ❛ ❧✐st✱ ✇❤♦s❡ ❡❧❡♠❡♥ts ❛r❡ t❤❡ ❝♦❧✉♠♥s ♦❢ B✳ ❊❛❝❤ r♦✇ ♦❢ A × B ✐s ♦❜t❛✐♥❡❞ ❜② ♠✉❧t✐♣❧②✐♥❣ ❛ r♦✇ ♦❢ A ❜② t❤❡ ❝♦❧✉♠♥s ♦❢ B✳ ❇❡❝❛✉s❡ ❞♦t♣r♦❞ ✐s ❝✉rr✐❡❞✱ ✐t ❝❛♥ ❜❡ ❛♣♣❧✐❡❞ t♦ ❛ r♦✇ ♦❢ A✳ ❚❤❡ r❡s✉❧t✐♥❣ ❢✉♥❝t✐♦♥ ✐s ❛♣♣❧✐❡❞ t♦ ❛❧❧ t❤❡ ❝♦❧✉♠♥s ♦❢ B✳ ❲❡ ❤❛✈❡ ❛♥♦t❤❡r ❡①❛♠♣❧❡ ♦❢ ❝✉rr②✐♥❣ ❛♥❞ ♣❛rt✐❛❧ ❛♣♣❧✐❝❛t✐♦♥✳ ❚❤❡ ♦✉t❡r ♠❛♣ ❛♣♣❧✐❡s ❞♦t♣r♦❞ t♦ ❡❛❝❤ r♦✇ ♦❢ A✳ ❚❤❡ ✐♥♥❡r ♠❛♣✱ ✉s✐♥❣ ❢♥✲♥♦t❛t✐♦♥✱ ❛♣♣❧✐❡s ❞♦t♣r♦❞ r♦✇ t♦ ❡❛❝❤ ❝♦❧✉♠♥ ♦❢ B✳ ❈♦♠♣❛r❡ ✇✐t❤ t❤❡ ✈❡rs✐♦♥ ✐♥ ▼▲ ❢♦r t❤❡ ❲♦r❦✐♥❣ Pr♦❣r❛♠♠❡r✱ ♣❛❣❡ ✽✾✱ ✇❤✐❝❤ ❞♦❡s ♥♦t ✉s❡ ♠❛♣ ❛♥❞ r❡q✉✐r❡s t✇♦ ❛❞❞✐t✐♦♥❛❧ ❢✉♥❝t✐♦♥ ❞❡❝❧❛r❛t✐♦♥s✳ ■♥ t❤❡ ❞♦t ♣r♦❞✉❝t ❢✉♥❝t✐♦♥✱ t❤❡ t✇♦ ✈❡❝t♦rs ♠✉st ❤❛✈❡ t❤❡ s❛♠❡ ❧❡♥❣t❤✳ ❖t❤❡r✇✐s❡✱ ❡①❝❡♣t✐♦♥ ▼❛t❝❤ ✐s r❛✐s❡❞✳

❳■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✶✷

Slide 1105

The ‘Fold’ Functionals

fun foldl f (e, []) = e | foldl f (e, x::xs) = foldl f (f(e,x), xs) fun foldr f ([], e) = e | foldr f (x::xs, e) = f(x, foldr f (xs,e))

They do recursion down a list:

foldl⊕ : (e, [x1, . . . , xn]) − → (· · · (e ⊕ x1) ⊕ · · · ) ⊕ xn foldr⊕ : ([x1, . . . , xn], e) − → x1 ⊕ (· · · ⊕ (xn ⊕ e) · · · ) ❚❤❡s❡ ❢✉♥❝t✐♦♥❛❧s st❛rt ✇✐t❤ ❛♥ ✐♥✐t✐❛❧ ✈❛❧✉❡ e✳ ❚❤❡② ❝♦♠❜✐♥❡ ✐t ✇✐t❤ t❤❡ ❧✐st ❡❧❡♠❡♥ts ♦♥❡ ❛t ❛ t✐♠❡✱ ✉s✐♥❣ t❤❡ ❢✉♥❝t✐♦♥ ⊕✳ ❲❤✐❧❡ ❢♦❧❞❧ t❛❦❡s t❤❡ ❧✐st ❡❧❡♠❡♥ts ❢r♦♠ ❧❡❢t t♦ r✐❣❤t✱ ❢♦❧❞r t❛❦❡s t❤❡♠ ❢r♦♠ r✐❣❤t t♦ ❧❡❢t✳ ❍❡r❡ ❛r❡ t❤❡✐r t②♣❡s✿

❃ ✈❛❧ ❢♦❧❞❧ ❂ ❢♥✿ ✭✬❛ ✯ ✬❜ ✲❃ ✬❛✮ ✲❃ ✬❛ ✯ ✬❜ ❧✐st ✲❃ ✬❛ ❃ ✈❛❧ ❢♦❧❞r ❂ ❢♥✿ ✭✬❛ ✯ ✬❜ ✲❃ ✬❜✮ ✲❃ ✬❛ ❧✐st ✯ ✬❜ ✲❃ ✬❜

❖❜✈✐♦✉s ❛♣♣❧✐❝❛t✐♦♥s ♦r ❢♦❧❞❧ ♦r ❢♦❧❞r ❛r❡ t♦ ❛❞❞ ♦r ♠✉❧t✐♣❧② ❛ ❧✐st ♦❢ ♥✉♠❜❡rs✳ ▼❛♥② r❡❝✉rs✐✈❡ ❢✉♥❝t✐♦♥s ♦♥ ❧✐sts ❝❛♥ ❜❡ ❡①♣r❡ss❡❞ ❝♦♥❝✐s❡❧②✳ ❙♦♠❡ ♦❢ t❤❡♠ ❢♦❧❧♦✇ ❝♦♠♠♦♥ ✐❞✐♦♠s ❛♥❞ ❛r❡ ❡❛s✐❧② ✉♥❞❡rst♦♦❞✳ ❇✉t ②♦✉ ❝❛♥ ❡❛s✐❧② ✇r✐t❡ ✐♥❝♦♠♣r❡❤❡♥s✐❜❧❡ ❝♦❞❡✱ t♦♦✳ ❚❤❡ r❡❧❛t✐♦♥s❤✐♣ ❜❡t✇❡❡♥ ❢♦❧❞r ❛♥❞ t❤❡ ❧✐st ❞❛t❛t②♣❡ ✐s ♣❛rt✐❝✉❧❛r❧② ❝❧♦s❡✳ ❍❡r❡ ✐s t❤❡ ❧✐st ❬✶✱✷✱✸✱✹❪ ✐♥ ✐ts ✐♥t❡r♥❛❧ ❢♦r♠❛t✿ :: → :: → :: → :: → nil ↓ ↓ ↓ ↓ 1 2 3 4 ❈♦♠♣❛r❡ ✇✐t❤ t❤❡ ❡①♣r❡ss✐♦♥ ❝♦♠♣✉t❡❞ ❜② ❢♦❧❞r(⊕, e)✳ t❤❡ ✜♥❛❧ ♥✐❧ ✐s r❡✲ ♣❧❛❝❡❞ ❜② e❀ t❤❡ ❝♦♥s❡s ❛r❡ r❡♣❧❛❝❡❞ ❜② ⊕✳ ⊕ → ⊕ → ⊕ → ⊕ → e ↓ ↓ ↓ ↓ 1 2 3 4

❳■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✶✸

Slide 1106

Defining List Functions Using foldl/r

foldl op+ (0,xs)

sum

foldr op:: (xs,ys)

append

foldl (foldl op+) (0,ls)

sum of sums!

foldl (fn(e,x) => e+1) (0,xs)

length

foldl (fn(e,x)=>x::e) ([],xs)

reverse

❚❤❡ s✉♠ ♦❢ ❛ ❧✐st✬s ❡❧❡♠❡♥ts ✐s ❢♦r♠❡❞ ❜② st❛rt✐♥❣ ✇✐t❤ ③❡r♦ ❛♥❞ ❛❞❞✐♥❣ ❡❛❝❤ ❧✐st ❡❧❡♠❡♥t ✐♥ t✉r♥✳ ❯s✐♥❣ ❢♦❧❞r ✇♦✉❧❞ ❜❡ ❧❡ss ❡✣❝✐❡♥t✱ r❡q✉✐r✐♥❣ ❧✐♥❡❛r ✐♥st❡❛❞ ♦❢ ❝♦♥st❛♥t s♣❛❝❡✳ ◆♦t❡ t❤❛t ♦♣✰ t✉r♥s t❤❡ ✐♥✜① ❛❞❞✐t✐♦♥ ♦♣❡r❛t♦r ✐♥t♦ ❛ ❢✉♥❝t✐♦♥ t❤❛t ❝❛♥ ❜❡ ♣❛ss❡❞ t♦ ♦t❤❡r ❢✉♥❝t✐♦♥s s✉❝❤ ❛s ❢♦❧❞❧✳ ❆♣♣❡♥❞ ✐s ❡①♣r❡ss❡❞ s✐♠✐❧❛r❧②✱ ✉s✐♥❣ ♦♣✿✿ t♦ st❛♥❞ ❢♦r t❤❡ ❝♦♥s ❢✉♥❝t✐♦♥✳ ❚❤❡ s✉♠✲♦❢✲s✉♠s ❝♦♠♣✉t❛t✐♦♥ ✐s s♣❛❝❡✲❡✣❝✐❡♥t✿ ✐t ❞♦❡s ♥♦t ❢♦r♠ ❛♥ ✐♥t❡r♠❡❞✐❛t❡ ❧✐st ♦❢ s✉♠s✳ ▼♦r❡♦✈❡r✱ ❢♦❧❞❧ ✐s ✐t❡r❛t✐✈❡✳ ❈❛r❡❢✉❧❧② ♦❜s❡r✈❡ ❤♦✇ t❤❡ ✐♥♥❡r ❢♦❧❞❧ ❡①♣r❡ss❡s ❛ ❢✉♥❝t✐♦♥ t♦ ❛❞❞ ❛ ♥✉♠❜❡r ♦❢ ❛ ❧✐st❀ t❤❡ ♦✉t❡r ❢♦❧❞❧ ❛♣♣❧✐❡s t❤✐s ❢✉♥❝t✐♦♥ t♦ ❡❛❝❤ ❧✐st ✐♥ t✉r♥✱ ❛❝❝✉♠✉❧❛t✐♥❣ ❛ s✉♠ st❛rt✐♥❣ ❢r♦♠ ③❡r♦✳ ❚❤❡ ♥❡st✐♥❣ ✐♥ t❤❡ s✉♠✲♦❢✲s✉♠s ❝❛❧❝✉❧❛t✐♦♥ ✐s t②♣✐❝❛❧ ♦❢ ✇❡❧❧✲❞❡s✐❣♥❡❞ ❢♦❧❞ ❢✉♥❝t✐♦♥❛❧s✳ ❙✐♠✐❧❛r ❢✉♥❝t✐♦♥❛❧s ❝❛♥ ❜❡ ❞❡❝❧❛r❡❞ ❢♦r ♦t❤❡r ❞❛t❛ str✉❝✲ t✉r❡s✱ s✉❝❤ ❛s tr❡❡s✳ ◆❡st✐♥❣ t❤❡s❡ ❢✉♥❝t✐♦♥s ♣r♦✈✐❞❡s ❛ ❝♦♥✈❡♥✐❡♥t ♠❡❛♥s ♦❢ ♦♣❡r❛t✐♥❣ ♦♥ ♥❡st❡❞ ❞❛t❛ str✉❝t✉r❡s✱ s✉❝❤ ❛s tr❡❡s ♦❢ ❧✐sts✳ ❚❤❡ ❧❡♥❣t❤ ❝♦♠♣✉t❛t✐♦♥ ♠✐❣❤t ❜❡ r❡❣❛r❞❡❞ ❛s ❢r✐✈♦❧♦✉s✳ ❆ tr✐✈✐❛❧ ❢✉♥❝t✐♦♥ ✐s s✉♣♣❧✐❡❞ ✉s✐♥❣ ❢♥✲♥♦t❛t✐♦♥❀ ✐t ✐❣♥♦r❡s t❤❡ ❧✐st ❡❧❡♠❡♥ts ❡①❝❡♣t t♦ ❝♦✉♥t t❤❡♠✳ ❍♦✇❡✈❡r✱ t❤✐s ❧❡♥❣t❤ ❢✉♥❝t✐♦♥ t❛❦❡s ❝♦♥st❛♥t s♣❛❝❡✱ ✇❤✐❝❤ ✐s ❜❡tt❡r t❤❛♥ ♥❛ï✈❡ ✈❡rs✐♦♥s s✉❝❤ ❛s ♥❧❡♥❣t❤ ✭▲❡❝t✳ ✹✮✳ ❯s✐♥❣ ❢♦❧❞❧ ❣✉❛r❛♥t❡❡s ❛♥ ✐t❡r❛t✐✈❡ s♦❧✉t✐♦♥ ✇✐t❤ ❛♥ ❛❝❝✉♠✉❧❛t♦r✳

❳■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✶✹

Slide 1107

List Functionals for Predicates

fun exists p [] = false | exists p (x::xs) = (p x) orelse exists p xs; > exists: (’a -> bool) -> (’a list -> bool) fun filter p [] = [] | filter p (x::xs) = if p x then x :: filter p xs else filter p xs; > filter: (’a -> bool) -> (’a list -> ’a list)

(A predicate is a boolean-valued function.)

❚❤❡ ❢✉♥❝t✐♦♥❛❧ ❡①✐sts tr❛♥s❢♦r♠s ❛ ♣r❡❞✐❝❛t❡ ✐♥t♦ ❛ ♣r❡❞✐❝❛t❡ ♦✈❡r ❧✐sts✳

• ✐✈❡♥ ❛ ❧✐st✱ ❡①✐sts ♣ t❡sts ✇❤❡t❤❡r ♦r ♥♦t s♦♠❡ ❧✐st ❡❧❡♠❡♥t s❛t✐s✜❡s ♣

✭♠❛❦✐♥❣ ✐t r❡t✉r♥ tr✉❡✮✳ ■❢ ✐t ✜♥❞s ♦♥❡✱ ✐t st♦♣s s❡❛r❝❤✐♥❣ ✐♠♠❡❞✐❛t❡❧②✱ t❤❛♥❦s t♦ t❤❡ ❜❡❤❛✈✐♦✉r ♦❢ ♦r❡❧s❡❀ t❤✐s ❛s♣❡❝t ♦❢ ❡①✐sts ❝❛♥♥♦t ❜❡ ♦❜t❛✐♥❡❞ ✉s✐♥❣ t❤❡ ❢♦❧❞ ❢✉♥❝t✐♦♥❛❧s✳ ❉✉❛❧❧②✱ ✇❡ ❤❛✈❡ ❛ ❢✉♥❝t✐♦♥❛❧ t♦ t❡st ✇❤❡t❤❡r ❛❧❧ ❧✐st ❡❧❡♠❡♥ts s❛t✐s❢② t❤❡ ♣r❡❞✐❝❛t❡✳ ■❢ ✐t ✜♥❞s ❛ ❝♦✉♥t❡r❡①❛♠♣❧❡ t❤❡♥ ✐t✱ t♦♦✱ st♦♣s s❡❛r❝❤✐♥❣✳

❢✉♥ ❛❧❧ ♣ ❬❪ ❂ tr✉❡ ⑤ ❛❧❧ ♣ ✭①✿✿①s✮ ❂ ✭♣ ①✮ ❛♥❞❛❧s♦ ❛❧❧ ♣ ①s❀ ❃ ❛❧❧✿ ✭✬❛ ✲❃ ❜♦♦❧✮ ✲❃ ✭✬❛ ❧✐st ✲❃ ❜♦♦❧✮

❚❤❡ ❢✐❧t❡r ❢✉♥❝t✐♦♥❛❧ ✐s r❡❧❛t❡❞ t♦ ♠❛♣✳ ■t ❛♣♣❧✐❡s ❛ ♣r❡❞✐❝❛t❡ t♦ ❛❧❧ t❤❡ ❧✐st ❡❧❡♠❡♥ts✱ ❜✉t ✐♥st❡❛❞ ♦❢ r❡t✉r♥✐♥❣ t❤❡ r❡s✉❧t✐♥❣ ✈❛❧✉❡s ✭✇❤✐❝❤ ❝♦✉❧❞ ♦♥❧② ❜❡ tr✉❡ ♦r ❢❛❧s❡✮✱ ✐t r❡t✉r♥s t❤❡ ❧✐st ♦❢ ❡❧❡♠❡♥ts s❛t✐s❢②✐♥❣ t❤❡ ♣r❡❞✐❝❛t❡✳

❳■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✶✺

Slide 1108

Applications of the Predicate Functionals

fun member(y,xs) = exists (fn x => x=y) xs; fun inter(xs,ys) = filter (fn x => member(x,ys)) xs;

Testing whether two lists have no common elements

fun disjoint(xs,ys) = all (fn x => all (fn y => x<>y) ys) xs; > val disjoint = fn: ’’a list * ’’a list -> bool

❆❣❛✐♥✱ ❜② ✇❛② ♦❢ ❡①❛♠♣❧❡✱ ✇❡ ❝♦♥s✐❞❡r ❛♣♣❧✐❝❛t✐♦♥s ♦❢ t❤❡ ♣r❡❞✐❝❛t❡ ❢✉♥❝✲ t✐♦♥❛❧s✳ ▲❡❝t✉r❡ ✺ ♣r❡s❡♥t❡❞ t❤❡ ❢✉♥❝t✐♦♥ ♠❡♠❜❡r✱ ✇❤✐❝❤ t❡sts ✇❤❡t❤❡r ❛ s♣❡❝✐✜❡❞ ✈❛❧✉❡ ❝❛♥ ❜❡ ❢♦✉♥❞ ❛s ❛ ❧✐st ❡❧❡♠❡♥t✱ ❛♥❞ ✐♥t❡r✱ ✇❤✐❝❤ r❡t✉r♥s t❤❡ ✏✐♥t❡rs❡❝t✐♦♥✑ ♦❢ t✇♦ ❧✐sts✿ t❤❡ ❧✐st ♦❢ ❡❧❡♠❡♥ts t❤❡② ❤❛✈❡ ✐♥ ❝♦♠♠♦♥✳ ❇✉t r❡♠❡♠❜❡r✿ t❤❡ ♣✉r♣♦s❡ ♦❢ ❧✐st ❢✉♥❝t✐♦♥❛❧s ✐s ♥♦t t♦ r❡♣❧❛❝❡ t❤❡ ❞❡❝✲ ❧❛r❛t✐♦♥s ♦❢ ♣♦♣✉❧❛r ❢✉♥❝t✐♦♥s✱ ✇❤✐❝❤ ♣r♦❜❛❜❧② ❛r❡ ❛✈❛✐❧❛❜❧❡ ❛❧r❡❛❞②✳ ■t ✐s t♦ ❡❧✐♠✐♥❛t❡ t❤❡ ♥❡❡❞ ❢♦r s❡♣❛r❛t❡ ❞❡❝❧❛r❛t✐♦♥s ♦❢ ❛❞✲❤♦❝ ❢✉♥❝t✐♦♥s✳ ❲❤❡♥ t❤❡② ❛r❡ ♥❡st❡❞✱ ❧✐❦❡ t❤❡ ❝❛❧❧s t♦ ❛❧❧ ✐♥ ❞✐s❥♦✐♥t ❛❜♦✈❡✱ t❤❡ ✐♥♥❡r ❢✉♥❝t✐♦♥s ❛r❡ ❛❧♠♦st ❝❡rt❛✐♥❧② ♦♥❡✲♦✛s✱ ♥♦t ✇♦rt❤ ❞❡❝❧❛r✐♥❣ s❡♣❛r❛t❡❧②✳

❳■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✶✻

Slide 1109

Tree Functionals

fun maptree f Lf = Lf | maptree f (Br(v,t1,t2)) = Br(f v, maptree f t1, maptree f t2); > val maptree = fn > : (’a -> ’b) -> ’a tree -> ’b tree fun fold f e Lf = e | fold f e (Br(v,t1,t2)) = f (v, fold f e t1, fold f e t2); > val fold = fn > : (’a * ’b * ’b -> ’b) -> ’b -> ’a tree -> ’b

❚❤❡ ✐❞❡❛s ♣r❡s❡♥t❡❞ ✐♥ t❤✐s ❧❡❝t✉r❡ ❣❡♥❡r❛❧✐③❡ ✐♥ t❤❡ ♦❜✈✐♦✉s ✇❛② t♦ tr❡❡s ❛♥❞ ♦t❤❡r ❞❛t❛t②♣❡s✱ ♥♦t ♥❡❝❡ss❛r✐❧② r❡❝✉rs✐✈❡ ♦♥❡s✳ ❚❤❡ ❢✉♥❝t✐♦♥❛❧ ♠❛♣tr❡❡ ❛♣♣❧✐❡s ❛ ❢✉♥❝t✐♦♥ t♦ ❡✈❡r② ❧❛❜❡❧ ♦❢ ❛ tr❡❡✱ r❡t✉r♥✲ ✐♥❣ ❛♥♦t❤❡r tr❡❡ ♦❢ t❤❡ s❛♠❡ s❤❛♣❡✳ ❆♥❛❧♦❣✉❡s ♦❢ ❡①✐sts ❛♥❞ ❛❧❧ ❛r❡ tr✐✈✐❛❧ t♦ ❞❡❝❧❛r❡✳ ❖♥ t❤❡ ♦t❤❡r ❤❛♥❞✱ ❢✐❧t❡r ✐s ❤❛r❞ ❜❡❝❛✉s❡ r❡♠♦✈✐♥❣ t❤❡ ✜❧t❡r❡❞ ❧❛❜❡❧s ❝❤❛♥❣❡s t❤❡ tr❡❡✬s s❤❛♣❡❀ ✐❢ ❛ ❧❛❜❡❧ ❢❛✐❧s t♦ s❛t✐s❢② t❤❡ ♣r❡❞✐❝❛t❡✱ t❤❡r❡ ✐s ♥♦ ♦❜✈✐♦✉s ✇❛② t♦ ✐♥❝❧✉❞❡ t❤❡ r❡s✉❧t ♦❢ ✜❧t❡r✐♥❣ ❜♦t❤ s✉❜tr❡❡s✳ ❚❤❡ ❡❛s✐❡st ✇❛② ♦❢ ❞❡❝❧❛r✐♥❣ ❛ ❢♦❧❞ ❢✉♥❝t✐♦♥❛❧ ✐s ❛s s❤♦✇♥ ❛❜♦✈❡✳ ❚❤❡ ❛r❣✉♠❡♥ts ❢ ❛♥❞ ❡ r❡♣❧❛❝❡ t❤❡ ❝♦♥str✉❝t♦rs ❇r ❛♥❞ ▲❢✱ r❡s♣❡❝t✐✈❡❧②✳ ❚❤✐s ❢✉♥❝t✐♦♥❛❧ ❝❛♥ ❜❡ ✉s❡❞ t♦ ❛❞❞ ❛ tr❡❡✬s ❧❛❜❡❧s✱ ❜✉t ✐t r❡q✉✐r❡s ❛ t❤r❡❡✲❛r❣✉♠❡♥t ❛❞❞✐t✐♦♥ ❢✉♥❝t✐♦♥✳ ❚♦ ❛✈♦✐❞ t❤✐s ✐♥❝♦♥✈❡♥✐❡♥❝❡✱ ❢♦❧❞ ❢✉♥❝t✐♦♥❛❧s ❢♦r tr❡❡s ❝❛♥ ✐♠♣❧✐❝✐t❧② tr❡❛t t❤❡ tr❡❡ ❛s ❛ ❧✐st✳ ❋♦r ❡①❛♠♣❧❡✱ ❤❡r❡ ✐s ❛ ❢♦❧❞ ❢✉♥❝t✐♦♥ r❡❧❛t❡❞ t♦ ❢♦❧❞r✱ ✇❤✐❝❤ ♣r♦❝❡ss❡s t❤❡ ❧❛❜❡❧s ✐♥ ✐♥♦r❞❡r✿

❢✉♥ ✐♥❢♦❧❞ ❢ ✭▲❢✱ ❡✮ ❂ ❡ ⑤ ✐♥❢♦❧❞ ❢ ✭❇r✭✈✱t✶✱t✷✮✱ ❡✮ ❂ ✐♥❢♦❧❞ ❢ ✭t✶✱ ❢ ✭✈✱ ✐♥❢♦❧❞ ❢ ✭t✷✱ ❡✮✮✮❀

■ts ❝♦❞❡ ✐s ❞❡r✐✈❡❞ ❢r♦♠ t❤❛t ♦❢ t❤❡ ❢✉♥❝t✐♦♥ ✐♥♦r❞ ♦❢ ▲❡❝t✳ ✼ ❜② ❣❡♥❡r❛❧✐③✐♥❣ ❝♦♥s t♦ t❤❡ ❢✉♥❝t✐♦♥ ❢✳ ❖✉r ♣r✐♠✐t✐✈❡s t❤❡♠s❡❧✈❡s ❝❛♥ ❜❡ s❡❡♥ ❛s ❛ ♣r♦❣r❛♠♠✐♥❣ ❧❛♥❣✉❛❣❡✳ ❚❤✐s tr✉t❤ ✐s ♣❛rt✐❝✉❧❛r❧② ♦❜✈✐♦✉s ✐♥ t❤❡ ❝❛s❡ ♦❢ ❢✉♥❝t✐♦♥❛❧s✱ ❜✉t ✐t ❤♦❧❞s ♦❢ ♣r♦✲ ❣r❛♠♠✐♥❣ ✐♥ ❣❡♥❡r❛❧✳ P❛rt ♦❢ t❤❡ t❛s❦ ♦❢ ♣r♦❣r❛♠♠✐♥❣ ✐s t♦ ❡①t❡♥❞ ♦✉r ♣r♦❣r❛♠♠✐♥❣ ❧❛♥❣✉❛❣❡ ✇✐t❤ ♥♦t❛t✐♦♥ ❢♦r s♦❧✈✐♥❣ t❤❡ ♣r♦❜❧❡♠ ❛t ❤❛♥❞✳ ❚❤❡ ❧❡✈❡❧s ♦❢ ♥♦t❛t✐♦♥ t❤❛t ✇❡ ❞❡✜♥❡ s❤♦✉❧❞ ❝♦rr❡s♣♦♥❞ t♦ ♥❛t✉r❛❧ ❧❡✈❡❧s ♦❢ ❛❜✲ str❛❝t✐♦♥ ✐♥ t❤❡ ♣r♦❜❧❡♠ ❞♦♠❛✐♥✳

❳■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✶✼ ▲❡❛r♥✐♥❣ ❣✉✐❞❡✳ ❘❡❧❛t❡❞ ♠❛t❡r✐❛❧ ✐s ✐♥ ▼▲ ❢♦r t❤❡ ❲♦r❦✐♥❣ Pr♦❣r❛♠♠❡r✱ ♣❛❣❡s ✶✽✷✕✶✾✵✳ ❊①❡r❝✐s❡ ✶✶✳✶ ❲✐t❤♦✉t ✉s✐♥❣ ♠❛♣✱ ❝✉rr②✐♥❣✱ ❡t❝✳✱ ✇r✐t❡ ❛ ❢✉♥❝t✐♦♥ t❤❛t ✐s ❡q✉✐✈❛❧❡♥t t♦ ♠❛♣ ✭♠❛♣ ❞♦✉❜❧❡✮✳ ❚❤❡ ♦❜✈✐♦✉s s♦❧✉t✐♦♥ r❡q✉✐r❡s ❞❡❝❧❛r✐♥❣ t✇♦ r❡❝✉rs✐✈❡ ❢✉♥❝t✐♦♥s✳ ❚r② t♦ ❣❡t ❛✇❛② ✇✐t❤ ♦♥❧② ♦♥❡ ❜② ❡①♣❧♦✐t✐♥❣ ♥❡st❡❞ ♣❛tt❡r♥✲♠❛t❝❤✐♥❣✳ ❊①❡r❝✐s❡ ✶✶✳✷ ❊①♣r❡ss t❤❡ ❢✉♥❝t✐♦♥❛❧ ♠❛♣ ✉s✐♥❣ ❢♦❧❞r✳ ❊①❡r❝✐s❡ ✶✶✳✸ ❉❡❝❧❛r❡ ❛♥ ❛♥❛❧♦❣✉❡ ♦❢ ♠❛♣ ❢♦r t②♣❡ ♦♣t✐♦♥✿

❞❛t❛t②♣❡ ✬❛ ♦♣t✐♦♥ ❂ ◆❖◆❊ ⑤ ❙❖▼❊ ♦❢ ✬❛❀

❊①❡r❝✐s❡ ✶✶✳✹ ❘❡❝❛❧❧ t❤❡ ♠❛❦✐♥❣ ❝❤❛♥❣❡ ❢✉♥❝t✐♦♥ ♦❢ ▲❡❝t✳ ✺✿

❢✉♥ ❝❤❛♥❣❡ ✳✳✳ ⑤ ❝❤❛♥❣❡ ✭❝✿✿t✐❧❧✱ ❛♠t✮ ❂ ✐❢ ✳✳✳ ❡❧s❡ ❧❡t ❢✉♥ ❛❧❧❝ ❬❪ ❂ ❬❪ ⑤ ❛❧❧❝✭❝s✿✿❝ss✮ ❂ ✭❝✿✿❝s✮✿✿❛❧❧❝ ❝ss ✐♥ ❛❧❧❝ ✭❝❤❛♥❣❡✭❝✿✿t✐❧❧✱ ❛♠t✲❝✮✮ ❅ ❝❤❛♥❣❡✭t✐❧❧✱ ❛♠t✮ ❡♥❞❀

❋✉♥❝t✐♦♥ ❛❧❧❝ ❛♣♣❧✐❡s t❤❡ ❢✉♥❝t✐♦♥ ❵❝♦♥s ❛ ❝✬ t♦ ❡✈❡r② ❡❧❡♠❡♥t ♦❢ ❛ ❧✐st✳ ❊❧✐♠✐♥❛t❡ ✐t ❜② ❞❡❝❧❛r✐♥❣ ❛ ❝✉rr✐❡❞ ❝♦♥s ❢✉♥❝t✐♦♥ ❛♥❞ ❛♣♣❧②✐♥❣ ♠❛♣✳

❳■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✶✽

Slide 1201

Computer Algebra

symbolic arithmetic on polynomials, trig functions, . . . closed-form or power-series solutions, not NUMERICAL ones rational arithmetic instead of FLOATING-POINT For scientific and engineering calculations Univariate polynomials anxn + · · · + a0x0 Example of data representation and algorithms in practice

❚❤✐s ❧❡❝t✉r❡ ✐❧❧✉str❛t❡s t❤❡ tr❡❛t♠❡♥t ♦❢ ❛ ❤❛r❞ ♣r♦❜❧❡♠✿ ♣♦❧②♥♦♠✐❛❧ ❛r✐t❤♠❡t✐❝✳ ▼❛♥② ♦♣❡r❛t✐♦♥s ❝♦✉❧❞ ❜❡ ♣❡r❢♦r♠❡❞ ♦♥ ♣♦❧②♥♦♠✐❛❧s✱ s♦ ✇❡ s❤❛❧❧ ❤❛✈❡ t♦ s✐♠♣❧✐❢② t❤❡ ♣r♦❜❧❡♠ ❞r❛st✐❝❛❧❧②✳ ❲❡ s❤❛❧❧ ♦♥❧② ❝♦♥s✐❞❡r ❢✉♥❝t✐♦♥s t♦ ❛❞❞ ❛♥❞ ♠✉❧t✐♣❧② ♣♦❧②♥♦♠✐❛❧s ✐♥ ♦♥❡ ✈❛r✐❛❜❧❡✳ ❚❤❡s❡ ❢✉♥❝t✐♦♥s ❛r❡ ♥❡✐t❤❡r ❡✣❝✐❡♥t ♥♦r ❛❝❝✉r❛t❡✱ ❜✉t ❛t ❧❡❛st t❤❡② ♠❛❦❡ ❛ st❛rt✳ ❇❡✇❛r❡✿ ❡✣❝✐❡♥t✱ ❣❡♥❡r❛❧ ❛❧❣♦r✐t❤♠s ❢♦r ♣♦❧②♥♦♠✐❛❧s ❛r❡ ❝♦♠♣❧✐❝❛t❡❞ ❡♥♦✉❣❤ t♦ ❜♦❣❣❧❡ t❤❡ ♠✐♥❞✳ ❆❧t❤♦✉❣❤ ❝♦♠♣✉t❡rs ✇❡r❡ ♦r✐❣✐♥❛❧❧② ✐♥✈❡♥t❡❞ ❢♦r ♣❡r❢♦r♠✐♥❣ ♥✉♠❡r✐❝❛❧ ❛r✐t❤♠❡t✐❝✱ s❝✐❡♥t✐sts ❛♥❞ ❡♥❣✐♥❡❡rs ♦❢t❡♥ ♣r❡❢❡r ❝❧♦s❡❞✲❢♦r♠ s♦❧✉t✐♦♥s t♦ ♣r♦❜❧❡♠s✳ ❆ ❢♦r♠✉❧❛ ✐s ♠♦r❡ ❝♦♠♣❛❝t t❤❛♥ ❛ t❛❜❧❡ ♦❢ ♥✉♠❜❡rs✱ ❛♥❞ ✐ts ♣r♦♣❡rt✐❡s✖t❤❡ ♥✉♠❜❡r ♦❢ ❝r♦ss✐♥❣s t❤r♦✉❣❤ ③❡r♦✱ ❢♦r ❡①❛♠♣❧❡✖❝❛♥ ❜❡ ❞❡✲ t❡r♠✐♥❡❞ ❡①❛❝t❧②✳ P♦❧②♥♦♠✐❛❧s ❛r❡ ❛ ♣❛rt✐❝✉❧❛r❧② s✐♠♣❧❡ ❦✐♥❞ ♦❢ ❢♦r♠✉❧❛✳ ❆ ♣♦❧②♥♦♠✐❛❧ ✐s ❛ ❧✐♥❡❛r ❝♦♠❜✐♥❛t✐♦♥ ♦❢ ♣r♦❞✉❝ts ♦❢ ❝❡rt❛✐♥ ✈❛r✐❛❜❧❡s✳ ❋♦r ❡①❛♠♣❧❡✱ ❛ ♣♦❧②♥♦♠✐❛❧ ✐♥ t❤❡ ✈❛r✐❛❜❧❡s x✱ y ❛♥❞ z ❤❛s t❤❡ ❢♦r♠

ijk aijk xiyjzk✱ ✇❤❡r❡

♦♥❧② ✜♥✐t❡❧② ♠❛♥② ♦❢ t❤❡ ❝♦❡✣❝✐❡♥ts aijk ❛r❡ ♥♦♥✲③❡r♦✳ P♦❧②♥♦♠✐❛❧s ✐♥ ♦♥❡ ✈❛r✐❛❜❧❡✱ s❛② x✱ ❛r❡ ❝❛❧❧❡❞ ✉♥✐✈❛r✐❛t❡✳ ❊✈❡♥ r❡str✐❝t✐♥❣ ♦✉rs❡❧✈❡s t♦ ✉♥✐✈❛r✐❛t❡ ♣♦❧②♥♦♠✐❛❧s ❞♦❡s ♥♦t ♠❛❦❡ ♦✉r t❛s❦ ❡❛s②✳ ❚❤✐s ❡①❛♠♣❧❡ ❞❡♠♦♥str❛t❡s ❤♦✇ t♦ r❡♣r❡s❡♥t ❛ ♥♦♥✲tr✐✈✐❛❧ ❢♦r♠ ♦❢ ❞❛t❛ ❛♥❞ ❤♦✇ t♦ ❡①♣❧♦✐t ❜❛s✐❝ ❛❧❣♦r✐t❤♠✐❝ ✐❞❡❛s t♦ ❣❛✐♥ ❡✣❝✐❡♥❝②✳

❳■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✶✾

Slide 1202

Data Representation Example: Finite Sets

represent by repetition-free lists representations not unique:

{3, 4} ւ ց [3, 4] [4, 3]

INVALID representations? [3, 3] represents no set ML operations must preserve the representation Representation must promote efficiency: try ordered lists?

▼▲ ❞♦❡s ♥♦t ♣r♦✈✐❞❡ ✜♥✐t❡ s❡ts ❛s ❛ ❞❛t❛ str✉❝t✉r❡✳ ❲❡ ❝♦✉❧❞ r❡♣r❡s❡♥t t❤❡♠ ❜② ❧✐sts ✇✐t❤♦✉t r❡♣❡t✐t✐♦♥s✳ ❋✐♥✐t❡ s❡ts ❛r❡ ❛ s✐♠♣❧❡ ❡①❛♠♣❧❡ ♦❢ ❞❛t❛ r❡♣r❡s❡♥t❛t✐♦♥✳ ❆ ❝♦❧❧❡❝t✐♦♥ ♦❢ ❛❜str❛❝t ♦❜❥❡❝ts ✭✜♥✐t❡ s❡ts✮ ✐s r❡♣r❡s❡♥t❡❞ ✉s✐♥❣ ❛ s❡t ♦❢ ❝♦♥❝r❡t❡ ♦❜❥❡❝ts ✭r❡♣❡t✐t✐♦♥✲❢r❡❡ ❧✐sts✮✳ ❊✈❡r② ❛❜str❛❝t ♦❜❥❡❝t ✐s r❡♣r❡s❡♥t❡❞ ❜② ❛t ❧❡❛st ♦♥❡ ❝♦♥❝r❡t❡ ♦❜❥❡❝t✱ ♠❛②❜❡ ♠♦r❡ t❤❛♥ ♦♥❡✱ ❢♦r {3, 4} ❝❛♥ ❜❡ r❡♣r❡s❡♥t❡❞ ❜② [3, 4] ♦r [4, 3]✳ ❙♦♠❡ ❝♦♥❝r❡t❡ ♦❜❥❡❝ts✱ s✉❝❤ ❛s [3, 3]✱ r❡♣r❡s❡♥t ♥♦ ❛❜str❛❝t ♦❜❥❡❝t ❛t ❛❧❧✳ ❖♣❡r❛t✐♦♥s ♦♥ t❤❡ ❛❜str❛❝t ❞❛t❛ ❛r❡ ❞❡✜♥❡❞ ✐♥ t❡r♠s ♦❢ t❤❡ r❡♣r❡s❡♥t❛✲ t✐♦♥s✳ ❋♦r ❡①❛♠♣❧❡✱ t❤❡ ▼▲ ❢✉♥❝t✐♦♥ ✐♥t❡r ✭▲❡❝t✳ ✺✮ ✐♠♣❧❡♠❡♥ts t❤❡ ❛❜str❛❝t ✐♥t❡rs❡❝t✐♦♥ ♦♣❡r❛t✐♦♥ ∩ ♣r♦✈✐❞❡❞ ✐♥t❡r(l, l′) r❡♣r❡s❡♥ts A ∩ A′ ❢♦r ❛❧❧ ❧✐sts l ❛♥❞ l′ t❤❛t r❡♣r❡s❡♥t t❤❡ s❡ts A ❛♥❞ A′✳ ■t ✐s ❡❛s② t♦ ❝❤❡❝❦ t❤❛t ✐♥t❡r ♣r❡✲ s❡r✈❡s t❤❡ r❡♣r❡s❡♥t❛t✐♦♥✿ ✐ts r❡s✉❧t ✐s r❡♣❡t✐t✐♦♥✲❢r❡❡ ♣r♦✈✐❞❡❞ ✐ts ❛r❣✉♠❡♥ts ❛r❡✳ ▼❛❦✐♥❣ t❤❡ ❧✐sts r❡♣❡t✐t✐♦♥✲❢r❡❡ ♠❛❦❡s t❤❡ ❜❡st ♣♦ss✐❜❧❡ ✉s❡ ♦❢ s♣❛❝❡✳ ❚✐♠❡ ❝♦♠♣❧❡①✐t② ❝♦✉❧❞ ❜❡ ✐♠♣r♦✈❡❞✳ ❋♦r♠✐♥❣ t❤❡ ✐♥t❡rs❡❝t✐♦♥ ♦❢ ❛♥ m✲ ❡❧❡♠❡♥t s❡t ❛♥❞ ❛♥ n✲❡❧❡♠❡♥t s❡t r❡q✉✐r❡s ✜♥❞✐♥❣ ❛❧❧ t❤❡ ❡❧❡♠❡♥ts t❤❡② ❤❛✈❡ ✐♥ ❝♦♠♠♦♥✳ ■t ❝❛♥ ♦♥❧② ❜❡ ❞♦♥❡ ❜② tr②✐♥❣ ❛❧❧ ♣♦ss✐❜✐❧✐t✐❡s✱ t❛❦✐♥❣ O(mn) t✐♠❡✳ ❙❡ts ♦❢ ♥✉♠❜❡rs✱ str✐♥❣s ♦r ♦t❤❡r ✐t❡♠s ♣♦ss❡ss✐♥❣ ❛ t♦t❛❧ ♦r❞❡r✐♥❣ s❤♦✉❧❞ ❜❡ r❡♣r❡s❡♥t❡❞ ❜② ♦r❞❡r❡❞ ❧✐sts✳ ❚❤❡ ✐♥t❡rs❡❝t✐♦♥ ❝♦♠♣✉t❛t✐♦♥ t❤❡♥ r❡s❡♠❜❧❡s ♠❡r❣✐♥❣ ❛♥❞ ❝❛♥ ❜❡ ♣❡r❢♦r♠❡❞ ✐♥ O(m + n) t✐♠❡✳ ❙♦♠❡ ❞❡❡♣❡r ✐ss✉❡s ❝❛♥ ♦♥❧② ❜❡ ♠❡♥t✐♦♥❡❞ ❤❡r❡✳ ❋♦r ❡①❛♠♣❧❡✱ ✢♦❛t✐♥❣✲ ♣♦✐♥t ❛r✐t❤♠❡t✐❝ ✐♠♣❧❡♠❡♥ts r❡❛❧ ❛r✐t❤♠❡t✐❝ ♦♥❧② ❛♣♣r♦①✐♠❛t❡❧②✳

❳■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✷✵

Slide 1203

A Data Structure for Polynomials

polynomial anxn + · · · + a0x0 as list [(n, an), . . . , (0, a0)] REAL coefficients (should be rational) Sparse representation (no zero coefficients) Decreasing exponents

x500 − 2

as

[(500, 1), (0, −2)] ❚❤❡ ✉♥✐✈❛r✐❛t❡ ♣♦❧②♥♦♠✐❛❧ anxn + · · · + a0x0 ♠✐❣❤t ❜❡ r❡♣r❡s❡♥t❡❞ ❜② t❤❡ ❧✐st ♦❢ ❝♦❡✣❝✐❡♥ts [an, . . . , a0]✳ ❚❤✐s ❞❡♥s❡ r❡♣r❡s❡♥t❛t✐♦♥ ✐s ✐♥❡✣❝✐❡♥t ✐❢ ♠❛♥② ❝♦❡✣❝✐❡♥ts ❛r❡ ③❡r♦✱ ❛s ✐♥ x500 − 2✳ ■♥st❡❛❞ ✇❡ ✉s❡ ❛ ❧✐st ♦❢ ✭❡①♣♦♥❡♥t✱ ❝♦❡✣❝✐❡♥t✮ ♣❛✐rs ✇✐t❤ ♦♥❧② ♥♦♥③❡r♦ ❝♦❡✣❝✐❡♥ts✿ ❛ s♣❛rs❡ r❡♣r❡s❡♥t❛t✐♦♥✳ ❈♦❡✣❝✐❡♥ts s❤♦✉❧❞ ❜❡ r❛t✐♦♥❛❧ ♥✉♠❜❡rs✿ ♣❛✐rs ♦❢ ✐♥t❡❣❡rs ✇✐t❤ ♥♦ ❝♦♠♠♦♥ ❢❛❝t♦r✳ ❊①❛❝t r❛t✐♦♥❛❧ ❛r✐t❤♠❡t✐❝ ✐s ❡❛s✐❧② ❞♦♥❡✱ ❜✉t ✐t r❡q✉✐r❡s ❛r❜✐tr❛r②✲ ♣r❡❝✐s✐♦♥ ✐♥t❡❣❡r ❛r✐t❤♠❡t✐❝✱ ✇❤✐❝❤ ✐s t♦♦ ❝♦♠♣❧✐❝❛t❡❞ ❢♦r ♦✉r ♣✉r♣♦s❡s✳ ❲❡ s❤❛❧❧ r❡♣r❡s❡♥t ❝♦❡✣❝✐❡♥ts ❜② t❤❡ ▼▲ t②♣❡ r❡❛❧✱ ✇❤✐❝❤ ✐s ❢❛r ❢r♦♠ ✐❞❡❛❧✳ ❚❤❡ ❝♦❞❡ s❡r✈❡s t❤❡ ♣✉r♣♦s❡ ♦❢ ✐❧❧✉str❛t✐♥❣ s♦♠❡ ❛❧❣♦r✐t❤♠s ❢♦r ♣♦❧②♥♦♠✐❛❧ ❛r✐t❤♠❡t✐❝✳ P♦❧②♥♦♠✐❛❧s ✇✐❧❧ ❤❛✈❡ t❤❡ ▼▲ t②♣❡ ✭✐♥t✯r❡❛❧✮❧✐st✱ r❡♣r❡s❡♥t✐♥❣ t❤❡ s✉♠ ♦❢ t❡r♠s✱ ❡❛❝❤ t❡r♠ ❣✐✈❡♥ ❜② ❛♥ ✐♥t❡❣❡r ❡①♣♦♥❡♥t ❛♥❞ r❡❛❧ ❝♦❡✣❝✐❡♥t✳ ❚♦ ♣r♦♠♦t❡ ❡✣❝✐❡♥❝②✱ ✇❡ ♥♦t ♦♥❧② ♦♠✐t ③❡r♦ ❝♦❡✣❝✐❡♥ts ❜✉t st♦r❡ t❤❡ ♣❛✐rs ✐♥ ❞❡❝r❡❛s✐♥❣ ♦r❞❡r ♦❢ ❡①♣♦♥❡♥ts✳ ❚❤❡ ♦r❞❡r✐♥❣ ❛❧❧♦✇s ❛❧❣♦r✐t❤♠s r❡s❡♠❜❧✐♥❣ ♠❡r❣❡s♦rt ❛♥❞ ❛❧❧♦✇s ❛t ♠♦st ♦♥❡ t❡r♠ t♦ ❤❛✈❡ ❛ ❣✐✈❡♥ ❡①♣♦♥❡♥t✳ ❚❤❡ ❞❡❣r❡❡ ♦❢ ❛ ♥♦♥✲③❡r♦ ✉♥✐✈❛r✐❛t❡ ♣♦❧②♥♦♠✐❛❧ ✐s ✐ts ❧❛r❣❡st ❡①♣♦♥❡♥t✳ ■❢ an = 0 t❤❡♥ anxn + · · · + a0x0 ❤❛s ❞❡❣r❡❡ n✳ ❖✉r r❡♣r❡s❡♥t❛t✐♦♥ ♠❛❦❡s ✐t tr✐✈✐❛❧ t♦ ❝♦♠♣✉t❡ ❛ ♣♦❧②♥♦♠✐❛❧✬s ❞❡❣r❡❡✳ ❋♦r ❡①❛♠♣❧❡✱ ❬✭✺✵✵✱✶✳✵✮✱ ✭✵✱⑦✷✳✵✮❪ r❡♣r❡s❡♥ts x500 − 2✳ ◆♦t ❡✈❡r② ❧✐st ♦❢ t②♣❡ ✭✐♥t✯r❡❛❧✮❧✐st ✐s ❛ ♣♦❧②♥♦♠✐❛❧✳ ❖✉r ♦♣❡r❛t✐♦♥s ♠❛② ❛ss✉♠❡ t❤❡✐r ❛r❣✉♠❡♥ts t♦ ❜❡ ✈❛❧✐❞ ♣♦❧②♥♦♠✐❛❧s ❛♥❞ ❛r❡ r❡q✉✐r❡❞ t♦ ❞❡❧✐✈❡r ✈❛❧✐❞ ♣♦❧②♥♦♠✐❛❧s✳

❳■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✷✶

Slide 1204

Specifying the Polynomial Operations

• poly is the type of univariate polynomials
• makepoly makes a polynomial from a list
• destpoly returns a polynomial as a list
• polysum adds two polynomials
• polyprod multiplies two polynomials
• polyquorem computes quotient and remainder

❆♥ ✐♠♣❧❡♠❡♥t❛t✐♦♥ ♦❢ ✉♥✐✈❛r✐❛t❡ ♣♦❧②♥♦♠✐❛❧s ♠✐❣❤t s✉♣♣♦rt t❤❡ ♦♣❡r❛✲ t✐♦♥s ❛❜♦✈❡✱ ✇❤✐❝❤ ❝♦✉❧❞ ❜❡ s✉♠♠❛r✐③❡❞ ❛s ❢♦❧❧♦✇s✿

t②♣❡ ♣♦❧② ✈❛❧ ♠❛❦❡♣♦❧② ✿ ✭✐♥t✯r❡❛❧✮❧✐st ✲❃ ♣♦❧② ✈❛❧ ❞❡st♣♦❧② ✿ ♣♦❧② ✲❃ ✭✐♥t✯r❡❛❧✮❧✐st ✈❛❧ ♣♦❧②s✉♠ ✿ ♣♦❧② ✲❃ ♣♦❧② ✲❃ ♣♦❧② ✈❛❧ ♣♦❧②♣r♦❞ ✿ ♣♦❧② ✲❃ ♣♦❧② ✲❃ ♣♦❧② ✈❛❧ ♣♦❧②q✉♦r❡♠ ✿ ♣♦❧② ✲❃ ♣♦❧② ✲❃ ♣♦❧② ✯ ♣♦❧②

❚❤✐s t✐❞② s♣❡❝✐✜❝❛t✐♦♥ ❝❛♥ ❜❡ ❝❛♣t✉r❡❞ ❛s ❛♥ ▼▲ s✐❣♥❛t✉r❡✳ ❆ ❜✉♥❞❧❡ ♦❢ ❞❡❝❧❛r❛t✐♦♥s ♠❡❡t✐♥❣ t❤❡ s✐❣♥❛t✉r❡ ❝❛♥ ❜❡ ♣❛❝❦❛❣❡❞ ❛s ❛♥ ▼▲ str✉❝t✉r❡✳ ❚❤❡s❡ ❝♦♥❝❡♣ts ♣r♦♠♦t❡ ♠♦❞✉❧❛r✐t②✱ ❧❡tt✐♥❣ ✉s ❦❡❡♣ t❤❡ ❤✐❣❤❡r ❛❜str❛❝t✐♦♥ ❧❡✈❡❧s t✐❞②✳ ■♥ ♣❛rt✐❝✉❧❛r✱ t❤❡ str✉❝t✉r❡ ♠✐❣❤t ❤❛✈❡ t❤❡ ♥❛♠❡ P♦❧② ❛♥❞ ✐ts ❝♦♠♣♦♥❡♥ts ❝♦✉❧❞ ❤❛✈❡ t❤❡ s❤♦rt ♥❛♠❡s s✉♠✱ ♣r♦❞✱ ❡t❝✳❀ ❢r♦♠ ♦✉ts✐❞❡ t❤❡ str✉❝t✉r❡✱ t❤❡② ✇♦✉❧❞ ❜❡ ❝❛❧❧❡❞ P♦❧②✳s✉♠✱ P♦❧②✳♣r♦❞✱ ❡t❝✳ ❚❤✐s ❝♦✉rs❡ ❞♦❡s ♥♦t ❞✐s❝✉ss ▼▲ ♠♦❞✉❧❡s✱ ❜✉t ❛ ♠♦❞✉❧❛r tr❡❛t♠❡♥t ♦❢ ♣♦❧②♥♦♠✐❛❧s ❝❛♥ ❜❡ ❢♦✉♥❞ ✐♥ ♠② ❜♦♦❦ ❬✶✸❪✳ ▼♦❞✉❧❡s ❛r❡ ❡ss❡♥t✐❛❧ ❢♦r ❜✉✐❧❞✐♥❣ ❧❛r❣❡ s②st❡♠s✳ ❋✉♥❝t✐♦♥ ♠❛❦❡♣♦❧② ❝♦✉❧❞ ❝♦♥✈❡rt ❛ ❧✐st t♦ ❛ ✈❛❧✐❞ ♣♦❧②♥♦♠✐❛❧✱ ✇❤✐❧❡ ❞❡st♣♦❧② ❝♦✉❧❞ r❡t✉r♥ t❤❡ ✉♥❞❡r❧②✐♥❣ ❧✐st✳ ❋♦r ♠❛♥② ❛❜str❛❝t t②♣❡s✱ t❤❡ ✉♥❞❡r❧②✐♥❣ r❡♣r❡s❡♥t❛t✐♦♥ ♦✉❣❤t t♦ ❜❡ ❤✐❞❞❡♥✳ ❋♦r ❞✐❝t✐♦♥❛r✐❡s ✭▲❡❝t✳ ✽✮✱ ✇❡ ❝❡rt❛✐♥❧② ❞♦ ♥♦t ✇❛♥t ❛♥ ♦♣❡r❛t✐♦♥ t♦ r❡t✉r♥ ❛ ❞✐❝t✐♦♥❛r② ❛s ❛ ❜✐♥❛r② s❡❛r❝❤ tr❡❡✳ ❖✉r ❧✐st✲♦❢✲♣❛✐rs r❡♣r❡s❡♥t❛t✐♦♥✱ ❤♦✇❡✈❡r✱ ✐s s✉✐t❛❜❧❡ ❢♦r ❝♦♠♠✉♥✐❝❛t✐♥❣ ♣♦❧②♥♦♠✐❛❧s t♦ t❤❡ ♦✉ts✐❞❡ ✇♦r❧❞✳ ■t ♠✐❣❤t ❜❡ r❡t❛✐♥❡❞ ❢♦r t❤❛t ♣✉r♣♦s❡ ❡✈❡♥ ✐❢ s♦♠❡ ♦t❤❡r r❡♣r❡s❡♥t❛t✐♦♥ ✇❡r❡ ❝❤♦s❡♥ t♦ ❢❛❝✐❧✐t❛t❡ ❢❛st ❛r✐t❤♠❡t✐❝✳

❳■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✷✷

Slide 1205

Polynomial addition

fun polysum [] us = us : (int*real)list | polysum ts [] = ts | polysum ((m,a)::ts) ((n,b)::us) = if m>n then (m,a) :: polysum ts ((n,b)::us) else if n>m then (n,b) :: polysum us ((m,a)::ts) else (*m=n*) if a+b=0.0 then polysum ts us else (m, a+b) :: polysum ts us;

❖✉r r❡♣r❡s❡♥t❛t✐♦♥ ❛❧❧♦✇s ❛❞❞✐t✐♦♥✱ ♠✉❧t✐♣❧✐❝❛t✐♦♥ ❛♥❞ ❞✐✈✐s✐♦♥ t♦ ❜❡ ♣❡r✲ ❢♦r♠❡❞ ✉s✐♥❣ t❤❡ ❝❧❛ss✐❝❛❧ ❛❧❣♦r✐t❤♠s t❛✉❣❤t ✐♥ s❝❤♦♦❧s✳ ❚❤❡✐r ❡✣❝✐❡♥❝② ❝❛♥ s♦♠❡t✐♠❡s ❜❡ ✐♠♣r♦✈❡❞ ✉♣♦♥✳ ❋♦r ♥♦ ♣❛rt✐❝✉❧❛r r❡❛s♦♥✱ t❤❡ ❛r✐t❤♠❡t✐❝ ❢✉♥❝✲ t✐♦♥s ❛r❡ ❛❧❧ ❝✉rr✐❡❞✳ ❆❞❞✐t✐♦♥ ✐♥✈♦❧✈❡s ❛❞❞✐♥❣ ❝♦rr❡s♣♦♥❞✐♥❣ ❝♦❡✣❝✐❡♥ts ❢r♦♠ t❤❡ t✇♦ ♣♦❧②✲ ♥♦♠✐❛❧s✳ Pr❡s❡r✈✐♥❣ t❤❡ ♣♦❧②♥♦♠✐❛❧ r❡♣r❡s❡♥t❛t✐♦♥ r❡q✉✐r❡s ♣r❡s❡r✈✐♥❣ t❤❡ ♦r❞❡r✐♥❣ ❛♥❞ ♦♠✐tt✐♥❣ ③❡r♦ ❝♦❡✣❝✐❡♥ts✳✶ ❚❤❡ ❛❞❞✐t✐♦♥ ❛❧❣♦r✐t❤♠ r❡s❡♠❜❧❡s ♠❡r❣✐♥❣✳ ■❢ ❜♦t❤ ♣♦❧②♥♦♠✐❛❧s ❛r❡ ♥♦♥✲ ❡♠♣t② ❧✐sts✱ ❝♦♠♣❛r❡ t❤❡✐r ❧❡❛❞✐♥❣ t❡r♠s✳ ❚❛❦❡ t❤❡ t❡r♠ ✇✐t❤ t❤❡ ❧❛r❣❡r ❡①♣♦♥❡♥t ✜rst✳ ■❢ t❤❡ ❡①♣♦♥❡♥ts ❛r❡ ❡q✉❛❧✱ t❤❡♥ ❝r❡❛t❡ ❛ s✐♥❣❧❡ t❡r♠✱ ❛❞❞✐♥❣ t❤❡✐r ❝♦❡✣❝✐❡♥ts❀ ✐❢ t❤❡ s✉♠ ✐s ③❡r♦✱ t❤❡♥ ❞✐s❝❛r❞ t❤❡ ♥❡✇ t❡r♠✳

✶❙♦♠❡ ▼▲ ❝♦♠♣✐❧❡rs ✐♥s✐st ✉♣♦♥ ❘❡❛❧✳❂❂✭❛✰❜✱✵✳✵✮ ✐♥st❡❛❞ ♦❢ ❛✰❜❂✵✳✵ ❛❜♦✈❡✳

❳■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✷✸

Slide 1206

Polynomial multiplication (1st try)

fun termprod (m,a) (n,b)

term × term

= (m+n, a*b) : (int*real); fun polyprod [] us = []

poly × poly

| polyprod ((m,a)::ts) us = polysum (map (termprod(m,a)) us) (polyprod ts us);

BAD MERGING; 16 seconds to square (x + 1)400

▼✉❧t✐♣❧✐❝❛t✐♦♥ ♦❢ ♣♦❧②♥♦♠✐❛❧s ✐s ❛❧s♦ str❛✐❣❤t❢♦r✇❛r❞ ♣r♦✈✐❞❡❞ ✇❡ ❞♦ ♥♦t ❝❛r❡ ❛❜♦✉t ❡✣❝✐❡♥❝②❀ t❤❡ s❝❤♦♦❧❜♦♦❦ ❛❧❣♦r✐t❤♠ s✉✣❝❡s✳ ❚♦ ❝r♦ss✲♠✉❧t✐♣❧② t❤❡ t❡r♠s✱ ❢✉♥❝t✐♦♥ ♣♦❧②♣r♦❞ ❢♦r♠s ♣r♦❞✉❝ts t❡r♠ ❜② t❡r♠ ❛♥❞ ❛❞❞s t❤❡ ✐♥t❡r♠❡❞✐❛t❡ ♣♦❧②♥♦♠✐❛❧s✳ ❲❡ s❡❡ ❛♥♦t❤❡r ❛♣♣❧✐❝❛t✐♦♥ ♦❢ t❤❡ ❢✉♥❝t✐♦♥❛❧ ♠❛♣✿ t❤❡ ♣r♦❞✉❝t ♦❢ t❤❡ t❡r♠ ✭♠✱❛✮ ✇✐t❤ t❤❡ ♣♦❧②♥♦♠✐❛❧ ts ✐s s✐♠♣❧②

♠❛♣ ✭t❡r♠♣r♦❞✭♠✱❛✮✮ ts

❳■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✷✹

Slide 1207

Polynomial multiplication (2nd try)

fun polyprod [] us = [] | polyprod [(m,a)] us = map (termprod(m,a)) us | polyprod ts us = let val k = length ts div 2 in polysum (polyprod (take(ts,k)) us) (polyprod (drop(ts,k)) us) end;

4 seconds to square (x + 1)400

❚❤❡ ❢✉♥❝t✐♦♥ ♣♦❧②♣r♦❞ ✐s t♦♦ s❧♦✇ t♦ ❤❛♥❞❧❡ ❧❛r❣❡ ♣♦❧②♥♦♠✐❛❧s✳ ■♥ t❡sts✱ ✐t r❡q✉✐r❡❞ ❛❜♦✉t ✶✻ s❡❝♦♥❞s ❛♥❞ ♥✉♠❡r♦✉s ❣❛r❜❛❣❡ ❝♦❧❧❡❝t✐♦♥s t♦ ❝♦♠♣✉t❡ t❤❡ sq✉❛r❡ ♦❢ (x+1)400✳ ✭❙✉❝❤ ❧❛r❣❡ ❝♦♠♣✉t❛t✐♦♥s ❛r❡ t②♣✐❝❛❧ ♦❢ s②♠❜♦❧✐❝ ❛❧✲ ❣❡❜r❛✳✮ ❚❤❡ ✐♥❡✣❝✐❡♥❝② ✐s ❞✉❡ t♦ t❤❡ ♠❡r❣✐♥❣ ✭✐♥ ♣♦❧②s✉♠✮ ♦❢ ❧✐sts t❤❛t ❞✐✛❡r ❣r❡❛t❧② ✐♥ ❧❡♥❣t❤✳ ❋♦r ✐♥st❛♥❝❡✱ ✐❢ ts ❛♥❞ ✉s ❝♦♥s✐st ♦❢ ✶✵✵ t❡r♠s ❡❛❝❤✱ t❤❡♥ ✭t❡r♠♣♦❧②♣r♦❞ ✭❡✱❝✮ ✉s✮ ❤❛s ♦♥❧② ✶✵✵ t❡r♠s✱ ✇❤✐❧❡ ✭♣♦❧②♣r♦❞ ts ✉s✮ ❝♦✉❧❞ ❤❛✈❡ ❛s ♠❛♥② ❛s ✶✵✱✵✵✵✳ ❚❤❡✐r s✉♠ ✇✐❧❧ ❤❛✈❡ ❛t ♠♦st ✶✵✱✶✵✵ t❡r♠s❀ ❛ ❣r♦✇t❤ ♦❢ ♦♥❧② ✶✪✳ ▼❡r❣✐♥❣ ❝♦♣✐❡s ❜♦t❤ ❧✐sts❀ ✐❢ ♦♥❡ ❧✐st ✐s ♠✉❝❤ s❤♦rt❡r t❤❛♥ t❤❡ ♦t❤❡r✱ t❤❡♥ ✐t ❡✛❡❝t✐✈❡❧② ❞❡❣❡♥❡r❛t❡s t♦ ✐♥s❡rt✐♦♥✳ ❆ ❢❛st❡r ❛❧❣♦r✐t❤♠ ✐s ✐♥s♣✐r❡❞ ❜② ♠❡r❣❡s♦rt ✭▲❡❝t✳ ✻✮✳ ❉✐✈✐❞❡ ♦♥❡ ♦❢ t❤❡ ♣♦❧②♥♦♠✐❛❧s ✐♥t♦ ❡q✉❛❧ ♣❛rts✱ ✉s✐♥❣ t❛❦❡ ❛♥❞ ❞r♦♣✳ ❈♦♠♣✉t❡ t✇♦ ♣r♦❞✉❝ts ♦❢ r♦✉❣❤❧② ❡q✉❛❧ s✐③❡ ❛♥❞ ♠❡r❣❡ t❤♦s❡✳ ■❢ ♦♥❡ ♣♦❧②♥♦♠✐❛❧ ❝♦♥s✐sts ♦❢ ❛ s✐♥❣❧❡ t❡r♠✱ ♠✉❧t✐♣❧② ✐t ❜② t❤❡ ♦t❤❡r ♣♦❧②♥♦♠✐❛❧ ✉s✐♥❣ ♠❛♣ ❛s ❛❜♦✈❡✳ ❚❤✐s ❛❧❣♦r✐t❤♠ ♣❡r❢♦r♠s ♠❛♥② ❢❡✇❡r ♠❡r❣❡s✱ ❛♥❞ ❡❛❝❤ ♠❡r❣❡ r♦✉❣❤❧② ❞♦✉❜❧❡s t❤❡ s✐③❡ ♦❢ t❤❡ r❡s✉❧t✳ ❖t❤❡r ❛❧❣♦r✐t❤♠s ❝❛♥ ♠✉❧t✐♣❧② ♣♦❧②♥♦♠✐❛❧s ❢❛st❡r st✐❧❧✳

❳■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✷✺

Slide 1208

Polynomial division

fun polyquorem ts ((n,b)::us) = let fun quo [] qs = (rev qs, []) | quo ((m,a)::ts) qs = if m<n then (rev qs, (m,a)::ts) else quo (polysum ts (map (termprod(m-n, ~a/b)) us)) ((m-n, a/b) :: qs) in quo ts [] end;

▲❡t ✉s t✉r♥ t♦ ❢✉♥❝t✐♦♥s ❢♦r ❝♦♠♣✉t✐♥❣ ♣♦❧②♥♦♠✐❛❧ q✉♦t✐❡♥ts ❛♥❞ r❡♠❛✐♥✲ ❞❡rs✳ ❚❤❡ ❢✉♥❝t✐♦♥ ♣♦❧②q✉♦r❡♠ ✐♠♣❧❡♠❡♥ts t❤❡ s❝❤♦♦❧❜♦♦❦ ❛❧❣♦r✐t❤♠ ❢♦r ♣♦❧②♥♦♠✐❛❧ ❞✐✈✐s✐♦♥✱ ✇❤✐❝❤ ✐s ❛❝t✉❛❧❧② s✐♠♣❧❡r t❤❛♥ ❧♦♥❣ ❞✐✈✐s✐♦♥✳ ■t r❡t✉r♥s t❤❡ ♣❛✐r ✭q✉♦t✐❡♥t✱ r❡♠❛✐♥❞❡r✮✱ ✇❤❡r❡ t❤❡ r❡♠❛✐♥❞❡r ✐s ❡✐t❤❡r ③❡r♦ ♦r ♦❢ ❧❡ss❡r ❞❡❣r❡❡ t❤❛♥ t❤❡ ❞✐✈✐s♦r✳ ❚❤❡ ❢✉♥❝t✐♦♥s ♣♦❧②q✉♦ ❛♥❞ ♣♦❧②r❡♠ r❡t✉r♥ t❤❡ ❞❡s✐r❡❞ ❝♦♠♣♦♥❡♥t ♦❢ t❤❡ r❡s✉❧t✱ ✉s✐♥❣ t❤❡ ▼▲ s❡❧❡❝t♦rs ★✶ ❛♥❞ ★✷✿

❢✉♥ ♣♦❧②q✉♦ ts ✉s ❂ ★✶✭♣♦❧②q✉♦r❡♠ ts ✉s✮ ❛♥❞ ♣♦❧②r❡♠ ts ✉s ❂ ★✷✭♣♦❧②q✉♦r❡♠ ts ✉s✮❀

❆s✐❞❡✿ ✐❢ k ✐s ❛♥② ♣♦s✐t✐✈❡ ✐♥t❡❣❡r ❝♦♥st❛♥t✱ t❤❡♥ ★k ✐s t❤❡ ▼▲ ❢✉♥❝t✐♦♥ t♦ r❡t✉r♥ t❤❡ kt❤ ❝♦♠♣♦♥❡♥t ♦❢ ❛ t✉♣❧❡✳ ❚✉♣❧❡s ❛r❡ ❛ s♣❡❝✐❛❧ ❝❛s❡ ♦❢ ▼▲ r❡❝♦r❞s✱ ❛♥❞ t❤❡ ★ ♥♦t❛t✐♦♥ ✇♦r❦s ❢♦r ❛r❜✐tr❛r② r❡❝♦r❞ ✜❡❧❞s✳ ❋♦r ❡①❛♠♣❧❡✱ ❧❡t ✉s ❞✐✈✐❞❡ x2 + 1 ❜② x + 1✿

♣♦❧②q✉♦r❡♠ ❬✭✷✱✶✳✵✮✱✭✵✱✶✳✵✮❪ ❬✭✶✱✶✳✵✮✱✭✵✱✶✳✵✮❪❀ ❃ ✈❛❧ ✐t ❂ ✭❬✭✶✱ ✶✳✵✮✱ ✭✵✱ ⑦✶✳✵✮❪✱ ❬✭✵✱ ✷✳✵✮❪✮

❚❤✐s ♣❛✐r t❡❧❧s ✉s t❤❛t t❤❡ q✉♦t✐❡♥t ✐s x − 1 ❛♥❞ t❤❡ r❡♠❛✐♥❞❡r ✐s ✷✳ ❲❡ ❝❛♥ ❡❛s✐❧② ✈❡r✐❢② t❤❛t (x + 1)(x − 1) + 2 = x2 − 1 + 2 = x2 + 1✳

❳■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✷✻

Slide 1209

The Greatest Common Divisor

fun polygcd [] us = us | polygcd ts us = polygcd (polyrem us ts) ts;

needed to simplify rational functions such as

x2 − 1 x2 − 2x + 1

• = x + 1

x − 1

• strange answers

TOO SLOW

❘❛t✐♦♥❛❧ ❢✉♥❝t✐♦♥s ❛r❡ ♣♦❧②♥♦♠✐❛❧ ❢r❛❝t✐♦♥s ❧✐❦❡ (x + 1)/(x − 1)✳ ❊✣✲ ❝✐❡♥❝② ❞❡♠❛♥❞s t❤❛t ❛ ❢r❛❝t✐♦♥✬s ♥✉♠❡r❛t♦r ❛♥❞ ❞❡♥♦♠✐♥❛t♦r s❤♦✉❧❞ ❤❛✈❡ ♥♦ ❝♦♠♠♦♥ ❢❛❝t♦r✳ ❲❡ s❤♦✉❧❞ ❞✐✈✐❞❡ t❤❡ ❜♦t❤ ♣♦❧②♥♦♠✐❛❧s ❜② t❤❡✐r ❣r❡❛t❡st ❝♦♠♠♦♥ ❞✐✈✐s♦r ✭●❈❉✮✳ ❲❡ ❝❛♥ ❝♦♠♣✉t❡ ●❈❉s ✉s✐♥❣ ❊✉❝❧✐❞✬s ❆❧❣♦r✐t❤♠✱ ❛s s❤♦✇♥ ❛❜♦✈❡✳ ❯♥✲ ❢♦rt✉♥❛t❡❧②✱ ✐ts ❜❡❤❛✈✐♦✉r ❢♦r ♣♦❧②♥♦♠✐❛❧s ✐s r❛t❤❡r ♣❡r✈❡rs❡✳ ■t ❣✐✈❡s t❤❡

• ❈❉ ♦❢ x2 + 2x + 1 ❛♥❞ x2 − 1 ❛s −2x − 2✱ ❛♥❞ t❤❛t ♦❢ x2 + 2x + 1 ❛♥❞

x5 + 1 ❛s 5x + 5❀ ❜♦t❤ ●❈❉s s❤♦✉❧❞ ❜❡ x + 1✳ ❚❤✐s ♣❛rt✐❝✉❧❛r ❞✐✣❝✉❧t② ❝❛♥ ❜❡ s♦❧✈❡❞ ❜② ❞✐✈✐❞✐♥❣ t❤r♦✉❣❤ ❜② t❤❡ ❧❡❛❞✐♥❣ ❝♦❡✣❝✐❡♥t✱ ❜✉t ❊✉❝❧✐❞✬s ❆❧❣♦r✐t❤♠ t✉r♥s ♦✉t t♦ ❜❡ t♦♦ s❧♦✇✳ ❆♥ ✐♥♥♦❝✉♦✉s✲❧♦♦❦✐♥❣ ♣❛✐r ♦❢ ❛r❣✉♠❡♥ts ❧❡❛❞s t♦ ❝♦♠♣✉t❛t✐♦♥s ♦♥ ❣✐❣❛♥t✐❝ ✐♥t❡❣❡rs✱ ❡✈❡♥ ✇❤❡♥ t❤❡ ✜♥❛❧ ●❈❉ ✐s ❥✉st ♦♥❡✦ ✭❚❤❛t ✐s t❤❡ ✉s✉❛❧ ♦✉t❝♦♠❡✿ ♠♦st ♣❛✐rs ♦❢ ♣♦❧②♥♦♠✐❛❧s ❤❛✈❡ ♥♦ ❝♦♠♠♦♥ ❢❛❝t♦r✳✮ ❚❤❡ ♣r♦❜❧❡♠ ♦❢ ❝♦♠♣✉t✐♥❣ t❤❡ ●❈❉ ♦❢ ♣♦❧②♥♦♠✐❛❧s ✐s ❝❡♥tr❛❧ t♦ t❤❡ ✜❡❧❞ ♦❢ ❝♦♠♣✉t❡r ❛❧❣❡❜r❛✳ ❊①tr❡♠❡❧② ❝♦♠♣❧❡① ❛❧❣♦r✐t❤♠s ❛r❡ ❡♠♣❧♦②❡❞✳ ❆ s✉❝❝❡ss❢✉❧ ✐♠♣❧❡♠❡♥t❛t✐♦♥ ♠❛❦❡s ✉s❡ ♦❢ ❞❡❡♣ ♠❛t❤❡♠❛t✐❝s ❛s ✇❡❧❧ ❛s s❦✐❧❧❡❞ ♣r♦❣r❛♠♠✐♥❣✳ ▼❛♥② ♣r♦❥❡❝ts ✐♥ ❛❞✈❛♥❝❡❞ t❡❝❤♥♦❧♦❣② r❡q✉✐r❡ t❤✐s s❛♠❡ ❝♦♠✲ ❜✐♥❛t✐♦♥ ♦❢ ❛❜✐❧✐t✐❡s✳

❳■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✷✼ ▲❡❛r♥✐♥❣ ❣✉✐❞❡✳ ❘❡❧❛t❡❞ ♠❛t❡r✐❛❧ ✐s ✐♥ ▼▲ ❢♦r t❤❡ ❲♦r❦✐♥❣ Pr♦❣r❛♠♠❡r✱ ♣❛❣❡s ✶✶✹✕✶✷✶✳ ❊①❡r❝✐s❡ ✶✷✳✶ ❈♦❞❡ t❤❡ s❡t ♦♣❡r❛t✐♦♥s ♦❢ ♠❡♠❜❡rs❤✐♣ t❡st✱ s✉❜s❡t t❡st✱ ✉♥✐♦♥ ❛♥❞ ✐♥t❡rs❡❝t✐♦♥ ✉s✐♥❣ t❤❡ ♦r❞❡r❡❞✲❧✐st r❡♣r❡s❡♥t❛t✐♦♥✳ ❊①❡r❝✐s❡ ✶✷✳✷

• ✐✈❡ ❛ ❝♦♥✈✐♥❝✐♥❣ ❛r❣✉♠❡♥t t❤❛t ♣♦❧②s✉♠ ❛♥❞ ♣♦❧②♣r♦❞

♣r❡s❡r✈❡ t❤❡ t❤r❡❡ r❡str✐❝t✐♦♥s ♦♥ ♣♦❧②♥♦♠✐❛❧s✳ ❊①❡r❝✐s❡ ✶✷✳✸ ❍♦✇ ✇♦✉❧❞ ②♦✉ ♣r♦✈❡ t❤❛t ♣♦❧②s✉♠ ❝♦rr❡❝t❧② ❝♦♠♣✉t❡s t❤❡ s✉♠ ♦❢ t✇♦ ♣♦❧②♥♦♠✐❛❧s❄ ❍✐♥t✿ ✇r✐t❡ ❛ ♠❛t❤❡♠❛t✐❝❛❧ ✭♥♦t ▼▲✮ ❢✉♥❝t✐♦♥ t♦ ❡①♣r❡ss t❤❡ ♣♦❧②♥♦♠✐❛❧ r❡♣r❡s❡♥t❡❞ ❜② ❛ ❧✐st✳ ❲❤✐❝❤ ♣r♦♣❡rt✐❡s ♦❢ ♣♦❧②♥♦♠✐❛❧ ❛❞❞✐t✐♦♥ ❞♦❡s ♣♦❧②s✉♠ ❛ss✉♠❡❄ ❊①❡r❝✐s❡ ✶✷✳✹ ❙❤♦✇ t❤❛t t❤❡ ❝♦♠♣❧❡①✐t② ♦❢ ♣♦❧②s✉♠ ✐s O(m + n) ✇❤❡♥ ❛♣♣❧✐❡❞ t♦ ❛r❣✉♠❡♥ts ❝♦♥s✐st✐♥❣ ♦❢ m ❛♥❞ n t❡r♠s✱ r❡s♣❡❝t✐✈❡❧②✳ ❊①❡r❝✐s❡ ✶✷✳✺

• ✐✈❡ ❛ ♠♦r❡ r✐❣♦r♦✉s ❛♥❛❧②s✐s ♦❢ t❤❡ ❛s②♠♣t♦t✐❝ ❝♦♠♣❧❡①✐t②

♦❢ t❤❡ t✇♦ ✈❡rs✐♦♥s ♦❢ ♣♦❧②♥♦♠✐❛❧ ♠✉❧t✐♣❧✐❝❛t✐♦♥✳ ✭❚❤✐s ❝♦✉❧❞ ❜❡ ❞✐✣❝✉❧t✳✮ ❊①❡r❝✐s❡ ✶✷✳✻ ■❢ ❝♦❡✣❝✐❡♥ts ♠❛② t❤❡♠s❡❧✈❡s ❜❡ ✉♥✐✈❛r✐❛t❡ ♣♦❧②♥♦♠✐❛❧s ✭✐♥ s♦♠❡ ♦t❤❡r ✈❛r✐❛❜❧❡✮✱ t❤❡♥ ✇❡ r❡❣❛✐♥ t❤❡ ❛❜✐❧✐t② t♦ r❡♣r❡s❡♥t ♣♦❧②♥♦♠✐❛❧s ✐♥ ❛♥② ♥✉♠❜❡r ♦❢ ✈❛r✐❛❜❧❡s✳ ❋♦r ❡①❛♠♣❧❡✱ y2 + xy ✐s ❛ ✉♥✐✈❛r✐❛t❡ ♣♦❧②♥♦♠✐❛❧ ✐♥ y ✇❤♦s❡ ❝♦❡✣❝✐❡♥ts ❛r❡ ✶ ❛♥❞ t❤❡ ♣♦❧②♥♦♠✐❛❧ x✳ ❉❡✜♥❡ t❤✐s r❡♣r❡s❡♥t❛t✐♦♥ ✐♥ ▼▲ ❛♥❞ ❞✐s❝✉ss ✐❞❡❛s ❢♦r ✐♠♣❧❡♠❡♥t✐♥❣ ❛❞❞✐t✐♦♥ ❛♥❞ ♠✉❧t✐♣❧✐❝❛t✐♦♥✳

❳■■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✷✽

Slide 1301

A Pipeline

Producer → Filter → · · · → Filter → Consumer Produce sequence of items Filter sequence in stages Consume results as needed Lazy lists join the stages together

❚✇♦ t②♣❡s ♦❢ ♣r♦❣r❛♠ ❝❛♥ ❜❡ ❞✐st✐♥❣✉✐s❤❡❞✳ ❆ s❡q✉❡♥t✐❛❧ ♣r♦❣r❛♠ ❛❝❝❡♣ts ❛ ♣r♦❜❧❡♠ t♦ s♦❧✈❡✱ ♣r♦❝❡ss❡s ❢♦r ❛ ✇❤✐❧❡✱ ❛♥❞ ✜♥❛❧❧② t❡r♠✐♥❛t❡s ✇✐t❤ ✐ts r❡s✉❧t✳ ❆ t②♣✐❝❛❧ ❡①❛♠♣❧❡ ✐s t❤❡ ❤✉❣❡ ♥✉♠❡r✐❝❛❧ s✐♠✉❧❛t✐♦♥s t❤❛t ❛r❡ r✉♥ ♦♥ s✉♣❡r❝♦♠♣✉t❡rs✳ ▼♦st ♦❢ ♦✉r ▼▲ ❢✉♥❝t✐♦♥s ❛❧s♦ ✜t t❤✐s ♠♦❞❡❧✳ ❆t t❤❡ ♦t❤❡r ❡①tr❡♠❡ ❛r❡ r❡❛❝t✐✈❡ ♣r♦❣r❛♠s✱ ✇❤♦s❡ ❥♦❜ ✐s t♦ ✐♥t❡r❛❝t ✇✐t❤ t❤❡ ❡♥✈✐r♦♥♠❡♥t✳ ❚❤❡② ❝♦♠♠✉♥✐❝❛t❡ ❝♦♥st❛♥t❧② ❞✉r✐♥❣ t❤❡✐r ♦♣❡r❛t✐♦♥ ❛♥❞ r✉♥ ❢♦r ❛s ❧♦♥❣ ❛s ✐s ♥❡❝❡ss❛r②✳ ❆ t②♣✐❝❛❧ ❡①❛♠♣❧❡ ✐s t❤❡ s♦❢t✇❛r❡ t❤❛t ❝♦♥✲ tr♦❧s ♠❛♥② ♠♦❞❡r♥ ❛✐r❝r❛❢t✳ ❘❡❛❝t✐✈❡ ♣r♦❣r❛♠s ♦❢t❡♥ ❝♦♥s✐st ♦❢ ❝♦♥❝✉rr❡♥t ♣r♦❝❡ss❡s r✉♥♥✐♥❣ ❛t t❤❡ s❛♠❡ t✐♠❡ ❛♥❞ ❝♦♠♠✉♥✐❝❛t✐♥❣ ✇✐t❤ ♦♥❡ ❛♥♦t❤❡r✳ ❈♦♥❝✉rr❡♥❝② ✐s t♦♦ ❞✐✣❝✉❧t t♦ ❝♦♥s✐❞❡r ✐♥ t❤✐s ❝♦✉rs❡✱ ❜✉t ✇❡ ❝❛♥ ♠♦❞❡❧ s✐♠♣❧❡ ♣✐♣❡❧✐♥❡s s✉❝❤ ❛s t❤❛t s❤♦✇♥ ❛❜♦✈❡✳ ❚❤❡ Pr♦❞✉❝❡r r❡♣r❡s❡♥ts ♦♥❡ ♦r ♠♦r❡ s♦✉r❝❡s ♦❢ ❞❛t❛✱ ✇❤✐❝❤ ✐t ♦✉t♣✉ts ❛s ❛ str❡❛♠✳ ❚❤❡ ❋✐❧t❡r st❛❣❡s ❝♦♥✈❡rt t❤❡ ✐♥♣✉t str❡❛♠ t♦ ❛♥ ♦✉t♣✉t str❡❛♠✱ ♣❡r❤❛♣s ❝♦♥s✉♠✐♥❣ s❡✈❡r❛❧ ✐♥♣✉t ✐t❡♠s t♦ ②✐❡❧❞ ❛ s✐♥❣❧❡ ♦✉t♣✉t ✐t❡♠✳ ❚❤❡ ❈♦♥s✉♠❡r t❛❦❡s ❛s ♠❛♥② ❡❧❡♠❡♥ts ❛s ♥❡❝❡ss❛r②✳ ❚❤❡ ❈♦♥s✉♠❡r ❞r✐✈❡s t❤❡ ♣✐♣❡❧✐♥❡✿ ♥♦t❤✐♥❣ ✐s ❝♦♠♣✉t❡❞ ❡①❝❡♣t ✐♥ r❡✲ s♣♦♥s❡ t♦ ✐ts ❞❡♠❛♥❞ ❢♦r ❛♥ ❛❞❞✐t✐♦♥❛❧ ❞❛t✉♠✳ ❊①❡❝✉t✐♦♥ ♦❢ t❤❡ ❋✐❧t❡r st❛❣❡s ✐s ✐♥t❡r❧❡❛✈❡❞ ❛s r❡q✉✐r❡❞ ❢♦r t❤❡ ❝♦♠♣✉t❛t✐♦♥ t♦ ❣♦ t❤r♦✉❣❤✳ ❚❤❡ ♣r♦❣r❛♠✲ ♠❡r s❡ts ✉♣ t❤❡ ❞❛t❛ ❞❡♣❡♥❞❡♥❝✐❡s ❜✉t ❤❛s ♥♦ ❝❧❡❛r ✐❞❡❛ ♦❢ ✇❤❛t ❤❛♣♣❡♥s ✇❤❡♥✳ ❲❡ ❤❛✈❡ t❤❡ ✐❧❧✉s✐♦♥ ♦❢ ❝♦♥❝✉rr❡♥t ❝♦♠♣✉t❛t✐♦♥✳ ❚❤❡ ❯♥✐① ♦♣❡r❛t✐♥❣ s②st❡♠ ♣r♦✈✐❞❡s s✐♠✐❧❛r ✐❞❡❛s t❤r♦✉❣❤ ✐ts ♣✐♣❡s t❤❛t ❧✐♥❦ ♣r♦❝❡ss❡s t♦❣❡t❤❡r✳ ■♥ ▼▲✱ ✇❡ ❝❛♥ ♠♦❞❡❧ ♣✐♣❡❧✐♥❡s ✉s✐♥❣ ❧❛③② ❧✐sts✳

❳■■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✷✾

Slide 1302

Lazy Lists — or Streams

Lists of possibly INFINITE length

• elements computed upon demand
• avoids waste if there are many solutions
• infinite objects are a useful abstraction

In ML: implement laziness by delaying evaluation of the tail

▲❛③② ❧✐sts ❤❛✈❡ ♣r❛❝t✐❝❛❧ ✉s❡s✳ ❙♦♠❡ ❛❧❣♦r✐t❤♠s✱ ❧✐❦❡ ♠❛❦✐♥❣ ❝❤❛♥❣❡✱ ❝❛♥ ②✐❡❧❞ ♠❛♥② s♦❧✉t✐♦♥s ✇❤❡♥ ♦♥❧② ❛ ❢❡✇ ❛r❡ r❡q✉✐r❡❞✳ ❙♦♠❡t✐♠❡s t❤❡ ♦r✐❣✐♥❛❧ ♣r♦❜❧❡♠ ❝♦♥❝❡r♥s ✐♥✜♥✐t❡ s❡r✐❡s✿ ✇✐t❤ ❧❛③② ❧✐sts✱ ✇❡ ❝❛♥ ♣r❡t❡♥❞ t❤❡② r❡❛❧❧② ❡①✐st✦ ❲❡ ❛r❡ ♥♦✇ ❞❡❛❧✐♥❣ ✇✐t❤ ✐♥✜♥✐t❡✱ ♦r ❛t ❧❡❛st ✉♥❜♦✉♥❞❡❞✱ ❝♦♠♣✉t❛t✐♦♥s✳ ❆ ♣♦t❡♥t✐❛❧❧② ✐♥✜♥✐t❡ s♦✉r❝❡ ♦❢ ❞❛t❛ ✐s ♣r♦❝❡ss❡❞ ♦♥❡ ❡❧❡♠❡♥t ❛t ❛ t✐♠❡✱ ✉♣♦♥ ❞❡♠❛♥❞✳ ❙✉❝❤ ♣r♦❣r❛♠s ❛r❡ ❤❛r❞❡r t♦ ✉♥❞❡rst❛♥❞ t❤❛♥ t❡r♠✐♥❛t✐♥❣ ♦♥❡s ❛♥❞ ❤❛✈❡ ♠♦r❡ ✇❛②s ♦❢ ❣♦✐♥❣ ✇r♦♥❣✳ ❙♦♠❡ ♣✉r❡❧② ❢✉♥❝t✐♦♥❛❧ ❧❛♥❣✉❛❣❡s✱ s✉❝❤ ❛s ❍❛s❦❡❧❧✱ ✉s❡ ❧❛③② ❡✈❛❧✉❛t✐♦♥ ❡✈❡r②✇❤❡r❡✳ ❊✈❡♥ t❤❡ ✐❢✲t❤❡♥✲❡❧s❡ ❝♦♥str✉❝t ❝❛♥ ❜❡ ❛ ❢✉♥❝t✐♦♥✱ ❛♥❞ ❛❧❧ ❧✐sts ❛r❡ ❧❛③②✳ ■♥ ▼▲✱ ✇❡ ❝❛♥ ❞❡❝❧❛r❡ ❛ t②♣❡ ♦❢ ❧✐sts s✉❝❤ t❤❛t ❡✈❛❧✉❛t✐♦♥ ♦❢ t❤❡ t❛✐❧ ❞♦❡s ♥♦t ♦❝❝✉r ✉♥t✐❧ ❞❡♠❛♥❞❡❞✳ ❉❡❧❛②❡❞ ❡✈❛❧✉❛t✐♦♥ ✐s ✇❡❛❦❡r t❤❛♥ ❧❛③② ❡✈❛❧✉❛t✐♦♥✱ ❜✉t ✐t ✐s ❣♦♦❞ ❡♥♦✉❣❤ ❢♦r ♦✉r ♣✉r♣♦s❡s✳ ❚❤❡ tr❛❞✐t✐♦♥❛❧ ✇♦r❞ str❡❛♠ ✐s r❡s❡r✈❡❞ ✐♥ ▼▲ ♣❛r❧❛♥❝❡ ❢♦r ✐♥♣✉t✴♦✉t♣✉t ❝❤❛♥♥❡❧s✳ ▲❡t ✉s ❝❛❧❧ ❧❛③② ❧✐sts s❡q✉❡♥❝❡s✳

❳■■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✸✵

Slide 1303

Lazy Lists in ML

The empty tuple () and its type unit Delayed version of E is fn()=>E

datatype ’a seq = Nil

sequences

| Cons of ’a * (unit -> ’a seq); fun head (Cons(x,_)) = x; fun tail (Cons(_,xf)) = xf();

Cons(x,xf) has head x and tail function xf ❚❤❡ ♣r✐♠✐t✐✈❡ ▼▲ t②♣❡ ✉♥✐t ❤❛s ♦♥❡ ❡❧❡♠❡♥t✱ ✇❤✐❝❤ ✐s ✇r✐tt❡♥ ✭✮✳ ❚❤✐s ❡❧❡♠❡♥t ♠❛② ❜❡ r❡❣❛r❞❡❞ ❛s ❛ ✵✲t✉♣❧❡✱ ❛♥❞ ✉♥✐t ❛s t❤❡ ♥✉❧❧❛r② ❈❛rt❡s✐❛♥ ♣r♦❞✉❝t✳ ✭❚❤✐♥❦ ♦❢ t❤❡ ❝♦♥♥❡❝t✐♦♥ ❜❡t✇❡❡♥ ♠✉❧t✐♣❧✐❝❛t✐♦♥ ❛♥❞ t❤❡ ♥✉♠❜❡r ✶✳✮ ❚❤❡ ❡♠♣t② t✉♣❧❡ s❡r✈❡s ❛s ❛ ♣❧❛❝❡❤♦❧❞❡r ✐♥ s✐t✉❛t✐♦♥s ✇❤❡r❡ ♥♦ ✐♥❢♦r♠❛✲ t✐♦♥ ✐s r❡q✉✐r❡❞✳ ■t ❤❛s s❡✈❡r❛❧ ✉s❡s✿

• ■t ♠❛② ❛♣♣❡❛r ✐♥ ❛ ❞❛t❛ str✉❝t✉r❡✳ ❋♦r ❡①❛♠♣❧❡✱ ❛ ✉♥✐t✲✈❛❧✉❡❞ ❞✐❝t✐♦✲

♥❛r② r❡♣r❡s❡♥ts ❛ s❡t ♦❢ ❦❡②s✳

• ■t ♠❛② ❜❡ t❤❡ ❛r❣✉♠❡♥t ♦❢ ❛ ❢✉♥❝t✐♦♥✱ ✇❤❡r❡ ✐ts ❡✛❡❝t ✐s t♦ ❞❡❧❛② ❡✈❛❧✲

✉❛t✐♦♥✳

• ■t ♠❛② ❜❡ t❤❡ ❛r❣✉♠❡♥t ♦r r❡s✉❧t ♦❢ ❛ ♣r♦❝❡❞✉r❡✳ ✭❙❡❡ ▲❡❝t✳ ✶✹✳✮

❚❤❡ ❡♠♣t② t✉♣❧❡✱ ❧✐❦❡ ❛❧❧ t✉♣❧❡s✱ ✐s ❛ ❝♦♥str✉❝t♦r ❛♥❞ ✐s ❛❧❧♦✇❡❞ ✐♥ ♣❛tt❡r♥s✿

❢✉♥ ❢ ✭✮ ❂ ✳✳✳

■♥ ♣❛rt✐❝✉❧❛r✱ ❢♥✭✮ ❂❃ E ✐s t❤❡ ❢✉♥❝t✐♦♥ t❤❛t t❛❦❡s ❛♥ ❛r❣✉♠❡♥t ♦❢ t②♣❡ ✉♥✐t ❛♥❞ r❡t✉r♥s t❤❡ ✈❛❧✉❡ ♦❢ E ❛s ✐ts r❡s✉❧t✳ ❊①♣r❡ss✐♦♥ E ✐s ♥♦t ❡✈❛❧✉❛t❡❞ ✉♥t✐❧ t❤❡ ❢✉♥❝t✐♦♥ ✐s ❝❛❧❧❡❞✱ ❡✈❡♥ t❤♦✉❣❤ t❤❡ ♦♥❧② ♣♦ss✐❜❧❡ ❛r❣✉♠❡♥t ✐s ✭✮✳ ❚❤❡ ❢✉♥❝t✐♦♥ s✐♠♣❧② ❞❡❧❛②s t❤❡ ❡✈❛❧✉❛t✐♦♥ ♦❢ E✳

❳■■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✸✶

Slide 1304

The Infinite Sequence k, k + 1, k + 2,. . .

fun from k = Cons(k, fn()=> from(k+1)); > val from = fn : int -> int seq from 1; > val it = Cons(1, fn) : int seq tail it; > val it = Cons(2, fn) : int seq tail it; > val it = Cons(3, fn) : int seq

❋✉♥❝t✐♦♥ ❢r♦♠ ❝♦♥str✉❝ts t❤❡ ✐♥✜♥✐t❡ s❡q✉❡♥❝❡ ♦❢ ✐♥t❡❣❡rs st❛rt✐♥❣ ❢r♦♠ k✳ ❊①❡❝✉t✐♦♥ t❡r♠✐♥❛t❡s ❜❡❝❛✉s❡ ♦❢ t❤❡ ❢♥ ❡♥❝❧♦s✐♥❣ t❤❡ r❡❝✉rs✐✈❡ ❝❛❧❧✳ ▼▲ ❞✐s♣❧❛②s t❤❡ t❛✐❧ ♦❢ ❛ s❡q✉❡♥❝❡ ❛s ❢♥✱ ✇❤✐❝❤ st❛♥❞s ❢♦r s♦♠❡ ❢✉♥❝t✐♦♥ ✈❛❧✉❡✳ ❊❛❝❤ ❝❛❧❧ t♦ t❛✐❧ ❣❡♥❡r❛t❡s t❤❡ ♥❡①t s❡q✉❡♥❝❡ ❡❧❡♠❡♥t✳ ❲❡ ❝♦✉❧❞ ❞♦ t❤✐s ❢♦r❡✈❡r✳ ❚❤✐s ❡①❛♠♣❧❡ ✐s ♦❢ ❧✐tt❧❡ ♣r❛❝t✐❝❛❧ ✈❛❧✉❡ ❜❡❝❛✉s❡ t❤❡ ❝♦st ♦❢ ❝♦♠♣✉t✐♥❣ ❛ s❡q✉❡♥❝❡ ❡❧❡♠❡♥t ✇✐❧❧ ❜❡ ❞♦♠✐♥❛t❡❞ ❜② t❤❛t ♦❢ ❝r❡❛t✐♥❣ t❤❡ ❞✉♠♠② ❢✉♥❝t✐♦♥✳ ▲❛③② ❧✐sts t❡♥❞ t♦ ❤❛✈❡ ❤✐❣❤ ♦✈❡r❤❡❛❞s✳

❳■■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✸✷

Slide 1305

Consuming a Sequence

fun get(0,xq) = [] | get(n,Nil) = [] | get(n,Cons(x,xf)) = x :: get(n-1,xf()); > val get = fn : int * ’a seq -> ’a list

Get the first n elements as a list

xf() forces evaluation ❚❤❡ ❢✉♥❝t✐♦♥ ❣❡t ❝♦♥✈❡rts ❛ s❡q✉❡♥❝❡ t♦ ❛ ❧✐st✳ ■t t❛❦❡s t❤❡ ✜rst n ❡❧❡✲ ♠❡♥ts❀ ✐t t❛❦❡s ❛❧❧ ♦❢ t❤❡♠ ✐❢ n < 0✱ ✇❤✐❝❤ ❝❛♥ t❡r♠✐♥❛t❡ ♦♥❧② ✐❢ t❤❡ s❡q✉❡♥❝❡ ✐s ✜♥✐t❡✳ ■♥ t❤❡ t❤✐r❞ ❧✐♥❡ ♦❢ ❣❡t✱ t❤❡ ❡①♣r❡ss✐♦♥ ①❢✭✮ ❝❛❧❧s t❤❡ t❛✐❧ ❢✉♥❝t✐♦♥✱ ❞❡✲ ♠❛♥❞✐♥❣ ❡✈❛❧✉❛t✐♦♥ ♦❢ t❤❡ ♥❡①t ❡❧❡♠❡♥t✳ ❚❤✐s ♦♣❡r❛t✐♦♥ ✐s ❝❛❧❧❡❞ ❢♦r❝✐♥❣ t❤❡ ❧✐st✳

❳■■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✸✸

Slide 1306

Sample Evaluation

get(2, from 6) ⇒ get(2, Cons(6, fn()=>from(6+1))) ⇒ 6 :: get(1, from(6+1)) ⇒ 6 :: get(1, Cons(7, fn()=>from(7+1))) ⇒ 6 :: 7 :: get(0, Cons(8, fn()=>from(8+1))) ⇒ 6 :: 7 :: [] ⇒ [6,7]

❍❡r❡ ✇❡ ❛s❦ ❢♦r t✇♦ ❡❧❡♠❡♥ts ♦❢ t❤❡ ✐♥✜♥✐t❡ s❡q✉❡♥❝❡✳ ■♥ ❢❛❝t✱ t❤r❡❡ ❡❧❡✲ ♠❡♥ts ❛r❡ ❝♦♠♣✉t❡❞✿ ✻✱ ✼ ❛♥❞ ✽✳ ❖✉r ✐♠♣❧❡♠❡♥t❛t✐♦♥ ✐s s❧✐❣❤t❧② t♦♦ ❡❛❣❡r✳ ❆ ♠♦r❡ ❝♦♠♣❧✐❝❛t❡❞ ❞❛t❛t②♣❡ ❞❡❝❧❛r❛t✐♦♥ ❝♦✉❧❞ ❛✈♦✐❞ t❤✐s ♣r♦❜❧❡♠✳ ❆♥♦t❤❡r ♣r♦❜❧❡♠ ✐s t❤❛t ✐❢ ♦♥❡ r❡♣❡❛t❡❞❧② ❡①❛♠✐♥❡s s♦♠❡ ♣❛rt✐❝✉❧❛r ❧✐st ❡❧❡♠❡♥t ✉s✐♥❣ ❢♦r❝✐♥❣✱ t❤❛t ❡❧❡♠❡♥t ✐s r❡♣❡❛t❡❞❧② ❡✈❛❧✉❛t❡❞✳ ■♥ ❛ ❧❛③② ♣r♦❣r❛♠♠✐♥❣ ❧❛♥✲ ❣✉❛❣❡✱ t❤❡ r❡s✉❧t ♦❢ t❤❡ ✜rst ❡✈❛❧✉❛t✐♦♥ ✇♦✉❧❞ ❜❡ st♦r❡❞ ❢♦r ❧❛t❡r r❡❢❡r❡♥❝❡✳ ❚♦ ❣❡t t❤❡ s❛♠❡ ❡✛❡❝t ✐♥ ▼▲ r❡q✉✐r❡s r❡❢❡r❡♥❝❡s ❬✶✸✱ ♣❛❣❡ ✸✷✼❪✳ ❲❡ s❤♦✉❧❞ ❜❡ ❣r❛t❡❢✉❧ t❤❛t t❤❡ ♣♦t❡♥t✐❛❧❧② ✐♥✜♥✐t❡ ❝♦♠♣✉t❛t✐♦♥ ✐s ❦❡♣t ✜♥✐t❡✳ ❚❤❡ t❛✐❧ ♦❢ t❤❡ ♦r✐❣✐♥❛❧ s❡q✉❡♥❝❡ ❡✈❡♥ ❝♦♥t❛✐♥s t❤❡ ✉♥❡✈❛❧✉❛t❡❞ ❡①✲ ♣r❡ss✐♦♥ ✻✰✶✳

❳■■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✸✹

Slide 1307

Joining Two Sequences

fun appendq (Nil, yq) = yq | appendq (Cons(x,xf), yq) = Cons(x, fn()=> appendq(xf(), yq));

A fair alternative. . .

fun interleave (Nil, yq) = yq | interleave (Cons(x,xf), yq) = Cons(x, fn()=> interleave(yq, xf()));

▼♦st ❧✐st ❢✉♥❝t✐♦♥s ❛♥❞ ❢✉♥❝t✐♦♥❛❧s ❤❛✈❡ ❛♥❛❧♦❣✉❡s ♦♥ s❡q✉❡♥❝❡s✱ ❜✉t str❛♥❣❡ t❤✐♥❣s ❝❛♥ ❤❛♣♣❡♥✳ ❈❛♥ ❛♥ ✐♥✜♥✐t❡ ❧✐st ❜❡ r❡✈❡rs❡❞❄ ❋✉♥❝t✐♦♥ ❛♣♣❡♥❞q ✐s ♣r❡❝✐s❡❧② t❤❡ s❛♠❡ ✐❞❡❛ ❛s ❛♣♣❡♥❞ ✭▲❡❝t✳ ✹✮✿ ✐t ❝♦♥✲ ❝❛t❡♥❛t❡s t✇♦ s❡q✉❡♥❝❡s✳ ■❢ t❤❡ ✜rst ❛r❣✉♠❡♥t ✐s ✐♥✜♥✐t❡✱ t❤❡♥ ❛♣♣❡♥❞q ♥❡✈❡r ❣❡ts t♦ ✐ts s❡❝♦♥❞ ❛r❣✉♠❡♥t✱ ✇❤✐❝❤ ✐s ❧♦st✳ ❈♦♥❝❛t❡♥❛t✐♦♥ ♦❢ ✐♥✜♥✐t❡ s❡q✉❡♥❝❡s ✐s ♥♦t t❡rr✐❜❧② ✐♥t❡r❡st✐♥❣✳ ❚❤❡ ❢✉♥❝t✐♦♥ ✐♥t❡r❧❡❛✈❡ ❛✈♦✐❞s t❤✐s ♣r♦❜❧❡♠ ❜② ❡①❝❤❛♥❣✐♥❣ t❤❡ t✇♦ ❛r❣✉♠❡♥ts ✐♥ ❡❛❝❤ r❡❝✉rs✐✈❡ ❝❛❧❧✳ ■t ❝♦♠❜✐♥❡s t❤❡ t✇♦ ❧❛③② ❧✐sts✱ ❧♦s✐♥❣ ♥♦ ❡❧❡♠❡♥ts✳ ■♥t❡r❧❡❛✈✐♥❣ ✐s t❤❡ r✐❣❤t ✇❛② t♦ ❝♦♠❜✐♥❡ t✇♦ ♣♦t❡♥t✐❛❧❧② ✐♥✜♥✐t❡ ✐♥❢♦r♠❛t✐♦♥ s♦✉r❝❡s ✐♥t♦ ♦♥❡✳ ■♥ ❜♦t❤ ❢✉♥❝t✐♦♥ ❞❡❝❧❛r❛t✐♦♥s✱ ♦❜s❡r✈❡ t❤❛t ❡❛❝❤ ①❢✭✮ ✐s ❡♥❝❧♦s❡❞ ✇✐t❤✐♥ ❛ ❢♥✭✮❂❃✳✳✳✳ ❊❛❝❤ ❢♦r❝❡ ✐s ❡♥❝❧♦s❡❞ ✇✐t❤✐♥ ❛ ❞❡❧❛②✳ ❚❤✐s ♣r❛❝t✐❝❡ ♠❛❦❡s t❤❡ ❢✉♥❝t✐♦♥s ❧❛③②✳ ❆ ❢♦r❝❡ ♥♦t ❡♥❝❧♦s❡❞ ✐♥ ❛ ❞❡❧❛②✱ ❛s ✐♥ ❣❡t ❛❜♦✈❡✱ r✉♥s t❤❡ r✐s❦ ♦❢ ❡✈❛❧✉❛t✐♥❣ t❤❡ s❡q✉❡♥❝❡ ✐♥ ❢✉❧❧✳

❳■■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✸✺

Slide 1308

Functionals for Lazy Lists

filtering

fun filterq p Nil = Nil | filterq p (Cons(x,xf)) = if p x then Cons(x, fn()=>filterq p (xf())) else filterq p (xf());

The infinite sequence x, f(x), f(f(x)),. . .

fun iterates f x = Cons(x, fn()=> iterates f (f x));

❚❤❡ ❢✉♥❝t✐♦♥❛❧ ❢✐❧t❡rq ❞❡♠❛♥❞s ❡❧❡♠❡♥ts ♦❢ ①q ✉♥t✐❧ ✐t ✜♥❞s ♦♥❡ s❛t✲ ✐s❢②✐♥❣ ♣✳ ✭❘❡❝❛❧❧ ❢✐❧t❡r✱ ▲❡❝t✳ ✶✶✳✮ ■t ❝♦♥t❛✐♥s ❛ ❢♦r❝❡ ♥♦t ♣r♦t❡❝t❡❞ ❜② ❛ ❞❡❧❛②✳ ■❢ ①q ✐s ✐♥✜♥✐t❡ ❛♥❞ ❝♦♥t❛✐♥s ♥♦ s❛t✐s❢❛❝t♦r② ❡❧❡♠❡♥t✱ t❤❡♥ ❢✐❧t❡rq r✉♥s ❢♦r❡✈❡r✳ ❚❤❡ ❢✉♥❝t✐♦♥❛❧ ✐t❡r❛t❡s ❣❡♥❡r❛❧✐③❡s ❢r♦♠✳ ■t ❝r❡❛t❡s t❤❡ ♥❡①t ❡❧❡♠❡♥t ♥♦t ❜② ❛❞❞✐♥❣ ♦♥❡ ❜✉t ❜② ❝❛❧❧✐♥❣ t❤❡ ❢✉♥❝t✐♦♥ ❢✳

❳■■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✸✻

Slide 1309

Numerical Computations on Infinite Sequences

fun next a x = (a/x + x) / 2.0;

Close enough?

fun within (eps:real) (Cons(x,xf)) = let val Cons(y,yf) = xf() in if abs(x-y) <= eps then y else within eps (Cons(y,yf)) end;

Square Roots!

fun root a = within 1E~6 (iterates (next a) 1.0)

❈❛❧❧✐♥❣ ✐t❡r❛t❡s ✭♥❡①t ❛✮ ①✵✮ ❣❡♥❡r❛t❡s t❤❡ ✐♥✜♥✐t❡ s❡r✐❡s ♦❢ ❛♣♣r♦①✲ ✐♠❛t✐♦♥s t♦ t❤❡ sq✉❛r❡ r♦♦t ♦❢ a ❢♦r t❤❡ ◆❡✇t♦♥✲❘❛♣❤s♦♥ ♠❡t❤♦❞✳ ❆s ❞✐s✲ ❝✉ss❡❞ ✐♥ ▲❡❝t✳ ✷✱ t❤❡ ✐♥✜♥✐t❡ s❡r✐❡s x0✱ (a + x0)/2✱ ✳ ✳ ✳ ❝♦♥✈❡r❣❡s t♦ √a✳ ❋✉♥❝t✐♦♥ ✇✐t❤✐♥ s❡❛r❝❤❡s ❞♦✇♥ t❤❡ ❧❛③② ❧✐st ❢♦r t✇♦ ♣♦✐♥ts ✇❤♦s❡ ❞✐✛❡r✲ ❡♥❝❡ ✐s ❧❡ss t❤❛♥ ❡♣s✳ ■t t❡sts t❤❡✐r ❛❜s♦❧✉t❡ ❞✐✛❡r❡♥❝❡✳ ❘❡❧❛t✐✈❡ ❞✐✛❡r❡♥❝❡ ❛♥❞ ♦t❤❡r ❵❝❧♦s❡ ❡♥♦✉❣❤✬ t❡sts ❝❛♥ ❜❡ ❝♦❞❡❞✳ ❙✉❝❤ ❝♦♠♣♦♥❡♥ts ❝❛♥ ❜❡ ✉s❡❞ t♦ ✐♠♣❧❡♠❡♥t ♦t❤❡r ♥✉♠❡r✐❝❛❧ ❢✉♥❝t✐♦♥s ❞✐r❡❝t❧② ❛s ❢✉♥❝t✐♦♥s ♦✈❡r s❡q✉❡♥❝❡s✳ ❚❤❡ ♣♦✐♥t ✐s t♦ ❜✉✐❧❞ ♣r♦❣r❛♠s ❢r♦♠ s♠❛❧❧✱ ✐♥t❡r❝❤❛♥❣❡❛❜❧❡ ♣❛rts✳ ❋✉♥❝t✐♦♥ r♦♦t ✉s❡s ✇✐t❤✐♥✱ ✐t❡r❛t❡s ❛♥❞ ♥❡①t t♦ ❛♣♣❧② t❤❡ ◆❡✇t♦♥✲ ❘❛♣❤s♦♥ ♠❡t❤♦❞ ✇✐t❤ ❛ t♦❧❡r❛♥❝❡ ♦❢ 10−6 ❛♥❞ ❛♥ ✭❛✇❢✉❧✮ ✐♥✐t✐❛❧ ❛♣♣r♦①✐♠❛✲ t✐♦♥ ♦❢ ✶✳✵✳ ❚❤✐s tr❡❛t♠❡♥t ♦❢ ♥✉♠❡r✐❝❛❧ ❝♦♠♣✉t❛t✐♦♥ ❤❛s r❡❝❡✐✈❡❞ s♦♠❡ ❛tt❡♥t✐♦♥ ✐♥ t❤❡ r❡s❡❛r❝❤ ❧✐t❡r❛t✉r❡❀ ❛ r❡❝✉rr✐♥❣ ❡①❛♠♣❧❡ ✐s ❘✐❝❤❛r❞s♦♥ ❡①tr❛♣♦❧❛t✐♦♥ ❬✼✱ ✽❪✳

❳■■■ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✸✼ ▲❡❛r♥✐♥❣ ❣✉✐❞❡✳ ❘❡❧❛t❡❞ ♠❛t❡r✐❛❧ ✐s ✐♥ ▼▲ ❢♦r t❤❡ ❲♦r❦✐♥❣ Pr♦❣r❛♠♠❡r✱ ♣❛❣❡s ✶✾✶✕✷✶✷✳ ❊①❡r❝✐s❡ ✶✸✳✶ ❈♦❞❡ ❛♥ ❛♥❛❧♦❣✉❡ ♦❢ ♠❛♣ ❢♦r s❡q✉❡♥❝❡s✳ ❊①❡r❝✐s❡ ✶✸✳✷ ❈♦♥s✐❞❡r t❤❡ ❧✐st ❢✉♥❝t✐♦♥ ❝♦♥❝❛t✱ ✇❤✐❝❤ ❝♦♥❝❛t❡♥❛t❡s ❛ ❧✐st ♦❢ ❧✐sts t♦ ❢♦r♠ ❛ s✐♥❣❧❡ ❧✐st✳ ❈❛♥ ✐t ❜❡ ❣❡♥❡r❛❧✐③❡❞ t♦ ❝♦♥❝❛t❡♥❛t❡ ❛ s❡q✉❡♥❝❡ ♦❢ s❡q✉❡♥❝❡s❄ ❲❤❛t ❝❛♥ ❣♦ ✇r♦♥❣❄

❢✉♥ ❝♦♥❝❛t ❬❪ ❂ ❬❪ ⑤ ❝♦♥❝❛t ✭❧✿✿❧s✮ ❂ ❧ ❅ ❝♦♥❝❛t ❧s❀

❊①❡r❝✐s❡ ✶✸✳✸ ❈♦❞❡ ❛ ❢✉♥❝t✐♦♥ t♦ ♠❛❦❡ ❝❤❛♥❣❡ ✉s✐♥❣ ❧❛③② ❧✐sts✳ ✭❚❤✐s ✐s ❞✐✣❝✉❧t✳✮

❳■❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✸✽

Slide 1401

Procedural Programming

Procedural programs can change the machine state. They can interact with its environment. They use control structures like branching, iteration and procedures. They use data abstractions of the computer’s memory:

• references to memory cells
• arrays: blocks of memory cells
• pointer structures and linked lists (next lecture)

Pr♦❝❡❞✉r❛❧ ♣r♦❣r❛♠♠✐♥❣ ✐s ♣r♦❣r❛♠♠✐♥❣ ✐♥ t❤❡ tr❛❞✐t✐♦♥❛❧ s❡♥s❡ ♦❢ t❤❡ ✇♦r❞✳ ❆ ♣r♦❣r❛♠ st❛t❡ ✐s r❡♣❡❛t❡❞❧② tr❛♥s❢♦r♠❡❞ ❜② t❤❡ ❡①❡❝✉t✐♦♥ ♦❢ ❝♦♠✲ ♠❛♥❞s ♦r st❛t❡♠❡♥ts✳ ❆ st❛t❡ ❝❤❛♥❣❡ ♠✐❣❤t ❜❡ ❧♦❝❛❧ t♦ t❤❡ ♠❛❝❤✐♥❡ ❛♥❞ ❝♦♥s✐st ♦❢ ✉♣❞❛t✐♥❣ ❛ ✈❛r✐❛❜❧❡ ♦r ❛rr❛②✳ ❆ st❛t❡ ❝❤❛♥❣❡ ♠✐❣❤t ❝♦♥s✐st ♦❢ s❡♥❞✐♥❣ ❞❛t❛ t♦ t❤❡ ♦✉ts✐❞❡ ✇♦r❧❞✳ ❊✈❡♥ r❡❛❞✐♥❣ ❞❛t❛ ❝♦✉♥ts ❛s ❛ st❛t❡ ❝❤❛♥❣❡✱ s✐♥❝❡ t❤✐s ❛❝t ♥♦r♠❛❧❧② r❡♠♦✈❡s t❤❡ ❞❛t❛ ❢r♦♠ t❤❡ ❡♥✈✐r♦♥♠❡♥t✳ Pr♦❝❡❞✉r❛❧ ♣r♦❣r❛♠♠✐♥❣ ❧❛♥❣✉❛❣❡s ♣r♦✈✐❞❡ ♣r✐♠✐t✐✈❡ ❝♦♠♠❛♥❞s ❛♥❞ ❝♦♥✲ tr♦❧ str✉❝t✉r❡s ❢♦r ❝♦♠❜✐♥✐♥❣ t❤❡♠✳ ❚❤❡ ♣r✐♠✐t✐✈❡ ❝♦♠♠❛♥❞s ✐♥❝❧✉❞❡ ❛s✲ s✐❣♥♠❡♥t✱ ❢♦r ✉♣❞❛t✐♥❣ ✈❛r✐❛❜❧❡s✱ ❛♥❞ ✈❛r✐♦✉s ✐♥♣✉t✴♦✉t♣✉t ❝♦♠♠❛♥❞s ❢♦r ❝♦♠♠✉♥✐❝❛t✐♦♥✳ ❈♦♥tr♦❧ str✉❝t✉r❡s ✐♥❝❧✉❞❡ ✐❢ ❛♥❞ ❝❛s❡ ❝♦♥str✉❝ts ❢♦r ❝♦♥✲ ❞✐t✐♦♥❛❧ ❡①❡❝✉t✐♦♥✱ ❛♥❞ r❡♣❡t✐t✐✈❡ ❝♦♥str✉❝ts s✉❝❤ ❛s ✇❤✐❧❡✳ Pr♦❣r❛♠♠❡rs ❝❛♥ ♣❛❝❦❛❣❡ ✉♣ t❤❡✐r ♦✇♥ ❝♦♠♠❛♥❞s ❛s ♣r♦❝❡❞✉r❡s t❛❦✐♥❣ ❛r❣✉♠❡♥ts✳ ❚❤❡ ♥❡❡❞ ❢♦r s✉❝❤ ❵s✉❜r♦✉t✐♥❡s✬ ✇❛s ❡✈✐❞❡♥t ❢r♦♠ t❤❡ ❡❛r❧✐❡st ❞❛②s ♦❢ ❝♦♠♣✉t✲ ✐♥❣❀ t❤❡② r❡♣r❡s❡♥t ♦♥❡ ♦❢ t❤❡ ✜rst ❡①❛♠♣❧❡s ♦❢ ❛❜str❛❝t✐♦♥ ✐♥ ♣r♦❣r❛♠♠✐♥❣ ❧❛♥❣✉❛❣❡s✳ ▼▲ ♠❛❦❡s ♥♦ ❞✐st✐♥❝t✐♦♥ ❜❡t✇❡❡♥ ❝♦♠♠❛♥❞s ❛♥❞ ❡①♣r❡ss✐♦♥s✳ ▼▲ ♣r♦✲ ✈✐❞❡s ❜✉✐❧t✲✐♥ ❢✉♥❝t✐♦♥s t♦ ♣❡r❢♦r♠ ❛ss✐❣♥♠❡♥t ❛♥❞ ❝♦♠♠✉♥✐❝❛t✐♦♥✳ ❚❤❡② ♠❛② ❜❡ ✉s❡❞ ✇✐t❤ ✐❢ ❛♥❞ ❝❛s❡ ♠✉❝❤ ❛s ✐♥ ❝♦♥✈❡♥t✐♦♥❛❧ ❧❛♥❣✉❛❣❡s✳ ▼▲ ❢✉♥❝✲ t✐♦♥s ♣❧❛② t❤❡ r♦❧❡ ♦❢ ♣r♦❝❡❞✉r❡s✳ ▼▲ ♣r♦❣r❛♠♠❡rs ♥♦r♠❛❧❧② ❢♦❧❧♦✇ ❛ ❢✉♥❝✲ t✐♦♥❛❧ st②❧❡ ❢♦r ♠♦st ✐♥t❡r♥❛❧ ❝♦♠♣✉t❛t✐♦♥s ❛♥❞ ✉s❡ ✐♠♣❡r❛t✐✈❡ ❢❡❛t✉r❡s ♦♥❧② ❢♦r ❝♦♠♠✉♥✐❝❛t✐♦♥ ✇✐t❤ t❤❡ ♦✉ts✐❞❡ ✇♦r❧❞✳

❳■❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✸✾

Slide 1402

ML Primitives for References τ ref

type of references to type τ

ref E

create a reference initial contents = the value of E

!P

return the current contents of reference P

P := E

update the contents of P to the value of E

❚❤❡ s❧✐❞❡ ♣r❡s❡♥ts t❤❡ ▼▲ ♣r✐♠✐t✐✈❡s✱ ❜✉t ♠♦st ❧❛♥❣✉❛❣❡s ❤❛✈❡ ❛♥❛❧♦❣✉❡s ♦❢ t❤❡♠✱ ♦❢t❡♥ ❤❡❛✈✐❧② ❞✐s❣✉✐s❡❞✳ ❲❡ ♥❡❡❞ ❛ ♠❡❛♥s ♦❢ ❝r❡❛t✐♥❣ r❡❢❡r❡♥❝❡s ✭♦r ❛❧❧♦❝❛t✐♥❣ st♦r❛❣❡✮✱ ❣❡tt✐♥❣ ❛t t❤❡ ❝✉rr❡♥t ❝♦♥t❡♥ts ♦❢ ❛ r❡❢❡r❡♥❝❡ ❝❡❧❧✱ ❛♥❞ ✉♣❞❛t✐♥❣ t❤❛t ❝❡❧❧✳ ❚❤❡ ❢✉♥❝t✐♦♥ r❡❢ ❝r❡❛t❡s r❡❢❡r❡♥❝❡s ✭❛❧s♦ ❝❛❧❧❡❞ ♣♦✐♥t❡rs ♦r ❧♦❝❛t✐♦♥s✮✳ ❈❛❧❧✐♥❣ r❡❢ ❛❧❧♦❝❛t❡s ❛ ♥❡✇ ❧♦❝❛t✐♦♥ ✐♥ t❤❡ ♠❛❝❤✐♥❡ st♦r❡✳ ■♥✐t✐❛❧❧②✱ t❤✐s ❧♦❝❛✲ t✐♦♥ ❤♦❧❞s t❤❡ ✈❛❧✉❡ ❣✐✈❡♥ ❜② ❡①♣r❡ss✐♦♥ E✳ ❆❧t❤♦✉❣❤ r❡❢ ✐s ❛♥ ▼▲ ❢✉♥❝t✐♦♥✱ ✐t ✐s ♥♦t ❛ ❢✉♥❝t✐♦♥ ✐♥ t❤❡ ♠❛t❤❡♠❛t✐❝❛❧ s❡♥s❡✳ ❋♦r ❡①❛♠♣❧❡✱ r❡❢✭✵✮❂r❡❢✭✵✮ ❡✈❛❧✉❛t❡s t♦ ❢❛❧s❡✳ ❚❤❡ ❢✉♥❝t✐♦♥ ✦✱ ✇❤❡♥ ❛♣♣❧✐❡❞ t♦ ❛ r❡❢❡r❡♥❝❡✱ r❡t✉r♥s ✐ts ❝♦♥t❡♥ts✳ ❚❤✐s ♦♣❡r❛t✐♦♥ ✐s ❝❛❧❧❡❞ ❞❡r❡❢❡r❡♥❝✐♥❣✳ ❈❧❡❛r❧② ✦ ✐s ♥♦t ❛ ♠❛t❤❡♠❛t✐❝❛❧ ❢✉♥❝t✐♦♥❀ ✐ts r❡s✉❧t ❞❡♣❡♥❞s ✉♣♦♥ t❤❡ st♦r❡✳ ❚❤❡ ❛ss✐❣♥♠❡♥t P✿❂E ❡✈❛❧✉❛t❡s ❡①♣r❡ss✐♦♥ P✱ ✇❤✐❝❤ ♠✉st r❡t✉r♥ ❛ r❡❢✲ ❡r❡♥❝❡ p✱ ❛♥❞ E✳ ■t st♦r❡s ❛t ❛❞❞r❡ss p t❤❡ ✈❛❧✉❡ ♦❢ E✳ ❙②♥t❛❝t✐❝❛❧❧②✱ ✿❂ ✐s ❛ ❢✉♥❝t✐♦♥ ❛♥❞ P✿❂E ✐s ❛♥ ❡①♣r❡ss✐♦♥✱ ❡✈❡♥ t❤♦✉❣❤ ✐t ✉♣❞❛t❡s t❤❡ st♦r❡✳ ▲✐❦❡ ♠❛♥② ❢✉♥❝t✐♦♥s t❤❛t ❝❤❛♥❣❡ t❤❡ st❛t❡✱ ✐t r❡t✉r♥s t❤❡ ✈❛❧✉❡ ✭✮ ♦❢ t②♣❡ unit✳ ■❢ τ ✐s s♦♠❡ ▼▲ t②♣❡✱ t❤❡♥ τ r❡❢ ✐s t❤❡ t②♣❡ ♦❢ r❡❢❡r❡♥❝❡s t♦ ❝❡❧❧s t❤❛t ❝❛♥ ❤♦❧❞ ✈❛❧✉❡s ♦❢ τ✳ P❧❡❛s❡ ❞♦ ♥♦t ❝♦♥❢✉s❡ t❤❡ t②♣❡ r❡❢ ✇✐t❤ t❤❡ ❢✉♥❝t✐♦♥ r❡❢✳ ❚❤✐s t❛❜❧❡ ♦❢ t❤❡ ♣r✐♠✐t✐✈❡ ❢✉♥❝t✐♦♥s ❛♥❞ t❤❡✐r t②♣❡s ♠✐❣❤t ❜❡ ✉s❡❢✉❧✿ r❡❢ ✬❛ ✲❃ ✬❛ r❡❢ ✦ ✬❛ r❡❢ ✲❃ ✬❛ ♦♣ ✿❂ ✬❛ r❡❢ ✯ ✬❛ ✲❃ ✉♥✐t

❳■❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✹✵

Slide 1403

A Simple Session

val p = ref 5;

create a reference

> val p = ref 5 : int ref p := !p + 1;

now p holds 6

val ps = [ref 77, p]; > val ps = [ref 77, ref 6] : int ref list hd ps := 3;

updating an integer ref

ps;

contents of the refs?

> val it = [ref 3, ref 6] : int ref list

❚❤❡ ✜rst ❧✐♥❡ ❞❡❝❧❛r❡s ♣ t♦ ❤♦❧❞ ❛ r❡❢❡r❡♥❝❡ t♦ ❛♥ ✐♥t❡❣❡r✱ ✐♥✐t✐❛❧❧② ✺✳ ■ts t②♣❡ ✐s ✐♥t r❡❢✱ ♥♦t ❥✉st ✐♥t✱ s♦ ✐t ❛❞♠✐ts ❛ss✐❣♥♠❡♥t✳ ❆ss✐❣♥♠❡♥t ♥❡✈❡r ❝❤❛♥❣❡s ✈❛❧ ❜✐♥❞✐♥❣s✿ t❤❡② ❛r❡ ✐♠♠✉t❛❜❧❡✳ ❚❤❡ ✐❞❡♥t✐✜❡r ♣ ✇✐❧❧ ❛❧✇❛②s ❞❡♥♦t❡ t❤❡ r❡❢❡r❡♥❝❡ ♠❡♥t✐♦♥❡❞ ✐♥ ✐ts ❞❡❝❧❛r❛t✐♦♥ ✉♥❧❡ss s✉♣❡rs❡❞❡❞ ❜② ❛ ♥❡✇ ✉s❛❣❡ ♦❢ ♣✳ ❖♥❧② t❤❡ ❝♦♥t❡♥ts ♦❢ t❤❡ r❡❢❡r❡♥❝❡ ✐s ♠✉t❛❜❧❡✳ ▼▲ ❞✐s♣❧❛②s ❛ r❡❢❡r❡♥❝❡ ✈❛❧✉❡ ❛s r❡❢ v✱ ✇❤❡r❡ ✈❛❧✉❡ v ✐s t❤❡ ❝♦♥t❡♥ts✳ ❚❤✐s ♥♦t❛t✐♦♥ ✐s r❡❛❞❛❜❧❡ ❜✉t ❣✐✈❡s ✉s ♥♦ ✇❛② ♦❢ t❡❧❧✐♥❣ ✇❤❡t❤❡r t✇♦ r❡❢❡r❡♥❝❡s ❤♦❧❞✐♥❣ t❤❡ s❛♠❡ ✈❛❧✉❡ ❛r❡ ❛❝t✉❛❧❧② t❤❡ s❛♠❡ r❡❢❡r❡♥❝❡✳ ❚♦ ❞✐s♣❧❛② ❛ r❡❢❡r❡♥❝❡ ❛s ❛ ♠❛❝❤✐♥❡ ❛❞❞r❡ss ❤❛s ♦❜✈✐♦✉s ❞r❛✇❜❛❝❦s✦ ■♥ t❤❡ ✜rst ❛ss✐❣♥♠❡♥t✱ t❤❡ ❡①♣r❡ss✐♦♥ ✦♣ ②✐❡❧❞s t❤❡ r❡❢❡r❡♥❝❡✬s ❝✉rr❡♥t ❝♦♥t❡♥ts✱ ♥❛♠❡❧② ✺✳ ❚❤❡ ❛ss✐❣♥♠❡♥t ❝❤❛♥❣❡s t❤❡ ❝♦♥t❡♥ts ♦❢ ♣ t♦ ✻✳ ▼♦st ❧❛♥❣✉❛❣❡s ❞♦ ♥♦t ❤❛✈❡ ❛♥ ❡①♣❧✐❝✐t ❞❡r❡❢❡r❡♥❝✐♥❣ ♦♣❡r❛t♦r ✭❧✐❦❡ ✦✮ ❜❡❝❛✉s❡ ♦❢ ✐ts ✐♥❝♦♥✈❡♥✐❡♥❝❡✳ ■♥st❡❛❞✱ ❜② ❝♦♥✈❡♥t✐♦♥✱ ♦❝❝✉rr❡♥❝❡s ♦❢ t❤❡ r❡❢❡r❡♥❝❡ t❤❡ ❧❡❢t✲❤❛♥❞ s✐❞❡ ♦❢ t❤❡ ✿❂ ❞❡♥♦t❡ ❧♦❝❛t✐♦♥s ❛♥❞ t❤♦s❡ ♦♥ t❤❡ r✐❣❤t✲❤❛♥❞ s✐❞❡ ❞❡♥♦t❡ t❤❡ ❝♦♥t❡♥ts✳ ❆ s♣❡❝✐❛❧ ❵❛❞❞r❡ss ♦❢✬ ♦♣❡r❛t♦r ♠❛② ❜❡ ❛✈❛✐❧❛❜❧❡ t♦ ♦✈❡rr✐❞❡ t❤❡ ❝♦♥✈❡♥t✐♦♥ ❛♥❞ ♠❛❦❡ ❛ r❡❢❡r❡♥❝❡ ♦♥ t❤❡ r✐❣❤t✲❤❛♥❞ s✐❞❡ t♦ ❞❡♥♦t❡ ❛ ❧♦❝❛t✐♦♥✳ ▲♦❣✐❝❛❧❧②✱ t❤✐s ✐s ❛ ♠❡ss✱ ❜✉t ✐t ♠❛❦❡s ♣r♦❣r❛♠s s❤♦rt❡r✳ ❚❤❡ ❧✐st ♣s ✐s ❞❡❝❧❛r❡❞ t♦ ❤♦❧❞ ❛ ♥❡✇ r❡❢❡r❡♥❝❡ ✭✐♥✐t✐❛❧❧② ❝♦♥t❛✐♥✐♥❣ ✼✼✮ ❛s ✇❡❧❧ ❛s ♣✳ ❚❤❡♥ t❤❡ ♥❡✇ r❡❢❡r❡♥❝❡ ✐s ✉♣❞❛t❡❞ t♦ ❤♦❧❞ ✸✳ ❚❤❡ ❛ss✐❣♥♠❡♥t t♦ ❤❞ ♣s ❞♦❡s ♥♦t ✉♣❞❛t❡ ♣s✱ ♦♥❧② t❤❡ ❝♦♥t❡♥ts ♦❢ ❛ r❡❢❡r❡♥❝❡ ✐♥ t❤❛t ❧✐st✳

❳■❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✹✶

Slide 1404

Iteration: the while Command

while B do C

fun length xs = let val lp = ref xs

list of uncounted elements

and np = ref 0

accumulated count

in while not (null (!lp)) do (lp := tl (!lp); np := 1 + !np); !np

value returned

end;

❖♥❝❡ ✇❡ ❝❛♥ ❝❤❛♥❣❡ t❤❡ st❛t❡✱ ✇❡ ♥❡❡❞ t♦ ❞♦ s♦ r❡♣❡❛t❡❞❧②✳ ❘❡❝✉rs✐♦♥ ❝❛♥ s❡r✈❡ t❤✐s ♣✉r♣♦s❡✱ ❜✉t ❤❛✈✐♥❣ t♦ ❞❡❝❧❛r❡ ❛ ♣r♦❝❡❞✉r❡ ❢♦r ❡✈❡r② ❧♦♦♣ ✐s ❝❧✉♠s②✱ ❛♥❞ ❝♦♠♣✐❧❡rs ❢♦r ❝♦♥✈❡♥t✐♦♥❛❧ ❧❛♥❣✉❛❣❡s s❡❧❞♦♠ ❡①♣❧♦✐t t❛✐❧✲r❡❝✉rs✐♦♥✳ ❊❛r❧② ♣r♦❣r❛♠♠✐♥❣ ❧❛♥❣✉❛❣❡s ♣r♦✈✐❞❡❞ ❧✐tt❧❡ s✉♣♣♦rt ❢♦r r❡♣❡t✐t✐♦♥✳ ❚❤❡ ♣r♦❣r❛♠♠❡r ❤❛❞ t♦ s❡t ✉♣ ❧♦♦♣s ✉s✐♥❣ ❣♦t♦ ❝♦♠♠❛♥❞s✱ ❡①✐t✐♥❣ t❤❡ ❧♦♦♣ ✉s✐♥❣ ❛♥♦t❤❡r ❣♦t♦ ❝♦♥tr♦❧❧❡❞ ❜② ❛♥ ✐❢✳ ▼♦❞❡r♥ ❧❛♥❣✉❛❣❡s ♣r♦✈✐❞❡ ❛ ❝♦♥❢✉s✐♥❣ ❥✉♠✲ ❜❧❡ ♦❢ ❧♦♦♣✐♥❣ ❝♦♥str✉❝ts✱ t❤❡ ♠♦st ❢✉♥❞❛♠❡♥t❛❧ ♦❢ ✇❤✐❝❤ ✐s ✇❤✐❧❡ B ❞♦ C✳ ❚❤❡ ❜♦♦❧❡❛♥ ❡①♣r❡ss✐♦♥ B ✐s ❡✈❛❧✉❛t❡❞✱ ❛♥❞ ✐❢ tr✉❡✱ ❝♦♠♠❛♥❞ C ✐s ❡①❡❝✉t❡❞ ❛♥❞ t❤❡ ❝♦♠♠❛♥❞ r❡♣❡❛ts✳ ■❢ B ❡✈❛❧✉❛t❡s t♦ ❢❛❧s❡ t❤❡♥ t❤❡ ✇❤✐❧❡ ❝♦♠♠❛♥❞ t❡r♠✐♥❛t❡s✱ ♣❡r❤❛♣s ✇✐t❤♦✉t ❡①❡❝✉t✐♥❣ C ❡✈❡♥ ♦♥❝❡✳ ▼▲✬s ♦♥❧② ❧♦♦♣✐♥❣ ❝♦♥str✉❝t ✐s ✇❤✐❧❡✱ ✇❤✐❝❤ r❡t✉r♥s t❤❡ ✈❛❧✉❡ ✭✮✳ ❆❧s♦ ✐♠♣♦rt❛♥t ✐s t❤❡ ❝♦♥str✉❝t ✭E1❀✳✳✳❀En✮✱ ✇❤✐❝❤ ❡✈❛❧✉❛t❡s t❤❡ ❡①♣r❡ss✐♦♥s E1 t♦ En ✐♥ t❤❡ ♦r❞❡r ❣✐✈❡♥ ❛♥❞ r❡t✉r♥s t❤❡ ✈❛❧✉❡ ♦❢ En✳ ❚❤❡ ✈❛❧✉❡s ♦❢ t❤❡ ♦t❤❡r ❡①♣r❡ss✐♦♥s ❛r❡ ❞✐s❝❛r❞❡❞❀ t❤❡✐r ♣✉r♣♦s❡ ✐s t♦ ❝❤❛♥❣❡ t❤❡ st❛t❡✳ ❚❤❡ ❢✉♥❝t✐♦♥ ❧❡♥❣t❤ ❞❡❝❧❛r❡s r❡❢❡r❡♥❝❡s t♦ ❤♦❧❞ t❤❡ ❧✐st ✉♥❞❡r ❡①❛♠✐♥❛t✐♦♥ ✭❧♣✮ ❛♥❞ ♥✉♠❜❡r ♦❢ ❡❧❡♠❡♥ts ❝♦✉♥t❡❞ s♦ ❢❛r ✭♥♣✮✳ ❲❤✐❧❡ t❤❡ ❧✐st ✐s ♥♦♥✲❡♠♣t②✱ ✇❡ s❦✐♣ ♦✈❡r ♦♥❡ ♠♦r❡ ❡❧❡♠❡♥t ✭❜② s❡tt✐♥❣ ✐t t♦ ✐ts t❛✐❧✮ ❛♥❞ ❝♦✉♥t t❤❛t ❡❧❡♠❡♥t✳ ❚❤❡ ❜♦❞② ♦❢ t❤❡ ✇❤✐❧❡ ❧♦♦♣ ❛❜♦✈❡ ❝♦♥s✐sts ♦❢ t✇♦ ❛ss✐❣♥♠❡♥t ❝♦♠♠❛♥❞s✱ ❡①❡❝✉t❡❞ ♦♥❡ ❛❢t❡r t❤❡ ♦t❤❡r✳ ❚❤❡ ✇❤✐❧❡ ❝♦♠♠❛♥❞ ✐s ❢♦❧❧♦✇❡❞ ❜② t❤❡ ❡①♣r❡s✲ s✐♦♥ ✦♥♣ t♦ r❡t✉r♥ ❝♦♠♣✉t❡❞ ❧❡♥❣t❤ ❛s t❤❡ ❢✉♥❝t✐♦♥✬s r❡s✉❧t✳ ❚❤✐s s❡♠✐❝♦❧♦♥ ♥❡❡❞ ♥♦t ❜❡ ❡♥❝❧♦s❡❞ ✐♥ ♣❛r❡♥t❤❡s❡s ❜❡❝❛✉s❡ ✐t ✐s ❜r❛❝❦❡t❡❞ ❜② ✐♥ ❛♥❞ ❡♥❞✳

❳■❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✹✷

Slide 1405

Private, Persistent References

fun makeAccount (initBalance: int) = let val balance = ref initBalance fun withdraw amt = if amt > !balance then !balance else (balance := !balance - amt; !balance) in withdraw end; > val makeAccount = fn : int -> (int -> int)

❆s ②♦✉ ♠❛② ❤❛✈❡ ♥♦t✐❝❡❞✱ ▼▲✬s ♣r♦❣r❛♠♠✐♥❣ st②❧❡ ❧♦♦❦s ❝❧✉♠s② ❝♦♠✲ ♣❛r❡❞ ✇✐t❤ t❤❛t ♦❢ ❧❛♥❣✉❛❣❡s ❧✐❦❡ ❈✳ ▼▲ ♦♠✐ts t❤❡ ❞❡❢❛✉❧ts ❛♥❞ ❛❜❜r❡✈✐❛✲ t✐♦♥s t❤❡② ♣r♦✈✐❞❡ t♦ s❤♦rt❡♥ ♣r♦❣r❛♠s✳ ❍♦✇❡✈❡r✱ ▼▲✬s ❡①♣❧✐❝✐t♥❡ss ♠❛❦❡s ✐t ✐❞❡❛❧ ❢♦r t❡❛❝❤✐♥❣ t❤❡ ✜♥❡ ♣♦✐♥ts ♦❢ r❡❢❡r❡♥❝❡s ❛♥❞ ❛rr❛②s✳ ▼▲✬s r❡❢❡r❡♥❝❡s ❛r❡ ♠♦r❡ ✢❡①✐❜❧❡ t❤❛♥ t❤♦s❡ ❢♦✉♥❞ ✐♥ ♦t❤❡r ❧❛♥❣✉❛❣❡s✳ ❚❤❡ ❢✉♥❝t✐♦♥ ♠❛❦❡❆❝❝♦✉♥t ♠♦❞❡❧s ❛ ❜❛♥❦✳ ❈❛❧❧✐♥❣ t❤❡ ❢✉♥❝t✐♦♥ ✇✐t❤ ❛ s♣❡❝✐✜❡❞ ✐♥✐t✐❛❧ ❜❛❧❛♥❝❡ ❝r❡❛t❡s ❛ ♥❡✇ r❡❢❡r❡♥❝❡ ✭❜❛❧❛♥❝❡✮ t♦ ♠❛✐♥t❛✐♥ t❤❡ ❛❝❝♦✉♥t ❜❛❧❛♥❝❡ ❛♥❞ r❡t✉r♥s ❛ ❢✉♥❝t✐♦♥ ✭✇✐t❤❞r❛✇✮ ❤❛✈✐♥❣ s♦❧❡ ❛❝❝❡ss t♦ t❤❛t r❡❢❡r❡♥❝❡✳ ❈❛❧❧✐♥❣ ✇✐t❤❞r❛✇ r❡❞✉❝❡s t❤❡ ❜❛❧❛♥❝❡ ❜② t❤❡ s♣❡❝✐✜❡❞ ❛♠♦✉♥t ❛♥❞ r❡t✉r♥s t❤❡ ♥❡✇ ❜❛❧❛♥❝❡✳ ❨♦✉ ❝❛♥ ♣❛② ♠♦♥❡② ✐♥ ❜② ✇✐t❤❞r❛✇✐♥❣ ❛ ♥❡❣❛t✐✈❡ ❛♠♦✉♥t✳ ❚❤❡ ✐❢✲❝♦♥str✉❝t ♣r❡✈❡♥ts t❤❡ ❛❝❝♦✉♥t ❢r♦♠ ❣♦✐♥❣ ♦✈❡r❞r❛✇♥ ✭✐t ❝♦✉❧❞ r❛✐s❡ ❛♥ ❡①❝❡♣t✐♦♥✮✳ ▲♦♦❦ ❛t t❤❡ ✭E1❀ E2✮ ❝♦♥str✉❝t ✐♥ t❤❡ ❡❧s❡ ♣❛rt ❛❜♦✈❡✳ ❚❤❡ ✜rst ❡①♣r❡s✲ s✐♦♥ ✉♣❞❛t❡s t❤❡ ❛❝❝♦✉♥t ❜❛❧❛♥❝❡ ❛♥❞ r❡t✉r♥s t❤❡ tr✐✈✐❛❧ ✈❛❧✉❡ ✭✮✳ ❚❤❡ s❡❝♦♥❞ ❡①♣r❡ss✐♦♥✱ ✦❜❛❧❛♥❝❡✱ r❡t✉r♥s t❤❡ ❝✉rr❡♥t ❜❛❧❛♥❝❡ ❜✉t ❞♦❡s ♥♦t r❡t✉r♥ t❤❡ r❡❢❡r❡♥❝❡ ✐ts❡❧❢✿ t❤❛t ✇♦✉❧❞ ❛❧❧♦✇ ✉♥❛✉t❤♦r✐③❡❞ ✉♣❞❛t❡s✳ ❚❤✐s ❡①❛♠♣❧❡ ✐s ❜❛s❡❞ ♦♥ ♦♥❡ ❜② ❉r ❆ ❈ ◆♦r♠❛♥✳

❳■❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✹✸

Slide 1406

Two Bank Accounts

val student = makeAccount 500; > val student = fn : int -> int val director = makeAccount 400000; > val director = fn : int -> int student 5; (*coach fare*) > val it = 495 : int director 50000; (*Jaguar*) > val it = 350000 : int

❊❛❝❤ ❝❛❧❧ t♦ ♠❛❦❡❆❝❝♦✉♥t r❡t✉r♥s ❛ ❝♦♣② ♦❢ ✇✐t❤❞r❛✇ ❤♦❧❞✐♥❣ ❛ ❢r❡s❤ ✐♥✲ st❛♥❝❡ ♦❢ t❤❡ r❡❢❡r❡♥❝❡ ❜❛❧❛♥❝❡✳ ❆s ✇✐t❤ ❛ r❡❛❧ ❜❛♥❦ ♣❛ss✲❜♦♦❦✱ t❤❡r❡ ✐s ♥♦ ❛❝❝❡ss t♦ t❤❡ ❛❝❝♦✉♥t ❜❛❧❛♥❝❡ ❡①❝❡♣t ✈✐❛ t❤❡ ❝♦rr❡s♣♦♥❞✐♥❣ ✇✐t❤❞r❛✇ ❢✉♥❝✲ t✐♦♥✳ ■❢ t❤❛t ❢✉♥❝t✐♦♥ ✐s ❞✐s❝❛r❞❡❞✱ t❤❡ r❡❢❡r❡♥❝❡ ❝❡❧❧ ❜❡❝♦♠❡s ✉♥r❡❛❝❤❛❜❧❡❀ t❤❡ ❝♦♠♣✉t❡r ✇✐❧❧ ❡✈❡♥t✉❛❧❧② r❡❝❧❛✐♠ ✐t✱ ❥✉st ❛s ❜❛♥❦s ❝❧♦s❡ ❞♦✇♥ ❞♦r♠❛♥t ❛❝❝♦✉♥ts✳ ❍❡r❡ ✇❡ s❡❡ t✇♦ ♣❡♦♣❧❡ ♠❛♥❛❣✐♥❣ t❤❡✐r ❛❝❝♦✉♥ts✳ ❋♦r ❜❡tt❡r ♦r ✇♦rs❡✱ ♥❡✐t❤❡r ❝❛♥ t❛❦❡ ♠♦♥❡② ❢r♦♠ t❤❡ ♦t❤❡r✳ ❲❡ ❝♦✉❧❞ ❣❡♥❡r❛❧✐③❡ ♠❛❦❡❆❝❝♦✉♥t t♦ r❡t✉r♥ s❡✈❡r❛❧ ❢✉♥❝t✐♦♥s t❤❛t ❥♦✐♥t❧② ♠❛♥❛❣❡ ✐♥❢♦r♠❛t✐♦♥ ❤❡❧❞ ✐♥ s❤❛r❡❞ r❡❢❡r❡♥❝❡s✳ ❚❤❡ ❢✉♥❝t✐♦♥s ♠✐❣❤t ❜❡ ♣❛❝❦✲ ❛❣❡❞ ✉s✐♥❣ ▼▲ r❡❝♦r❞s✱ ✇❤✐❝❤ ❛r❡ ❞✐s❝✉ss❡❞ ❡❧s❡✇❤❡r❡ ❬✶✸✱ ♣❛❣❡s ✸✷✕✸✻❪✳ ▼♦st ♣r♦❝❡❞✉r❛❧ ❧❛♥❣✉❛❣❡s ❞♦ ♥♦t ♣r♦♣❡r❧② s✉♣♣♦rt t❤❡ ❝♦♥❝❡♣t ♦❢ ♣r✐✈❛t❡ r❡❢❡r❡♥❝❡s✱ ❛❧t❤♦✉❣❤ ♦❜❥❡❝t✲♦r✐❡♥t❡❞ ❧❛♥❣✉❛❣❡s t❛❦❡ t❤❡♠ ❛s ❛ ❜❛s✐❝ t❤❡♠❡✳

❳■❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✹✹

Slide 1407

Variables: ML Versus Conventional Languages

The need to write !p to get at the contents of p The ability to write just p for the address of p The ability to store a private reference cells (like balance) in functions—simulating object-oriented programming Assignment syntax V

:= E instead of V = E

The dearth of useful control structures: only while and case

❈♦♥✈❡♥t✐♦♥❛❧ s②♥t❛① ❢♦r ✈❛r✐❛❜❧❡s ❛♥❞ ❛ss✐❣♥♠❡♥ts ❤❛s ❤❛r❞❧② ❝❤❛♥❣❡❞ s✐♥❝❡ ❋♦rtr❛♥✱ t❤❡ ✜rst ❤✐❣❤✲❧❡✈❡❧ ❧❛♥❣✉❛❣❡✳ ■♥ ❝♦♥✈❡♥t✐♦♥❛❧ ❧❛♥❣✉❛❣❡s✱ ✈✐r✲ t✉❛❧❧② ❛❧❧ ✈❛r✐❛❜❧❡s ❝❛♥ ❜❡ ✉♣❞❛t❡❞✳ ❲❡ ❞❡❝❧❛r❡ s♦♠❡t❤✐♥❣ ❧✐❦❡ ♣✿ ✐♥t✱ ♠❡♥✲ t✐♦♥✐♥❣ ♥♦ r❡❢❡r❡♥❝❡ t②♣❡ ❡✈❡♥ ✐❢ t❤❡ ❧❛♥❣✉❛❣❡ ♣r♦✈✐❞❡s t❤❡♠✳ ■❢ ✇❡ ❞♦ ♥♦t s♣❡❝✐❢② ❛♥ ✐♥✐t✐❛❧ ✈❛❧✉❡✱ ✇❡ ♠❛② ❣❡t ✇❤❛t❡✈❡r ❜✐ts ✇❡r❡ ♣r❡✈✐♦✉s❧② ❛t t❤❛t ❛❞❞r❡ss✳ ■❧❧❡❣❛❧ ✈❛❧✉❡s ❛r✐s✐♥❣ ❢r♦♠ ✉♥✐♥✐t✐❛❧✐③❡❞ ✈❛r✐❛❜❧❡s ❝❛♥ ❝❛✉s❡ ❡rr♦rs t❤❛t ❛r❡ ❛❧♠♦st ✐♠♣♦ss✐❜❧❡ t♦ ❞✐❛❣♥♦s❡✳ ❉❡r❡❢❡r❡♥❝✐♥❣ ♦♣❡r❛t♦rs ✭❧✐❦❡ ▼▲✬s ✦✮ ❛r❡ ❡s♣❡❝✐❛❧❧② ✉♥♣♦♣✉❧❛r✱ ❜❡❝❛✉s❡ t❤❡② ❝❧✉tt❡r t❤❡ ♣r♦❣r❛♠ t❡①t✳ ▼❛♥② ♣r♦❣r❛♠♠✐♥❣ ❧❛♥❣✉❛❣❡s ♠❛❦❡ ❞❡r❡❢❡r✲ ❡♥❝✐♥❣ ✐♠♣❧✐❝✐t ✭t❤❛t ✐s✱ ❛✉t♦♠❛t✐❝✮✳

❳■❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✹✺

Slide 1408

ML Primitives for Arrays τ Array.array

type of arrays of type τ

Array.tabulate(n,f)

create a n-element array

A[i] initially holds f(i) Array.sub(A,i)

return the contents of A[i]

Array.update(A,i,E)

update A[i] to the value of E

▼▲ ❛rr❛②s ❛r❡ ❧✐❦❡ r❡❢❡r❡♥❝❡s t❤❛t ❤♦❧❞ n ❡❧❡♠❡♥ts ✐♥st❡❛❞ ♦❢ ♦♥❡✳ ❚❤❡ ❡❧❡♠❡♥ts ♦❢ ❛♥ n✲❡❧❡♠❡♥t ❛rr❛② ❛r❡ ❞❡s✐❣♥❛t❡❞ ❜② t❤❡ ✐♥t❡❣❡rs ❢r♦♠ ✵ t♦ n − 1✳ ❚❤❡ it❤ ❛rr❛② ❡❧❡♠❡♥t ✐s ✉s✉❛❧❧② ✇r✐tt❡♥ A[i]✳ ■❢ τ ✐s ❛ t②♣❡ t❤❡♥ τ ❆rr❛②✳❛rr❛② ✐s t❤❡ t②♣❡ ♦❢ ❛rr❛②s ✭♦❢ ❛♥② s✐③❡✮ ✇✐t❤ ❡❧❡♠❡♥ts ❢r♦♠ τ✳ ❈❛❧❧✐♥❣ ❆rr❛②✳t❛❜✉❧❛t❡✭n✱f✮ ❝r❡❛t❡s ❛♥ ❛rr❛② ♦❢ t❤❡ s✐③❡ s♣❡❝✐✜❡❞ ❜② ❡①♣r❡ss✐♦♥ n✱ ❛❧❧♦❝❛t✐♥❣ t❤❡ ♥❡❝❡ss❛r② st♦r❛❣❡✳ ■♥✐t✐❛❧❧②✱ ❡❧❡♠❡♥t A[i] ❤♦❧❞s t❤❡ ✈❛❧✉❡ ♦❢ f(i) ❢♦r i = 0✱ ✳ ✳ ✳ ✱ n − 1✳ ❈❛❧❧✐♥❣ ❆rr❛②✳s✉❜✭A✱i✮ r❡t✉r♥s t❤❡ ❝♦♥t❡♥ts ♦❢ A[i]✳ ❈❛❧❧✐♥❣ ❆rr❛②✳✉♣❞❛t❡✭A✱i✱E✮ ♠♦❞✐✜❡s t❤❡ ❛rr❛② ❜② st♦r✐♥❣ t❤❡ ✈❛❧✉❡ ♦❢ E ❛s t❤❡ ♥❡✇ ❝♦♥t❡♥ts ♦❢ A[i]❀ ✐t r❡t✉r♥s ✭✮ ❛s ✐ts ✈❛❧✉❡✳ ❲❤② ✐s t❤❡r❡ ♥♦ ❢✉♥❝t✐♦♥ r❡t✉r♥✐♥❣ ❛ r❡❢❡r❡♥❝❡ t♦ A[i]❄ ❙✉❝❤ ❛ ❢✉♥❝t✐♦♥ ❝♦✉❧❞ r❡♣❧❛❝❡ ❜♦t❤ ❆rr❛②✳s✉❜ ❛♥❞ ❆rr❛②✳✉♣❞❛t❡✱ ❜✉t ❛❧❧♦✇✐♥❣ r❡❢❡r❡♥❝❡s t♦ ✐♥❞✐✈✐❞✉❛❧ ❛rr❛② ❡❧❡♠❡♥ts ✇♦✉❧❞ ❝♦♠♣❧✐❝❛t❡ st♦r❛❣❡ ♠❛♥❛❣❡♠❡♥t✳ ❆♥ ❛rr❛②✬s s✐③❡ ✐s s♣❡❝✐✜❡❞ ✐♥ ❛❞✈❛♥❝❡ t♦ ❢❛❝✐❧✐t❛t❡ st♦r❛❣❡ ♠❛♥❛❣❡♠❡♥t✳ ❚②♣✐❝❛❧❧② ❛♥♦t❤❡r ✈❛r✐❛❜❧❡ r❡❝♦r❞s ❤♦✇ ♠❛♥② ❡❧❡♠❡♥ts ❛r❡ ❛❝t✉❛❧❧② ✐♥ ✉s❡✳ ❚❤❡ ✉♥✉s❡❞ ❡❧❡♠❡♥ts ❝♦♥st✐t✉t❡ ✇❛st❡❞ st♦r❛❣❡❀ ✐❢ t❤❡② ❛r❡ ♥❡✈❡r ✐♥✐t✐❛❧✐③❡❞ t♦ ❧❡❣❛❧ ✈❛❧✉❡s ✭t❤❡② s❡❧❞♦♠ ❛r❡✮✱ t❤❡♥ t❤❡② ❝❛♥ ❝❛✉s❡ ♥♦ ❡♥❞ ♦❢ tr♦✉❜❧❡✳ ❲❤❡♥ t❤❡ ❛rr❛② ❜♦✉♥❞ ✐s r❡❛❝❤❡❞✱ ❡✐t❤❡r t❤❡ ♣r♦❣r❛♠ ♠✉st ❛❜♦rt ♦r t❤❡ ❛rr❛② ♠✉st ❡①♣❛♥❞✱ t②♣✐❝❛❧❧② ❜② ❝♦♣②✐♥❣ ✐♥t♦ ❛ ♥❡✇ ♦♥❡ t❤❛t ✐s t✇✐❝❡ ❛s ❜✐❣✳

❳■❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✹✻

Slide 1409

Array Example: Block Move

fun insert (A,kp,x) = let val ip = ref (!kp) in while !ip>0 do (Array.update(A, !ip, (* A[i] := A[i-1] *) Array.sub(A, !ip-1)); ip := !ip-1); Array.update(A, 0, x); kp := !kp+1 end;

❚❤❡ ♠❛✐♥ ❧❡ss♦♥ t♦ ❞r❛✇ ❢r♦♠ t❤✐s ❡①❛♠♣❧❡ ✐s t❤❛t ❛rr❛②s ❛r❡ ❤❛r❞❡r t♦ ✉s❡ t❤❛♥ ❧✐sts✳ ■♥s❡rt✐♦♥ s♦rt ❛♥❞ q✉✐❝❦ s♦rt ✜t ♦♥ ❛ s❧✐❞❡ ✇❤❡♥ ❡①♣r❡ss❡❞ ✉s✐♥❣ ❧✐sts ✭▲❡❝t✳ ✻✮✳ ❚❤❡ ❝♦❞❡ ❛❜♦✈❡✱ r♦✉❣❤❧② t❤❡ ❡q✉✐✈❛❧❡♥t ♦❢ ①✿✿①s✱ ✇❛s ♦r✐❣✐♥❛❧❧② ♣❛rt ♦❢ ❛♥ ✐♥s❡rt✐♦♥ ❢✉♥❝t✐♦♥ ❢♦r ❛rr❛②✲❜❛s❡❞ ✐♥s❡rt✐♦♥ s♦rt✳ ▼▲✬s ❛rr❛② s②♥t❛① ❞♦❡s ♥♦t ❤❡❧♣✳ ■♥ ❛ ❝♦♥✈❡♥t✐♦♥❛❧ ❧❛♥❣✉❛❣❡✱ t❤❡ ❦❡② ❛ss✐❣♥♠❡♥t ♠✐❣❤t ❜❡ ✇r✐tt❡♥

❆❬✐♣❪ ✿❂ ❆❬✐♣✲✶❪

❚♦ ❜❡ ❢❛✐r✱ ▼▲✬s ❞❛t❛t②♣❡s ❛♥❞ ❧✐sts r❡q✉✐r❡ ❛ s♦♣❤✐st✐❝❛t❡❞ st♦r❛❣❡ ♠❛♥❛❣❡✲ ♠❡♥t s②st❡♠ ❛♥❞ t❤❡✐r ♦✈❡r❤❡❛❞s ❛r❡ ❤❡❛✈②✳ ❖❢t❡♥✱ ❢♦r ❡✈❡r② ❜②t❡ ❞❡✈♦t❡❞ t♦ ❛❝t✉❛❧ ❞❛t❛✱ ❛♥♦t❤❡r ❜②t❡ ♠✉st ❜❡ ❞❡✈♦t❡❞ t♦ ❧✐♥❦ ✜❡❧❞s✱ ❛s ❞✐s❝✉ss❡❞ ✐♥ ▲❡❝t✳ ✶✺✳ ❋✉♥❝t✐♦♥ ✐♥s❡rt t❛❦❡s ❛♥ ❛rr❛② ❆ ✇❤♦s❡ ❡❧❡♠❡♥ts ✐♥❞❡①❡❞ ❜② ③❡r♦ t♦✦❦♣✲✶ ❛r❡ ✐♥ ✉s❡✳ ❚❤❡ ❢✉♥❝t✐♦♥ ♠♦✈❡s ❡❛❝❤ ❡❧❡♠❡♥t t♦ t❤❡ ♥❡①t ❤✐❣❤❡r s✉❜s❝r✐♣t ♣♦s✐t✐♦♥✱ st♦r❡s ① ✐♥ ♣♦s✐t✐♦♥ ③❡r♦ ❛♥❞ ✐♥❝r❡❛s❡s t❤❡ ❜♦✉♥❞ ✐♥ ❦♣✳ ❲❡ ❤❛✈❡ ❛♥ ❡①❛♠♣❧❡ ♦❢ ✇❤❛t ✐♥ ♦t❤❡r ❧❛♥❣✉❛❣❡s ❛r❡ ❝❛❧❧❡❞ r❡❢❡r❡♥❝❡ ♣❛✲ r❛♠❡t❡rs✳ ❆r❣✉♠❡♥t ❆ ❤❛s t②♣❡ ✬❛ ❆rr❛②✳❛rr❛②✱ ✇❤✐❧❡ ❦♣ ❤❛s t②♣❡ ✐♥t r❡❢✳ ❚❤❡ ❢✉♥❝t✐♦♥ ❛❝ts t❤r♦✉❣❤ t❤❡s❡ ♣❛r❛♠❡t❡rs ♦♥❧②✳ ■♥ t❤❡ ❈ ❧❛♥❣✉❛❣❡✱ t❤❡r❡ ❛r❡ ♥♦ ❛rr❛②s ❛s ♥♦r♠❛❧❧② ✉♥❞❡rst♦♦❞✱ ♠❡r❡❧② ❛ ❝♦♥✈❡♥✐❡♥t s②♥t❛① ❢♦r ♠❛❦✐♥❣ ❛❞❞r❡ss ❝❛❧❝✉❧❛t✐♦♥s✳ ❆s ❛ r❡s✉❧t✱ ❈ ✐s ♦♥❡ ♦❢ t❤❡ ♠♦st ❡rr♦r✲♣r♦♥❡ ❧❛♥❣✉❛❣❡s ✐♥ ❡①✐st❡♥❝❡✳ ❚❤❡ ✈✉❧♥❡r❛❜✐❧✐t② ♦❢ ❈ s♦❢t✇❛r❡ ✇❛s ❞r❛♠❛t✐❝❛❧❧② ❞❡♠♦♥str❛t❡❞ ✐♥ ◆♦✈❡♠❜❡r ✶✾✽✽✱ ✇❤❡♥ t❤❡ ■♥t❡r♥❡t ❲♦r♠ ❜r♦✉❣❤t t❤❡ ♥❡t✇♦r❦ ❞♦✇♥✳

❳■❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✹✼

Slide 1410

Arrays: ML Versus Conventional Languages

advantages

• Array subscripts are checked! (Unlike C)
• Read-only arrays are available.

DISADVANTAGES

• clumsy syntax, especially for updating
• and even worse for arrays of arrays

USE ARRAYS WITH CARE, BECAUSE THEY COMPLICATE PROGRAMS.

▼▲ ♣r♦✈✐❞❡s ✐♠♠✉t❛❜❧❡ ❛rr❛②s✱ ❝❛❧❧❡❞ ✈❡❝t♦rs✱ ✇❤✐❝❤ ❧❛❝❦ ❛♥ ✉♣❞❛t❡ ♦♣✲ ❡r❛t✐♦♥✳ ❚❤❡ ♦♣❡r❛t✐♦♥ ❱❡❝t♦r✳t❛❜✉❧❛t❡ ❝❛♥ ❜❡ ✉s❡❞ t♦ tr❛❞❡ st♦r❛❣❡ ❢♦r r✉♥t✐♠❡✳ ❈r❡❛t✐♥❣ ❛ t❛❜❧❡ ♦❢ ❢✉♥❝t✐♦♥ ✈❛❧✉❡s ✐s ✇♦rt❤✇❤✐❧❡ ✐❢ t❤❡ ❢✉♥❝t✐♦♥ ✐s ❝♦♠♣✉t❛t✐♦♥❛❧❧② ❡①♣❡♥s✐✈❡✳ ❍❡r❡ ✐s ❛ t❛❜❧❡ ♦❢ t❤❡ ♠❛✐♥ ❛rr❛② ❢✉♥❝t✐♦♥s✱ ✇✐t❤ t❤❡✐r t②♣❡s✳ ❆rr❛②✳❛rr❛② ✐♥t ✯ ✬❛ ✲❃ ✬❛ ❆rr❛②✳❛rr❛② ❆rr❛②✳t❛❜✉❧❛t❡ ✐♥t ✯ ✭✐♥t ✲❃ ✬❛✮ ✲❃ ✬❛ ❆rr❛②✳❛rr❛② ❆rr❛②✳s✉❜ ✬❛ ❆rr❛②✳❛rr❛② ✯ ✐♥t ✲❃ ✬❛ ❆rr❛②✳✉♣❞❛t❡ ✬❛ ❆rr❛②✳❛rr❛② ✯ ✐♥t ✯ ✬❛ ✲❃ ✉♥✐t ❘❡❢❡r❡♥❝❡s ❣✐✈❡ ✉s ♥❡✇ ✇❛②s ♦❢ ❡①♣r❡ss✐♥❣ ♣r♦❣r❛♠s✱ ❛♥❞ ❛rr❛②s ❣✐✈❡ ✉s ❡✣❝✐❡♥t ❛❝❝❡ss t♦ t❤❡ ❤❛r❞✇❛r❡ ❛❞❞r❡ss✐♥❣ ♠❡❝❤❛♥✐s♠✳ ❇✉t ♥❡✐t❤❡r ❢✉♥❞❛✲ ♠❡♥t❛❧❧② ✐♥❝r❡❛s❡s t❤❡ s❡t ♦❢ ❛❧❣♦r✐t❤♠s t❤❛t ✇❡ ❝❛♥ ❡①♣r❡ss✖ ✉♥❧✐❦❡ ❝♦♠✲ ♠✉♥✐❝❛t✐♦♥ ♣r✐♠✐t✐✈❡s✖❛♥❞ t❤❡② ❝❛♥ ♠❛❦❡ ♣r♦❣r❛♠s ❤❛r❞❡r t♦ ✉♥❞❡rst❛♥❞✳ ◆♦ ❧♦♥❣❡r ❝❛♥ ✇❡ ❞❡s❝r✐❜❡ ♣r♦❣r❛♠ ❡①❡❝✉t✐♦♥ ✐♥ t❡r♠s ♦❢ r❡❞✉❝t✐♦♥✱ ❛s ✇❡ ❞✐❞ ✐♥ ▲❡❝t✳ ✷✳ ❚❤❡② ❝❛♥ ❛❧s♦ ♠❛❦❡ st♦r❛❣❡ ♠❛♥❛❣❡♠❡♥t ♠♦r❡ ❡①♣❡♥s✐✈❡✳ ❚❤❡② s❤♦✉❧❞ t❤❡r❡❢♦r❡ ❜❡ ✉s❡❞ ✇✐t❤ ❝❛r❡✳ ▼▲✬s ❛rr❛②s ❛r❡ ♠✉❝❤ s❛❢❡r t❤❛♥ ❈✬s✱ ❤♦✇❡✈❡r✳ ■♥ ❈✱ ❛♥ ❛rr❛② ✐s ♥♦t❤✐♥❣ ♠♦r❡ t❤❛♥ ❛♥ ❛❞❞r❡ss ✐♥❞✐❝❛t✐♥❣ t❤❡ st❛rt ♦❢ ❛ st♦r❛❣❡ ❛r❡❛✳ ◆♦t❤✐♥❣ ✐♥❞✐❝❛t❡s t❤❡ s✐③❡ ♦❢ t❤❡ ❛r❡❛ ♦r ✇❤❡r❡ ✐t ❡♥❞s✳ ❚❤✐s ✢❛✇ ✐♥ ❈ ✐s ❧❛r❣❡❧② t♦ ❜❧❛♠❡ ❢♦r t❤❡ ✉❜✐q✉✐t♦✉s s❡❝✉r✐t② ❧♦♦♣❤♦❧❡s ❝❛✉s❡❞ ❜② ❜✉✛❡r ♦✈❡rr✉♥s✳ ■♥ ❛ ❜✉✛❡r ♦✈❡rr✉♥ ❛tt❛❝❦✱ t❤❡ ❤❛❝❦❡r s❡♥❞s ♠♦r❡ ❞❛t❛ t❤❛♥ t❤❡ r❡❝❡✐✈✐♥❣ ♣r♦❣r❛♠ ❡①♣❡❝ts✱ ♦✈❡rr✉♥♥✐♥❣ t❤❡ ❛r❡❛ ♦❢ st♦r❛❣❡ s❡t ❛s✐❞❡ t♦ ❤♦❧❞ ✐t✳ ❍❡ ❡✈❡♥t✉❛❧❧② ♦✈❡r✇r✐t❡s t❤❡ ♣r♦❣r❛♠ ✐ts❡❧❢✱ r❡♣❧❛❝✐♥❣ ✐t ✇✐t❤ t❤❡ ❤❛❝❦❡r✬s ❝❤♦s❡♥ ❝♦❞❡✳

❳■❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✹✽ ▲❡❛r♥✐♥❣ ❣✉✐❞❡✳ ❘❡❧❛t❡❞ ♠❛t❡r✐❛❧ ✐s ✐♥ ▼▲ ❢♦r t❤❡ ❲♦r❦✐♥❣ Pr♦❣r❛♠♠❡r✱ ♣❛❣❡s ✸✶✸✕✸✷✻✳ ❆ ❜r✐❡❢ ❞✐s❝✉ss✐♦♥ ♦❢ ▼▲✬s ❝♦♠♣r❡❤❡♥s✐✈❡ ✐♥♣✉t✴♦✉t♣✉t ❢❛✲ ❝✐❧✐t✐❡s✱ ✇❤✐❝❤ ❛r❡ ♥♦t ❝♦✈❡r❡❞ ✐♥ t❤✐s ❝♦✉rs❡✱ ✐s ♦♥ ♣❛❣❡s ✸✹✵✕✸✺✻✳ ❊①❡r❝✐s❡ ✶✹✳✶ ❈♦♠♠❡♥t✱ ✇✐t❤ ❡①❛♠♣❧❡s✱ ♦♥ t❤❡ ❞✐✛❡r❡♥❝❡s ❜❡t✇❡❡♥ ❛♥ ✐♥t r❡❢ ❧✐st ❛♥❞ ❛♥ ✐♥t ❧✐st r❡❢✳ ❊①❡r❝✐s❡ ✶✹✳✷ ❲r✐t❡ ❛ ✈❡rs✐♦♥ ♦❢ ❢✉♥❝t✐♦♥ ♣♦✇❡r ✭▲❡❝t✳ ✷✮ ✉s✐♥❣ ✇❤✐❧❡ ✐♥st❡❛❞ ♦❢ r❡❝✉rs✐♦♥✳ ❊①❡r❝✐s❡ ✶✹✳✸ ❲❤❛t ✐s t❤❡ ❡✛❡❝t ♦❢ ✇❤✐❧❡ ✭C1❀ B✮ ❞♦ C2❄ ❊①❡r❝✐s❡ ✶✹✳✹ ❆rr❛②s ♦❢ ♠✉❧t✐♣❧❡ ❞✐♠❡♥s✐♦♥s ❛r❡ r❡♣r❡s❡♥t❡❞ ✐♥ ▼▲ ❜② ❛rr❛②s ♦❢ ❛rr❛②s✳ ❲r✐t❡ ❢✉♥❝t✐♦♥s t♦ ✭❛✮ ❝r❡❛t❡ ❛♥ n×n ✐❞❡♥t✐t② ♠❛tr✐①✱ ❣✐✈❡♥ n✱ ❛♥❞ ✭❜✮ t♦ tr❛♥s♣♦s❡ ❛♥ m × n ♠❛tr✐①✳ ❊①❡r❝✐s❡ ✶✹✳✺ ❋✉♥❝t✐♦♥ ✐♥s❡rt ❝♦♣✐❡s ❡❧❡♠❡♥ts ❢r♦♠ A[i − 1] t♦ A[i]✱ ❢♦r i = k✱ ✳ ✳ ✳ ✱ ✶✳ ❲❤❛t ❤❛♣♣❡♥s ✐❢ ✐♥st❡❛❞ ✐t ❝♦♣✐❡s ❡❧❡♠❡♥ts ❢r♦♠ A[i] t♦ A[i+1]✱ ❢♦r i = 0✱ ✳ ✳ ✳ ✱ k − 1❄

❳❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✹✾

Slide 1501

References to References

3 5 9 · NESTED BOXES v pointers

3 5 9 9 9 9 Nil 7 ❘❡❢❡r❡♥❝❡s ❝❛♥ ❜❡ ✐♠❛❣✐♥❡❞ t♦ ❜❡ ❜♦①❡s ✇❤♦s❡ ❝♦♥t❡♥ts ❝❛♥ ❜❡ ❝❤❛♥❣❡❞✳ ❇✉t t❤❡ ❜♦① ♠❡t❛♣❤♦r ❜❡❝♦♠❡s ✉♥✇♦r❦❛❜❧❡ ✇❤❡♥ t❤❡ ❝♦♥t❡♥ts ♦❢ t❤❡ ❜♦① ❝❛♥ ✐ts❡❧❢ ❜❡ ❛ ❜♦①✿ ❞❡❡♣ ♥❡st✐♥❣ ✐s t♦♦ ❞✐✣❝✉❧t t♦ ❤❛♥❞❧❡✳ ❆ ♠♦r❡ ✢❡①✐❜❧❡ ♠❡t❛♣❤♦r ✐s t❤❡ ♣♦✐♥t❡r✳ ❆ r❡❢❡r❡♥❝❡ ♣♦✐♥ts t♦ s♦♠❡ ♦❜❥❡❝t❀ t❤✐s ♣♦✐♥t❡r ❝❛♥ ❜❡ ♠♦✈❡❞ t♦ ❛♥② ♦t❤❡r ♦❜❥❡❝t ♦❢ t❤❡ r✐❣❤t t②♣❡✳ ❚❤❡ s❧✐❞❡ ❞❡♣✐❝ts ❛ r❡♣r❡s❡♥t❛t✐♦♥ ♦❢ t❤❡ ❧✐st ❬✸✱✺✱✾❪✱ ✇❤❡r❡ t❤❡ ✜♥❛❧ ♣♦✐♥t❡r t♦ ◆✐❧ ✐s ❛❜♦✉t t♦ ❜❡ r❡❞✐r❡❝t❡❞ t♦ ❛ ❝❡❧❧ ❝♦♥t❛✐♥✐♥❣ t❤❡ ❡❧❡♠❡♥t ✼✳ ▼▲ ❢♦r❜✐❞s s✉❝❤ r❡❞✐r❡❝t✐♦♥ ❢♦r ✐ts ❜✉✐❧t✲✐♥ ❧✐sts✱ ❜✉t ✇❡ ❝❛♥ ❞❡❝❧❛r❡ ❧✐♥❦❡❞ ❧✐sts ✇❤♦s❡ ❧✐♥❦ ✜❡❧❞s ❛r❡ ♠✉t❛❜❧❡✳

❳❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✺✵

Slide 1502

Linked, or Mutable, Lists

datatype ’a mlist = Nil | Cons of ’a * ’a mlist ref;

Tail can be REDIRECTED Creating a linked list:

fun mlistOf [] = Nil | mlistOf (x::l) = Cons (x, ref (mlistOf l)); > val mlistOf = fn : ’a list -> ’a mlist

❆ ♠✉t❛❜❧❡ ❧✐st ✐s ❡✐t❤❡r ❡♠♣t② ✭◆✐❧✮ ♦r ❝♦♥s✐sts ♦❢ ❛♥ ❡❧❡♠❡♥t ♣❛✐r❡❞ ✇✐t❤ ❛ ♣♦✐♥t❡r t♦ ❛♥♦t❤❡r ♠✉t❛❜❧❡ ❧✐st✳ ❘❡♠♦✈✐♥❣ t❤❡ r❡❢ ❢r♦♠ t❤❡ ❞❡❝❧❛r❛t✐♦♥ ❛❜♦✈❡ ✇♦✉❧❞ ♠❛❦❡ t❤❡ ❞❛t❛t②♣❡ ❡①❛❝t❧② ❡q✉✐✈❛❧❡♥t t♦ ❜✉✐❧t✲✐♥ ▼▲ ❧✐sts✳ ❚❤❡ r❡❢❡r❡♥❝❡ ✐♥ t❤❡ t❛✐❧ ❛❧❧♦✇s ❧✐♥❦s t♦ ❜❡ ❝❤❛♥❣❡❞ ❛❢t❡r t❤❡✐r ❝r❡❛t✐♦♥✳ ❚♦ ❣❡t r❡❢❡r❡♥❝❡s t♦ t❤❡ ❡❧❡♠❡♥ts t❤❡♠s❡❧✈❡s✱ ✇❡ ❝❛♥ ✉s❡ t②♣❡s ♦❢ t❤❡ ❢♦r♠ ✬❛ r❡❢ ♠❧✐st✳ ✭❲❡ ❤❛✈❡ s❡❡♥ t②♣❡ ✐♥t r❡❢ ❧✐st ✐♥ ▲❡❝t✳ ✶✹✳✮ ❙♦ t❤❡r❡ ✐s ♥♦ ♥❡❡❞ ❢♦r ❛♥♦t❤❡r r❡❢ ✐♥ t❤❡ ❞❛t❛t②♣❡ ❞❡❝❧❛r❛t✐♦♥✳ ❋✉♥❝t✐♦♥ ♠❧✐st❖❢ ❝♦♥✈❡rts ♦r❞✐♥❛r② ❧✐sts t♦ ♠✉t❛❜❧❡ ❧✐sts✳ ■ts ❝❛❧❧ t♦ r❡❢ ❝r❡❛t❡s ❛ ♥❡✇ r❡❢❡r❡♥❝❡ ❝❡❧❧ ❢♦r ❡❛❝❤ ❡❧❡♠❡♥t ♦❢ t❤❡ ♥❡✇ ❧✐st✳ ▼♦st ♣r♦❣r❛♠♠✐♥❣ ❧❛♥❣✉❛❣❡s ♣r♦✈✐❞❡ r❡❢❡r❡♥❝❡ t②♣❡s ❞❡s✐❣♥❡❞ ❢♦r ❜✉✐❧❞✲ ✐♥❣ ❧✐♥❦❡❞ ❞❛t❛ str✉❝t✉r❡s✳ ❙♦♠❡t✐♠❡s t❤❡ ♥✉❧❧ r❡❢❡r❡♥❝❡✱ ✇❤✐❝❤ ♣♦✐♥ts t♦ ♥♦t❤✐♥❣✱ ✐s ❛ ♣r❡❞❡✜♥❡❞ ❝♦♥st❛♥t ❝❛❧❧❡❞ ◆■▲✳ ❚❤❡ r✉♥✲t✐♠❡ s②st❡♠ ❛❧❧♦❝❛t❡s s♣❛❝❡ ❢♦r r❡❢❡r❡♥❝❡ ❝❡❧❧s ✐♥ ❛ ❞❡❞✐❝❛t❡❞ ♣❛rt ♦❢ st♦r❛❣❡✱ ❝❛❧❧❡❞ t❤❡ ❤❡❛♣✱ ✇❤✐❧❡ ♦t❤❡r ✭♠✉t❛❜❧❡✮ ✈❛r✐❛❜❧❡s ❛r❡ ❛❧❧♦❝❛t❡❞ ♦♥ t❤❡ st❛❝❦✳ ■♥ ❝♦♥tr❛st✱ ▼▲ tr❡❛ts ❛❧❧ r❡❢❡r❡♥❝❡s ✉♥✐❢♦r♠❧②✳ ▼▲ ❧✐sts ❛r❡ r❡♣r❡s❡♥t❡❞ ✐♥t❡r♥❛❧❧② ❜② ❛ ❧✐♥❦❡❞ ❞❛t❛ str✉❝t✉r❡ t❤❛t ✐s ❡q✉✐✈❛❧❡♥t t♦ ♠❧✐st✳ ❚❤❡ r❡♣r❡s❡♥t❛t✐♦♥ ❛❧❧♦✇s t❤❡ ❧✐♥❦s ✐♥ ❛♥ ▼▲ ❧✐st t♦ ❜❡ ❝❤❛♥❣❡❞✳ ❚❤❛t s✉❝❤ ❝❤❛♥❣❡s ❛r❡ ❢♦r❜✐❞❞❡♥ ✐s ❛ ❞❡s✐❣♥ ❞❡❝✐s✐♦♥ ♦❢ ▼▲ t♦ ❡♥❝♦✉r❛❣❡ ❢✉♥❝t✐♦♥❛❧ ♣r♦❣r❛♠♠✐♥❣✳ ❚❤❡ ❧✐st✲♣r♦❝❡ss✐♥❣ ❧❛♥❣✉❛❣❡ ▲✐s♣ ❛❧❧♦✇s ❧✐♥❦s t♦ ❜❡ ❝❤❛♥❣❡❞✳

❳❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✺✶

Slide 1503

Extending a List to the Rear

fun extend (mlp, x) = let val last = ref Nil in mlp := Cons (x, last); last

new final reference

end; > val extend = fn > : ’a mlist ref * ’a -> ’a mlist ref

❊①t❡♥❞✐♥❣ ♦r❞✐♥❛r② ▼▲ ❧✐sts t♦ t❤❡ r❡❛r ✐s ❤✉❣❡❧② ❡①♣❡♥s✐✈❡✿ ✇❡ ♠✉st ❡✈❛❧✉❛t❡ ❛♥ ❡①♣r❡ss✐♦♥ ♦❢ t❤❡ ❢♦r♠ ①s❅❬①❪✱ ✇❤✐❝❤ ✐s O(n) ✐♥ t❤❡ s✐③❡ ♦❢ ①s✳ ❲✐t❤ ♠✉t❛❜❧❡ ❧✐sts✱ ✇❡ ❝❛♥ ❦❡❡♣ ❛ ♣♦✐♥t❡r t♦ t❤❡ ✜♥❛❧ r❡❢❡r❡♥❝❡✳ ❚♦ ❡①t❡♥❞ t❤❡ ❧✐st✱ ✉♣❞❛t❡ t❤✐s ♣♦✐♥t❡r t♦ ❛ ♥❡✇ ❧✐st ❝❡❧❧✳ ◆♦t❡ t❤❡ ♥❡✇ ✜♥❛❧ r❡❢❡r❡♥❝❡ ❢♦r ✉s❡ t❤❡ ♥❡①t t✐♠❡ t❤❡ ❧✐st ✐s ❡①t❡♥❞❡❞✳ ❋✉♥❝t✐♦♥ ❡①t❡♥❞ t❛❦❡s t❤❡ r❡❢❡r❡♥❝❡ ♠❧♣ ❛♥❞ ❛♥ ❡❧❡♠❡♥t ①✳ ■t ❛ss✐❣♥s t♦ ♠❧♣ ❛♥❞ r❡t✉r♥s t❤❡ ♥❡✇ r❡❢❡r❡♥❝❡ ❛s ✐ts ✈❛❧✉❡✳ ■ts ❡✛❡❝t ✐s t♦ ✉♣❞❛t❡ ♠❧♣ t♦ ❛ ❧✐st ❝❡❧❧ ❝♦♥t❛✐♥✐♥❣ ①✳

❳❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✺✷

Slide 1504

Example of Extending a List

val mlp = ref (Nil: string mlist); > val mlp = ref Nil : string mlist ref extend (mlp, "a"); > val it = ref Nil : string mlist ref extend (it, "b"); > val it = ref Nil : string mlist ref mlp; > ref(Cons("a", ref(Cons("b", ref Nil))))

❲❡ st❛rt t❤✐♥❣s ♦✛ ❜② ❝r❡❛t✐♥❣ ❛ ♥❡✇ ♣♦✐♥t❡r t♦ ◆✐❧✱ ❜✐♥❞✐♥❣ ✐t t♦ ♠❧♣✳ ❚✇♦ ❝❛❧❧s t♦ ❡①t❡♥❞ ❛❞❞ t❤❡ ❡❧❡♠❡♥ts ✧❛✧ ❛♥❞ ✧❜✧✳ ◆♦t❡ t❤❛t t❤❡ ✜rst ❡①t❡♥❞ ❝❛❧❧ ✐s ❣✐✈❡♥ ♠❧♣✱ ✇❤✐❧❡ t❤❡ s❡❝♦♥❞ ❝❛❧❧ ✐s ❣✐✈❡♥ t❤❡ r❡s✉❧t ♦❢ t❤❡ ✜rst✱ ♥❛♠❡❧② ✐t✳ ❋✐♥❛❧❧②✱ ✇❡ ❡①❛♠✐♥❡ ♠❧♣✳ ■t ♥♦ ❧♦♥❣❡r ♣♦✐♥ts t♦ ◆✐❧ ❜✉t t♦ t❤❡ ♠✉t❛❜❧❡ ❧✐st ❬✧❛✧✱✧❜✧❪✳

❳❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✺✸

Slide 1505

Destructive Concatenation

fun joining (mlp, ml2) = case !mlp of Nil => mlp := ml2 | Cons(_,mlp1) => joining (mlp1, ml2); fun join (ml1, ml2) = let val mlp = ref ml1

temporary reference

in joining (mlp, ml2); !mlp end;

❋✉♥❝t✐♦♥ ❥♦✐♥ ♣❡r❢♦r♠s ❞❡str✉❝t✐✈❡ ❝♦♥❝❛t❡♥❛t✐♦♥✳ ■t ✉♣❞❛t❡s t❤❡ ✜♥❛❧ ♣♦✐♥t❡r ♦❢ ♦♥❡ ♠✉t❛❜❧❡ ❧✐st t♦ ♣♦✐♥t t♦ s♦♠❡ ♦t❤❡r ❧✐st r❛t❤❡r t❤❛♥ t♦ ◆✐❧✳ ❈♦♥tr❛st ✇✐t❤ ♦r❞✐♥❛r② ❧✐st ❛♣♣❡♥❞✱ ✇❤✐❝❤ ❝♦♣✐❡s ✐ts ✜rst ❛r❣✉♠❡♥t✳ ❆♣♣❡♥❞ t❛❦❡s O(n) t✐♠❡ ❛♥❞ s♣❛❝❡ ✐♥ t❤❡ s✐③❡ ♦❢ t❤❡ ✜rst ❧✐st✱ ✇❤✐❧❡ ❞❡str✉❝t✐✈❡ ❝♦♥❝❛t❡♥❛t✐♦♥ ♥❡❡❞s ♦♥❧② ❝♦♥st❛♥t s♣❛❝❡✳ ❋✉♥❝t✐♦♥ ❥♦✐♥✐♥❣ ❞♦❡s t❤❡ r❡❛❧ ✇♦r❦✳ ■ts ✜rst ❛r❣✉♠❡♥t ✐s ❛ ♣♦✐♥t❡r t❤❛t s❤♦✉❧❞ ❜❡ ❢♦❧❧♦✇❡❞ ✉♥t✐❧✱ ✇❤❡♥ ◆✐❧ ✐s r❡❛❝❤❡❞✱ ✐t ❝❛♥ ❜❡ ♠❛❞❡ t♦ ♣♦✐♥t t♦ ❧✐st ♠❧✷✳ ❚❤❡ ❢✉♥❝t✐♦♥ ❧♦♦❦s ❛t t❤❡ ❝♦♥t❡♥ts ♦❢ r❡❢❡r❡♥❝❡ ♠❧♣✳ ■❢ ✐t ✐s ◆✐❧✱ t❤❡♥ t❤❡ t✐♠❡ ❤❛s ❝♦♠❡ t♦ ✉♣❞❛t❡ ♠❧♣ t♦ ♣♦✐♥t t♦ ♠❧✷✳ ❇✉t ✐❢ ✐t ✐s ❛ ❈♦♥s t❤❡♥ t❤❡ s❡❛r❝❤ ❝♦♥t✐♥✉❡s ✉s✐♥❣ r❡❢❡r❡♥❝❡ ✐♥ t❤❡ t❛✐❧✳ ❋✉♥❝t✐♦♥ ❥♦✐♥ st❛rts t❤❡ s❡❛r❝❤ ♦✛ ✇✐t❤ ❛ t❡♠♣♦r❛r② r❡❢❡r❡♥❝❡ t♦ ✐ts ✜rst ❛r❣✉♠❡♥t✳ ❚❤✐s tr✐❝❦ s❛✈❡s ✉s ❢r♦♠ ❤❛✈✐♥❣ t♦ t❡st ✇❤❡t❤❡r ♦r ♥♦t ♠❧✶ ✐s ◆✐❧❀ t❤❡ t❡st ✐♥ ❥♦✐♥✐♥❣ ❡✐t❤❡r ✉♣❞❛t❡s t❤❡ r❡❢❡r❡♥❝❡ ♦r s❦✐♣s ❞♦✇♥ t♦ t❤❡ ❵♣r♦♣❡r✬ r❡❢❡r❡♥❝❡ ✐♥ t❤❡ t❛✐❧✳ ❚r✐❝❦s ♦❢ t❤✐s s♦rt ❛r❡ q✉✐t❡ ✉s❡❢✉❧ ✇❤❡♥ ♣r♦❣r❛♠♠✐♥❣ ✇✐t❤ ❧✐♥❦❡❞ str✉❝t✉r❡s✳ ❚❤❡ ❢✉♥❝t✐♦♥s✬ t②♣❡s t❡❧❧ ✉s t❤❛t ❥♦✐♥✐♥❣ t❛❦❡s t✇♦ ♠✉t❛❜❧❡ ❧✐sts ❛♥❞ ✭❛t ♠♦st✮ ♣❡r❢♦r♠s s♦♠❡ ❛❝t✐♦♥✱ s✐♥❝❡ ✐t ❝❛♥ ♦♥❧② r❡t✉r♥ ✭✮✱ ✇❤✐❧❡ ❥♦✐♥ t❛❦❡s t✇♦ ❧✐sts ❛♥❞ r❡t✉r♥s ❛♥♦t❤❡r ♦♥❡✳

❥♦✐♥✐♥❣ ✿ ✬❛ ♠❧✐st r❡❢ ✯ ✬❛ ♠❧✐st ✲❃ ✉♥✐t ❥♦✐♥ ✿ ✬❛ ♠❧✐st ✯ ✬❛ ♠❧✐st ✲❃ ✬❛ ♠❧✐st

❳❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✺✹

Slide 1506

Side-Effects

val ml1 = mlistOf ["a"]; > val ml1 = Cons("a", ref Nil) : string mlist val ml2 = mlistOf ["b","c"]; > val ml2 = Cons("b", ref(Cons("c", ref Nil))) join(ml1,ml2); ml1;

IT’S CHANGED!?

> Cons("a", > ref(Cons("b", ref(Cons("c", ref Nil)))))

■♥ t❤✐s ❡①❛♠♣❧❡✱ ✇❡ ❜✐♥❞ t❤❡ ♠✉t❛❜❧❡ ❧✐sts ❬✧❛✧❪ ❛♥❞ ❬✧❜✧✱✧❝✧❪ t♦ t❤❡ ✈❛r✐❛❜❧❡s ♠❧✶ ❛♥❞ ♠❧✷✳ ▼▲✬s ♠❡t❤♦❞ ♦❢ ❞✐s♣❧❛②✐♥❣ r❡❢❡r❡♥❝❡ ✈❛❧✉❡s ❧❡ts ✉s ❡❛s✐❧② r❡❛❞ ♦✛ t❤❡ ❧✐st ❡❧❡♠❡♥ts ✐♥ t❤❡ ❞❛t❛ str✉❝t✉r❡s✳ ◆❡①t✱ ✇❡ ❝♦♥❝❛t❡♥❛t❡ t❤❡ ❧✐sts ✉s✐♥❣ ❥♦✐♥✳ ✭❚❤❡r❡ ✐s ♥♦ r♦♦♠ t♦ ❞✐s♣❧❛② t❤❡ r❡t✉r♥❡❞ ✈❛❧✉❡✱ ❜✉t ✐t ✐s ✐❞❡♥t✐❝❛❧ t♦ t❤❡ ♦♥❡ ❛t t❤❡ ❜♦tt♦♠ ♦❢ t❤❡ s❧✐❞❡✱ ✇❤✐❝❤ ✐s t❤❡ ♠✉t❛❜❧❡ ❧✐st ❬✧❛✧✱✧❜✧✱✧❝✧❪✳✮ ❋✐♥❛❧❧②✱ ✇❡ ✐♥s♣❡❝t t❤❡ ✈❛❧✉❡ ♦❢ ♠❧✶✳ ■t ❧♦♦❦s ❞✐✛❡r❡♥t❀ ❤❛s ✐t ❝❤❛♥❣❡❞❄ ◆♦❀ ✐t ✐s t❤❡ s❛♠❡ r❡❢❡r❡♥❝❡ ❛s ❡✈❡r✳ ❚❤❡ ❝♦♥t❡♥ts ♦❢ ❛ ❝❡❧❧ r❡❛❝❤❛❜❧❡ ❢r♦♠ ✐t ❤❛s ❝❤❛♥❣❡❞✳ ❖✉r ✐♥t❡r♣r❡t❛t✐♦♥ ♦❢ ✐ts ✈❛❧✉❡ ♦❢ ❛ ❧✐st ❤❛s ❝❤❛♥❣❡❞ ❢r♦♠ ❬✧❛✧❪ t♦ ❬✧❛✧✱✧❜✧✱✧❝✧❪✳ ❚❤✐s ❜❡❤❛✈✐♦✉r ❝❛♥♥♦t ♦❝❝✉r ✇✐t❤ ▼▲✬s ❜✉✐❧t✲✐♥ ❧✐sts ❜❡❝❛✉s❡ t❤❡✐r ✐♥t❡r✲ ♥❛❧ ❧✐♥❦ ✜❡❧❞s ❛r❡ ♥♦t ♠✉t❛❜❧❡✳ ❚❤❡ ❛❜✐❧✐t② t♦ ✉♣❞❛t❡ t❤❡ ❧✐st ❤❡❧❞ ✐♥ ♠❧✶ ♠✐❣❤t ❜❡ ✇❛♥t❡❞✱ ❜✉t ✐t ♠✐❣❤t ❛❧s♦ ❝♦♠❡ ❛s ❛♥ ✉♥♣❧❡❛s❛♥t s✉r♣r✐s❡✱ ❡s♣❡❝✐❛❧❧② ✐❢ ✇❡ ❝♦♥❢✉s❡ ❥♦✐♥ ✇✐t❤ ❛♣♣❡♥❞✳ ❆ ❢✉rt❤❡r s✉r♣r✐s❡ ✐s t❤❛t

❥♦✐♥✭♠❧✷✱♠❧✸✮

❛❧s♦ ❛✛❡❝ts t❤❡ ❧✐st ✐♥ ♠❧✶✿ ✐t ✉♣❞❛t❡s t❤❡ ❧❛st ♣♦✐♥t❡r ♦❢ ♠❧✷ ❛♥❞ t❤❛t ✐s ♥♦✇ t❤❡ ❧❛st ♣♦✐♥t❡r ♦❢ ♠❧✶ t♦♦✳

❳❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✺✺

Slide 1507

A Cyclic List

val ml = mlistOf [0,1]; > val ml = Cons(0, ref(Cons(1, ref Nil))) join(ml,ml); > Cons(0, > ref(Cons(1, > ref(Cons(0, > ref(Cons(1,...)))))))

❲❤❛t ❤❛s ❤❛♣♣❡♥❡❞❄ ❈❛❧❧✐♥❣ ❥♦✐♥✭♠❧✱♠❧✮ ❝❛✉s❡s t❤❡ ❧✐st ♠❧ t♦ ❜❡ ❝❤❛s❡❞ ❞♦✇♥ t♦ ✐ts ✜♥❛❧ ❧✐♥❦✱ ✇❤✐❝❤ ✐s ♠❛❞❡ t♦ ♣♦✐♥t t♦ ✳ ✳ ✳ ♠❧✦ ■❢ ❛♥ ♦❜❥❡❝t ❝♦♥t❛✐♥s✱ ♣❡r❤❛♣s ✈✐❛ s❡✈❡r❛❧ ❧✐♥❦s✱ ❛ ♣♦✐♥t❡r ❧❡❛❞✐♥❣ ❜❛❝❦ t♦ ✐ts❡❧❢✱ ✇❡ ❤❛✈❡ ❛ ❝②❝❧❡✳ ❆ ❝②❝❧✐❝ ❝❤❛✐♥ ♦❢ ♣♦✐♥t❡rs ❝❛♥ ❜❡ ❞✐s❛str♦✉s ✐❢ ✐t ✐s ❝r❡❛t❡❞ ✉♥❡①♣❡❝t❡❞❧②✳ ❈②❝❧✐❝ ❞❛t❛ str✉❝t✉r❡s ❛r❡ ❞✐✣❝✉❧t t♦ ♥❛✈✐❣❛t❡ ✇✐t❤♦✉t ❧♦♦♣✐♥❣ ❛♥❞ ❛r❡ ❡s♣❡❝✐❛❧❧② ❞✐✣❝✉❧t t♦ ❝♦♣②✳ ◆❛t✉r❛❧❧②✱ t❤❡② ❞♦♥✬t s✉✐t t❤❡ ❜♦① ♠❡t❛♣❤♦r ❢♦r r❡❢❡r❡♥❝❡s✦ ❈②❝❧✐❝ ❞❛t❛ str✉❝t✉r❡s ❞♦ ❤❛✈❡ t❤❡✐r ✉s❡s✳ ❆ ❝✐r❝✉❧❛r ❧✐st ❝❛♥ ❜❡ ✉s❡❞ t♦ r♦t❛t❡ ❛♠♦♥❣ ❛ ✜♥✐t❡ ♥✉♠❜❡r ♦❢ ❝❤♦✐❝❡s ❢❛✐r❧②✳ ❆ ❞❡♣❡♥❞❡♥❝② ❣r❛♣❤ ❞❡s❝r✐❜❡s ❤♦✇ ✈❛r✐♦✉s ✐t❡♠s ❞❡♣❡♥❞ ✉♣♦♥ ♦t❤❡r ✐t❡♠s❀ s✉❝❤ ❞❡♣❡♥❞❡♥❝✐❡s ❝❛♥ ❜❡ ❝②❝❧✐❝✳

❳❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✺✻

Slide 1508

Destructive Reverse: The Idea

a b c Nil argument a b c Nil result

▲✐st r❡✈❡rs❛❧ ❝❛♥ ❜❡ tr✐❝❦② t♦ ✇♦r❦ ♦✉t ❢r♦♠ ✜rst ♣r✐♥❝✐♣❧❡s✱ ❜✉t t❤❡ ❝♦❞❡ s❤♦✉❧❞ ❜❡ ❡❛s② t♦ ✉♥❞❡rst❛♥❞✳ ❘❡✈❡rs❡ ❢♦r ♦r❞✐♥❛r② ❧✐sts ❝♦♣✐❡s t❤❡ ❧✐st ❝❡❧❧s ✇❤✐❧❡ r❡✈❡rs✐♥❣ t❤❡ ♦r❞❡r ♦❢ t❤❡ ❡❧❡♠❡♥ts✳ ❉❡str✉❝t✐✈❡ r❡✈❡rs❡ r❡✲✉s❡s t❤❡ ❡①✐st✐♥❣ ❧✐st ❝❡❧❧s ✇❤✐❧❡ r❡✲ ♦r✐❡♥t✐♥❣ t❤❡ ❧✐♥❦s✳ ■t ✇♦r❦s ❜② ✇❛❧❦✐♥❣ ❞♦✇♥ t❤❡ ♠✉t❛❜❧❡ ❧✐st✱ ♥♦t✐♥❣ t❤❡ ❧❛st t✇♦ ♠✉t❛❜❧❡ ❧✐sts ❡♥❝♦✉♥t❡r❡❞✱ ❛♥❞ r❡❞✐r❡❝t✐♥❣ t❤❡ s❡❝♦♥❞ ❝❡❧❧✬s ❧✐♥❦ ✜❡❧❞ t♦ ♣♦✐♥t t♦ t❤❡ ✜rst✳ ■♥✐t✐❛❧❧②✱ t❤❡ ✜rst ♠✉t❛❜❧❡ ❧✐st ✐s ◆✐❧✱ s✐♥❝❡ t❤❡ ❧❛st ❧✐♥❦ ♦❢ t❤❡ r❡✈❡rs❡❞ ♠✉st ♣♦✐♥t t♦ ◆✐❧✳ ◆♦t❡ t❤❛t ✇❡ ♠✉st ❧♦♦❦ ❛t t❤❡ r❡✈❡rs❡❞ ❧✐st ❢r♦♠ t❤❡ ♦♣♣♦s✐t❡ ❡♥❞✦ ❚❤❡ r❡✈❡rs❛❧ ❢✉♥❝t✐♦♥ t❛❦❡s ❛s ✐ts ❛r❣✉♠❡♥t ❛ ♣♦✐♥t❡r t♦ t❤❡ ✜rst ❡❧❡♠❡♥t ♦❢ t❤❡ ❧✐st✳ ■t ♠✉st r❡t✉r♥ ❛ ♣♦✐♥t❡r t♦ t❤❡ ✜rst ❡❧❡♠❡♥t ♦❢ t❤❡ r❡✈❡rs❡❞ ❧✐st✱ ✇❤✐❝❤ ✐s t❤❡ ❧❛st ❡❧❡♠❡♥t ♦❢ t❤❡ ♦r✐❣✐♥❛❧ ❧✐st✳

❳❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✺✼

Slide 1509

A Destructive Reverse Function

fun reversing (prev, ml) = case ml of Nil => prev

start of reversed list

| Cons(_,mlp2) => let val ml2 = !mlp2

next cell

in mlp2 := prev;

re-orient

reversing (ml, ml2) end; > reversing: ’a mlist * ’a mlist -> ’a mlist fun drev ml = reversing (Nil, ml);

❚❤❡ ❢✉♥❝t✐♦♥ r❡✈❡rs✐♥❣ r❡❞✐r❡❝ts ♣♦✐♥t❡rs ❛s ❞❡s❝r✐❜❡❞ ❛❜♦✈❡✳ ❚❤❡ ❢✉♥❝✲ t✐♦♥ ♥❡❡❞s ♦♥❧② ❝♦♥st❛♥t s♣❛❝❡ ❜❡❝❛✉s❡ ✐t ✐s t❛✐❧ r❡❝✉rs✐✈❡ ❛♥❞ ❞♦❡s ♥♦t ❝❛❧❧ r❡❢ ✭✇❤✐❝❤ ✇♦✉❧❞ ❛❧❧♦❝❛t❡ st♦r❛❣❡✮✳ ❚❤❡ ♣♦✐♥t❡r r❡❞✐r❡❝t✐♦♥s ❝❛♥ ❜❡ ❞♦♥❡ ✐♥ ❝♦♥st❛♥t s♣❛❝❡ ❜❡❝❛✉s❡ ❡❛❝❤ ♦♥❡ ✐s ❧♦❝❛❧✱ ✐♥❞❡♣❡♥❞❡♥t ♦❢ ♦t❤❡r ♣♦✐♥t✲ ❡rs✳ ■t ❞♦❡s ♥♦t ♠❛tt❡r ❤♦✇ ❧♦♥❣ t❤❡ ❧✐st ✐s✳ ❙♣❛❝❡ ❡✣❝✐❡♥❝② ✐s ❛ ♠❛❥♦r ❛❞✈❛♥t❛❣❡ ♦❢ ❞❡str✉❝t✐✈❡ ❧✐st ♦♣❡r❛t✐♦♥s✳ ■t ♠✉st ❜❡ s❡t ❛❣❛✐♥st t❤❡ ❣r❡❛t❡r r✐s❦ ♦❢ ♣r♦❣r❛♠♠❡r ❡rr♦r✳ ❈♦❞❡ s✉❝❤ ❛s t❤❡ ❛❜♦✈❡ ♠❛② ❧♦♦❦ s✐♠♣❧❡✱ ❜✉t ♣♦✐♥t❡r r❡❞✐r❡❝t✐♦♥s ❛r❡ ❝♦♥s✐❞❡r❛❜❧② ❤❛r❞❡r t♦ ✇r✐t❡ t❤❛♥ ❢✉♥❝t✐♦♥❛❧ ❧✐st ♦♣❡r❛t✐♦♥s✳ ❚❤❡ r❡❞✉❝t✐♦♥ ♠♦❞❡❧ ❞♦❡s ♥♦t ❛♣✲ ♣❧②✳ ❲❡ ❝❛♥♥♦t ❞❡r✐✈❡ ❢✉♥❝t✐♦♥ ❞❡✜♥✐t✐♦♥s ❢r♦♠ ❡q✉❛t✐♦♥s ❜✉t ♠✉st t❤✐♥❦ ❡①♣❧✐❝✐t❧② ✐♥ t❡r♠s ♦❢ t❤❡ ❡✛❡❝ts ♦❢ ✉♣❞❛t✐♥❣ ♣♦✐♥t❡rs✳

❳❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✺✽

Slide 1510

Example of Destructive Reverse

val ml = mlistOf [3, 5, 9]; > val ml = > Cons(3, ref(Cons(5, ref(Cons(9, ref Nil))))) drev ml; > Cons(9, ref(Cons(5, ref(Cons(3, ref Nil))))) ml;

IT’S CHANGED!?

> val it = Cons(3, ref Nil) : int mlist

■♥ t❤❡ ❡①❛♠♣❧❡ ❛❜♦✈❡✱ t❤❡ ♠✉t❛❜❧❡ ❧✐st ❬✸✱✺✱✾❪ ✐s r❡✈❡rs❡❞ t♦ ②✐❡❧❞ ❬✾✱✺✱✸❪✳ ❚❤❡ ❡✛❡❝t ♦❢ ❞r❡✈ ✉♣♦♥ ✐ts ❛r❣✉♠❡♥t ♠❧ ♠❛② ❝♦♠❡ ❛s ❛ s✉r♣r✐s❡✦ ❇❡❝❛✉s❡ ♠❧ ✐s ♥♦✇ t❤❡ ❧❛st ❝❡❧❧ ✐♥ t❤❡ ❧✐st✱ ✐t ❛♣♣❡❛rs ❛s t❤❡ ♦♥❡✲❡❧❡♠❡♥t ❧✐st ❬✸❪✳ ❚❤❡ ✐❞❡❛s ♣r❡s❡♥t❡❞ ✐♥ t❤✐s ❧❡❝t✉r❡ ❝❛♥ ❜❡ ❣❡♥❡r❛❧✐③❡❞ ✐♥ t❤❡ ♦❜✈✐♦✉s ✇❛② t♦ tr❡❡s✳ ❆♥♦t❤❡r ❣❡♥❡r❛❧✐③❛t✐♦♥ ✐s t♦ ♣r♦✈✐❞❡ ❛❞❞✐t✐♦♥❛❧ ❧✐♥❦ ✜❡❧❞s✳ ■♥ ❛ ❞♦✉❜❧②✲❧✐♥❦❡❞ ❧✐st✱ ❡❛❝❤ ♥♦❞❡ ♣♦✐♥ts t♦ ✐ts ♣r❡❞❡❝❡ss♦r ❛s ✇❡❧❧ ❛s t♦ ✐ts s✉❝❝❡ss♦r✳ ■♥ s✉❝❤ ❛ ❧✐st ♦♥❡ ❝❛♥ ♠♦✈❡ ❢♦r✇❛r❞s ♦r ❜❛❝❦✇❛r❞s ❢r♦♠ ❛ ❣✐✈❡♥ s♣♦t✳ ■♥s❡rt✐♥❣ ♦r ❞❡❧❡t✐♥❣ ❡❧❡♠❡♥ts r❡q✉✐r❡s r❡❞✐r❡❝t✐♥❣ t❤❡ ♣♦✐♥t❡r ✜❡❧❞s ✐♥ t✇♦ ❛❞❥❛❝❡♥t ♥♦❞❡s✳ ■❢ t❤❡ ❞♦✉❜❧②✲❧✐♥❦❡❞ ❧✐st ✐s ❛❧s♦ ❝②❝❧✐❝ t❤❡♥ ✐t ✐s s♦♠❡t✐♠❡s ❝❛❧❧❡❞ ❛ r✐♥❣ ❜✉✛❡r ❬✶✸✱ ♣❛❣❡ ✸✸✶❪✳ ❚r❡❡ ♥♦❞❡s ♥♦r♠❛❧❧② ❝❛rr② ❧✐♥❦s t♦ t❤❡✐r ❝❤✐❧❞r❡♥✳ ❖❝❝❛s✐♦♥❛❧❧②✱ t❤❡② ✐♥st❡❛❞ ❤❛✈❡ ❛ ❧✐♥❦ t♦ t❤❡✐r ♣❛r❡♥t✱ ♦r s♦♠❡t✐♠❡s ❧✐♥❦s ✐♥ ❜♦t❤ ❞✐r❡❝t✐♦♥s✳

❳❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✺✾ ▲❡❛r♥✐♥❣ ❣✉✐❞❡✳ ❘❡❧❛t❡❞ ♠❛t❡r✐❛❧ ✐s ✐♥ ▼▲ ❢♦r t❤❡ ❲♦r❦✐♥❣ Pr♦❣r❛♠♠❡r✱ ♣❛❣❡s ✸✷✻✕✸✸✾✳ ❊①❡r❝✐s❡ ✶✺✳✶ ❲r✐t❡ ❛ ❢✉♥❝t✐♦♥ t♦ ❝♦♣② ❛ ♠✉t❛❜❧❡ ❧✐st✳ ❲❤❡♥ ♠✐❣❤t ②♦✉ ✉s❡ ✐t❄ ❊①❡r❝✐s❡ ✶✺✳✷ ❲❤❛t ✐s t❤❡ ✈❛❧✉❡ ♦❢ ♠❧✶ ✭r❡❣❛r❞❡❞ ❛s ❛ ❧✐st✮ ❛❢t❡r t❤❡ ❢♦❧❧♦✇✐♥❣ ❞❡❝❧❛r❛t✐♦♥s ❛♥❞ ❝♦♠♠❛♥❞s ❛r❡ ❡♥t❡r❡❞ ❛t t♦♣ ❧❡✈❡❧❄ ❊①♣❧❛✐♥ t❤✐s ♦✉t❝♦♠❡✳

✈❛❧ ♠❧✶ ❂ ♠❧✐st❖❢❬✶✱✷✱✸❪ ❛♥❞ ♠❧✷ ❂ ♠❧✐st❖❢❬✹✱✺✱✻✱✼❪❀ ❥♦✐♥✭♠❧✶✱ ♠❧✷✮❀ ❞r❡✈ ♠❧✷❀

❊①❡r❝✐s❡ ✶✺✳✸ ❈♦❞❡ ❞❡str✉❝t✐✈❡ r❡✈❡rs❡ ✉s✐♥❣ ✇❤✐❧❡ ✐♥st❡❛❞ ♦❢ r❡❝✉rs✐♦♥✳ ❊①❡r❝✐s❡ ✶✺✳✹ ❲r✐t❡ ❛ ❢✉♥❝t✐♦♥ t♦ ❝♦♣② ❛ ❝②❝❧✐❝ ❧✐st✱ ②✐❡❧❞✐♥❣ ❛♥♦t❤❡r ❝②❝❧✐❝ ❧✐st ❤♦❧❞✐♥❣ t❤❡ s❛♠❡ ❡❧❡♠❡♥ts✳

❳❱ ❋♦✉♥❞❛t✐♦♥s ♦❢ ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡ ✶✻✵

❘❡❢❡r❡♥❝❡s

❬✶❪ ❍❛r♦❧❞ ❆❜❡❧s♦♥ ❛♥❞ ●❡r❛❧❞ ❏✳ ❙✉ss♠❛♥✳ ❙tr✉❝t✉r❡ ❛♥❞ ■♥t❡r♣r❡t❛t✐♦♥ ♦❢ ❈♦♠♣✉t❡r Pr♦❣r❛♠s✳ ▼■❚ Pr❡ss✱ ✶✾✽✺✳ ❬✷❪ ❆❧❢r❡❞ ❱✳ ❆❤♦✱ ❏♦❤♥ ❊✳ ❍♦♣❝r♦❢t✱ ❛♥❞ ❏❡✛r❡② ❉✳ ❯❧❧♠❛♥✳ ❚❤❡ ❉❡s✐❣♥ ❛♥❞ ❆♥❛❧②s✐s ♦❢ ❈♦♠♣✉t❡r ❆❧❣♦r✐t❤♠s✳ ❆❞❞✐s♦♥✲❲❡s❧❡②✱ ✶✾✼✹✳ ❬✸❪ ❈✳ ●♦r❞♦♥ ❇❡❧❧ ❛♥❞ ❆❧❧❡♥ ◆❡✇❡❧❧✳ ❈♦♠♣✉t❡r ❙tr✉❝t✉r❡s✿ ❘❡❛❞✐♥❣s ❛♥❞ ❊①❛♠♣❧❡s✳ ▼❝●r❛✇✲❍✐❧❧✱ ✶✾✼✶✳ ❬✹❪ ❆rt❤✉r ❲✳ ❇✉r❦s✱ ❍❡r♠❛♥ ❍✳ ●♦❧❞st✐♥❡✱ ❛♥❞ ❏♦❤♥ ✈♦♥ ◆❡✉♠❛♥♥✳ Pr❡❧✐♠✐♥❛r② ❞✐s❝✉ss✐♦♥ ♦❢ t❤❡ ❧♦❣✐❝❛❧ ❞❡s✐❣♥ ♦❢ ❛♥ ❡❧❡❝tr♦♥✐❝ ❝♦♠♣✉t✐♥❣ ✐♥str✉♠❡♥t✳ ❘❡♣r✐♥t❡❞ ❛s ❈❤❛♣t❡r ✹ ♦❢ ❇❡❧❧ ❛♥❞ ◆❡✇❡❧❧ ❬✸❪✱ ✜rst ♣✉❜❧✐s❤❡❞ ✐♥ ✶✾✹✻✳ ❬✺❪ ❚❤♦♠❛s ❍✳ ❈♦r♠❡♥✱ ❈❤❛r❧❡s ❊✳ ▲❡✐s❡rs♦♥✱ ❛♥❞ ❘♦♥❛❧❞ ▲✳ ❘✐✈❡st✳ ■♥tr♦❞✉❝t✐♦♥ t♦ ❆❧❣♦r✐t❤♠s✳ ▼■❚ Pr❡ss✱ ✶✾✾✵✳ ❬✻❪ ❘♦♥❛❧❞ ▲✳ ●r❛❤❛♠✱ ❉♦♥❛❧❞ ❊✳ ❑♥✉t❤✱ ❛♥❞ ❖r❡♥ P❛t❛s❤♥✐❦✳ ❈♦♥❝r❡t❡ ▼❛t❤❡♠❛t✐❝s✿ ❆ ❋♦✉♥❞❛t✐♦♥ ❢♦r ❈♦♠♣✉t❡r ❙❝✐❡♥❝❡✳ ❆❞❞✐s♦♥✲❲❡s❧❡②✱ ✷♥❞ ❡❞✐t✐♦♥✱ ✶✾✾✹✳ ❬✼❪ ▼❛tt❤❡✇ ❍❛❧❢❛♥t ❛♥❞ ●❡r❛❧❞ ❏❛② ❙✉ss♠❛♥✳ ❆❜str❛❝t✐♦♥ ✐♥ ♥✉♠❡r✐❝❛❧ ♠❡t❤♦❞s✳ ■♥ ▲■❙P ❛♥❞ ❋✉♥❝t✐♦♥❛❧ Pr♦❣r❛♠♠✐♥❣✱ ♣❛❣❡s ✶✕✼✳ ❆❈▼ Pr❡ss✱ ✶✾✽✽✳ ❬✽❪ ❏♦❤♥ ❍✉❣❤❡s✳ ❲❤② ❢✉♥❝t✐♦♥❛❧ ♣r♦❣r❛♠♠✐♥❣ ♠❛tt❡rs✳ ❈♦♠♣✉t❡r ❏♦✉r♥❛❧✱ ✸✷✿✾✽✕✶✵✼✱ ✶✾✽✾✳ ❬✾❪ ❉♦♥❛❧❞ ❊✳ ❑♥✉t❤✳ ❚❤❡ ❆rt ♦❢ ❈♦♠♣✉t❡r Pr♦❣r❛♠♠✐♥❣✱ ✈♦❧✉♠❡ ✸✿ ❙♦rt✐♥❣ ❛♥❞ ❙❡❛r❝❤✐♥❣✳ ❆❞❞✐s♦♥✲❲❡s❧❡②✱ ✶✾✼✸✳ ❬✶✵❪ ❉♦♥❛❧❞ ❊✳ ❑♥✉t❤✳ ❚❤❡ ❆rt ♦❢ ❈♦♠♣✉t❡r Pr♦❣r❛♠♠✐♥❣✱ ✈♦❧✉♠❡ ✶✿ ❋✉♥❞❛♠❡♥t❛❧ ❆❧❣♦r✐t❤♠s✳ ❆❞❞✐s♦♥✲❲❡s❧❡②✱ ✷♥❞ ❡❞✐t✐♦♥✱ ✶✾✼✸✳ ❬✶✶❪ ❘✳ ❊✳ ❑♦r❢✳ ❉❡♣t❤✲✜rst ✐t❡r❛t✐✈❡✲❞❡❡♣❡♥✐♥❣✿ ❛♥ ♦♣t✐♠❛❧ ❛❞♠✐ss✐❜❧❡ tr❡❡ s❡❛r❝❤✳ ❆rt✐✜❝✐❛❧ ■♥t❡❧❧✐❣❡♥❝❡✱ ✷✼✿✾✼✕✶✵✾✱ ✶✾✽✺✳ ❬✶✷❪ ❙t❡♣❤❡♥ ❑✳ P❛r❦ ❛♥❞ ❑❡✐t❤ ❲✳ ▼✐❧❧❡r✳ ❘❛♥❞♦♠ ♥✉♠❜❡r ❣❡♥❡r❛t♦rs✿

• ♦♦❞ ♦♥❡s ❛r❡ ❤❛r❞ t♦ ✜♥❞✳ ❈♦♠♠✉♥✐❝❛t✐♦♥s ♦❢ t❤❡ ❆❈▼✱

✸✶✭✶✵✮✿✶✶✾✷✕✶✷✵✶✱ ❖❝t♦❜❡r ✶✾✽✽✳ ❋♦❧❧♦✇✲✉♣ ❞✐s❝✉ss✐♦♥ ✐♥ ❈♦♠♠✳ ❆❈▼ ✸✻ ✭✼✮✱ ❏✉❧② ✶✾✾✸✱ ♣♣✳ ✶✵✺✲✶✶✵✳ ❬✶✸❪ ▲❛✇r❡♥❝❡ ❈✳ P❛✉❧s♦♥✳ ▼▲ ❢♦r t❤❡ ❲♦r❦✐♥❣ Pr♦❣r❛♠♠❡r✳ ❈❛♠❜r✐❞❣❡ ❯♥✐✈❡rs✐t② Pr❡ss✱ ✷♥❞ ❡❞✐t✐♦♥✱ ✶✾✾✻✳ ❬✶✹❪ ❘♦❜❡rt ❙❡❞❣❡✇✐❝❦✳ ❆❧❣♦r✐t❤♠s✳ ❆❞❞✐s♦♥✲❲❡s❧❡②✱ ✷♥❞ ❡❞✐t✐♦♥✱ ✶✾✽✽✳ ❬✶✺❪ ❏❡✛r❡② ❉✳ ❯❧❧♠❛♥✳ ❊❧❡♠❡♥ts ♦❢ ▼▲ Pr♦❣r❛♠♠✐♥❣✳ Pr❡♥t✐❝❡✲❍❛❧❧✱ ✶✾✾✸✳ ❬✶✻❪ ➴✳ ❲✐❦strö♠✳ ❋✉♥❝t✐♦♥❛❧ Pr♦❣r❛♠♠✐♥❣ ✉s✐♥❣ ▼▲✳ Pr❡♥t✐❝❡✲❍❛❧❧✱ ✶✾✽✼✳