Exercises #1

1. Write the identity function (the I combinator), which simply returns its argument (any type of argument) unchanged:

   # I :: alpha -> alpha
   proc I {x} {...}

   Examples:

   I 12
   => 12
   I foo
   => foo
   I {string length abracadabra}
   => {string length abracadabra}

   Why is this a useful function?

2. Write the K combinator, which takes two arguments and always returns its first argument, unchanged:

   # K :: alpha beta -> alpha
   proc K {x y} {...}

   Examples:

   K 0 456
   => 0
   K foo 1
   => foo

   Why is this a useful function?

3. Write the function change, which takes a whole number as it argument and returns a list that represents how to "make change" for that number, taken as a number of cents. You can use quarters, dimes, nickels and pennies to make change, and so the result list should be of length four, sorted from most valuable coin to least valuable. You should make change using as few coins as possible.

   # change :: num -> [num]
   proc change {n} {...}
   change 75
   => 3 0 0 0
   change 23
   => 0 2 0 3

4. Write the iota function, which takes a numeric argument n and returns a list of numbers of length n which are the numbers from 0 to n-1.

   # iota :: num -> [num]
   proc iota {n} {...}

   Examples:

   iota 3
   => 0 1 2
   iota 20
   => 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

   Does your function work for 0? What should your function do for negative arguments?

5. Write the function incrlist, which takes one argument, a list of numbers, and returns a list of equal length as a result, in which each element is the successor to the corresponding element of the argument list.

   # incrlist :: [num] -> [num]
   proc incrlist {L} {...}
   incrlist {34 987 1 567 -23 8}
   => 35 988 2 568 -22 9
   incrlist [iota 12]
   => 1 2 3 4 5 6 7 8 9 10 11 12

   Does your function work for the empty list?

6. Write the function strlenlist, which takes one argument, a list of strings, and returns a list of equal length as a result, in which each element is the string length of the corresponding element of the argument list.

   # strlenlist :: [str] -> [num]
   proc strlenlist {L} {...}
   strlenlist {34 987 1 567 -23 8}
   => 2 3 1 3 3 1
   strlenlist {foo bar antidisestablishmentarianism}
   => 3 3 28

   Does your function work for the empty list?

7. Write sumlist, which takes one argument, a list of numbers, and returns, as result, a single number: the sum of the numbers in the argument list.

   # sumlist :: [num] -> num
   proc sumlist {L} {...}
   sumlist [iota 3]
   => 3
   sumlist {34 987 1 567 -23 8}
   => 1574

8. Write multlist, which takes one argument, a list of numbers, and returns, as result, a single number: the product of the numbers in the argument list.

   # multlist :: [num] -> num
   proc multlist {L} {...}
   multlist [iota 3]
   => 0
   multlist [incrlist [iota 3]]
   => 3
   multlist {34 987 1 567 -23 8}
   => 793928272

9. Write catlist, which takes one argument, a list of strings, and returns, as result, a single string: the concatenation of the strings in the argument list.

   # catlist :: [str] -> str
   proc catlist {L} {...}
   catlist [iota 3]
   => 012
   catlist [incrlist [iota 3]]
   => 123
   list {foo bar antidisestablishmentarianism}
   => foobarantidisestablishmentarianism

10. Write factorial, iteratively.

    # factorial :: num -> num
    proc fact {num} {...}
    factorial 3
    => 6
    factorial 6
    => 720
    factorial 12
    => 479001600

11. Write factorial, recursively.
12. Write factorial, neither iteratively nor recursively, using only functions that you've written in this set of exercises.