Skip to content
GitLab
Menu
Projects
Groups
Snippets
/
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
Menu
Open sidebar
Logan Ince
cse34122wipublic
Commits
6b1044ae
Commit
6b1044ae
authored
Jan 19, 2022
by
Dan Grossman
Browse files
typo in string, if/then/else formatting
parent
fe0f3b65
Changes
3
Hide whitespace changes
Inline
Sidebyside
lecture/lec07/lec07.ml
View file @
6b1044ae
...
...
@@ 19,7 +19,7 @@ let rec meh_zip3_v2 (xs,ys,zs) = (* like life without && and  *)

[]
>
(
match
zs
with

[]
>
[]

_
>
failwith
"zip3 length mismatch"
)

_
>
failwith
"zip3 leng
h
t mismatch"
)

_
>
failwith
"zip3 lengt
h
mismatch"
)

x
::
xs'
>
(
match
ys
with

[]
>
failwith
"zip3 length mismatch"

y
::
ys'
>
(
match
zs
with
...
...
lecture/lec08/lec08live.ml
0 → 100755
View file @
6b1044ae
(* CSE 341, Lecture 8 *)
#
utop_prompt_dummy
let
_
=
UTop
.
set_show_box
false
(* Lecture 8: FirstClass Functions *)
let
double
x
=
x
*
2
let
incr
x
=
x
+
1
let
funcs
=
[
double
;
incr
]
let
rec
apply_funcs
(
fs
,
x
)
=
match
fs
with

[]
>
x

f
::
fs'
>
apply_funcs
(
fs'
,
f
x
)
let
foo
=
apply_funcs
(
funcs
,
100
)
(* binds foo to 201 *)
let
bar
=
apply_funcs
(
List
.
rev
funcs
,
100
)
(* binds bar to 202 *)
(* it should really bother us to write these functions separately *)
let
rec
increment_n_times_bothersome
(
n
,
x
)
=
if
n
=
0
then
x
else
1
+
increment_n_times_bothersome
(
n

1
,
x
)
let
rec
double_n_times_bothersome
(
n
,
x
)
=
if
n
=
0
then
x
else
2
*
double_n_times_bothersome
(
n

1
,
x
)
let
rec
tail_n_times_bothersome
(
n
,
xs
)
=
if
n
=
0
then
xs
else
List
.
tl
(
tail_n_times_bothersome
(
n

1
,
xs
))
(* much better: abstract the common pieces into a function *)
let
rec
n_times
(
f
,
n
,
x
)
=
if
n
=
0
then
x
else
f
(
n_times
(
f
,
n

1
,
x
))
(* we can now implement the 3 bothersome functions above in one line each *)
let
increment_n_times
(
n
,
x
)
=
n_times
(
incr
,
n
,
x
)
let
double_n_times
(
n
,
x
)
=
n_times
(
double
,
n
,
x
)
let
tail_n_times
(
n
,
xs
)
=
n_times
(
List
.
tl
,
n
,
xs
)
(* and nothing stops us from using n_times in places we didn't originally plan *)
let
triple
x
=
3
*
x
let
triple_n_times
(
n
,
x
)
=
n_times
(
triple
,
n
,
x
)
(* polymorphic but not higher order *)
let
rec
len
xs
=
match
xs
with

[]
>
0

_
::
xs'
>
1
+
len
xs'
(* higher order but not polymorphic *)
let
rec
times_until_zero
(
f
,
x
)
=
if
x
=
0
then
0
else
1
+
times_until_zero
(
f
,
f
x
)
(* two very useful and very common higherorder functions *)
let
rec
map
(
f
,
xs
)
=
match
xs
with

[]
>
[]

x
::
xs'
>
(
f
x
)
::
(
map
(
f
,
xs'
))
let
rec
filter
(
f
,
xs
)
=
match
xs
with

[]
>
[]

x
::
xs'
>
if
f
x
then
x
::
filter
(
f
,
xs'
)
else
filter
(
f
,
xs'
)
(* motivating anonymous functions *)
(* if we just need is_even for only_evens, better to use local function *)
let
only_evens2
xs
=
let
is_even
x
=
x
mod
2
=
0
in
filter
(
is_even
,
xs
)
(* actually, we could define it *right* where we need it *)
let
only_evens3
xs
=
filter
((
let
is_even
x
=
x
mod
2
=
0
in
is_even
)
,
xs
)
(* seems kind of silly to have a let expression whose body is the variable...
can we do better? *)
(* not like this. a let binding is not an expression! *)
(*
let only_evens4 xs =
filter ((let is_even x = x mod 2 = 0), xs)
*)
(* but an anonymous function is an expression! *)
let
only_evens5
xs
=
filter
((
fun
x
>
x
mod
2
=
0
)
,
xs
)
(* bad style: the 'if e then true else false' of functions *)
(* "unnecessary function wrapping" *)
let
tail_n_times_bad_style
(
n
,
xs
)
=
n_times
((
fun
ys
>
List
.
tl
ys
)
,
n
,
xs
)
(* good style *)
let
tail_n_times_good_style
(
n
,
xs
)
=
n_times
(
List
.
tl
,
n
,
xs
)
(*  *)
(* you can return functions from functions as well *)
let
mult_by_n
n
=
fun
x
>
n
*
x
(* notice how this is different from a simple multiplication function *)
let
multiply
(
n
,
x
)
=
n
*
x
(* look at the types! *)
(* another example *)
let
double_or_triple
f
=
if
f
7
then
fun
x
>
2
*
x
else
fun
x
>
3
*
x
let
roundabout_double
=
double_or_triple
(
fun
x
>
x

3
=
4
)
let
roundabout_nine
=
(
double_or_triple
(
fun
x
>
x
=
42
))
3
(*  *)
(* higherorder functions over our own recursive variant types *)
type
exp
=

Const
of
int

Negate
of
exp

Add
of
exp
*
exp

Multiply
of
exp
*
exp
let
rec
true
_of_all_constants
(
f
,
e
)
=
match
e
with

Const
n
>
f
n

Negate
e'
>
true
_of_all_constants
(
f
,
e'
)

Add
(
e1
,
e2
)
>
true
_of_all_constants
(
f
,
e1
)
&&
true
_of_all_constants
(
f
,
e2
)

Multiply
(
e1
,
e2
)
>
true
_of_all_constants
(
f
,
e1
)
&&
true
_of_all_constants
(
f
,
e2
)
let
all_even_constants
e
=
true
_of_all_constants
((
fun
x
>
x
mod
2
=
0
)
,
e
)
lecture/lec08/lec08.ml
View file @
6b1044ae
...
...
@@ 72,9 +72,10 @@ let rec map (f, xs) =
let
rec
filter
(
f
,
xs
)
=
match
xs
with

[]
>
[]

x
::
xs'
>
if
f
x
then
x
::
filter
(
f
,
xs'
)
else
filter
(
f
,
xs'
)

x
::
xs'
>
if
f
x
then
x
::
filter
(
f
,
xs'
)
else
filter
(
f
,
xs'
)
(* motivating anonymous functions *)
...
...
Write
Preview
Supports
Markdown
0%
Try again
or
attach a new file
.
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment