(This is a post for CS320 Boston University.)

This is a page for most commonly seen methods about a functional list (in ATS). And this is in Haskell.

Here are some commonly seen ones:

  • head takes a list, returns the first element.
  • last takes a list, returns the last element.
  • tail takes a list, returns it without the first element.
  • take takes the beginning n elements of a list.
  • drop drops the beginning n elements and returns the rest.
  • zip zips two (or more) lists into a list of pairs (or tuples).
  • map applies a function to each element of the list to get another list.
  • fold aggregates a list into a value by applying a binary function iteratively.

Please implement the following functions.

implement main () = print "Hello World!"

datatype intlist =
    | ilist_cons of (int, intlist)
    | ilist_nil of ()

datatype intintlist = 
    | iilist_cons of ((int, int), intintlist)
    | iilist_nil of ()
    
      
extern fun zip (xs: intlist, ys: intlist): intintlist
extern fun sum (xs: intlist): int
extern fun reverse (xs: intlist): intlist
extern fun map (f: int -> int, xs: intlist): intlist

extern fun addtwo (x: int): int
implement addtwo (x) = x + 2

A possible solutions:

implement zip (xs, ys) = 
    case+ xs of 
    | ilist_nil () => iilist_nil ()
    | ilist_cons (x, xs) => 
        case+ ys of 
        | ilist_nil () => iilist_nil ()
        | ilist_cons (y, ys) => iilist_cons ((x, y), zip (xs, ys))
        
implement sum (xs) = case+ xs of
    | ilist_cons (x, xs) => x + sum (xs)
    | ilist_nil () => 0
    
implement reverse (xs) = let
    fun do_reverse (xs: intlist, ys: intlist): intlist = 
        case+ xs of 
        | ilist_cons (x, xs) => do_reverse (xs, ilist_cons (x, ys))
        | ilist_nil () => ys
in 
    do_reverse (xs, ilist_nil ())
end

implement map (f, xs) = case+ xs of
    | ilist_cons (x, xs) => ilist_cons (f (x), map (f, xs))
    | ilist_nil () => ilist_nil ()

extern fun print_ilist (xs: intlist): void
implement print_ilist (xs) = case+ xs of 
    | ilist_cons (x, xs) => () where { 
        val () = fprint! (stdout_ref, x, " ")
        val () = print_ilist (xs)
        }
    | ilist_nil () => ()
    
extern fun print_iilist (xs: intintlist): void
implement print_iilist (xs) = case+ xs of 
    | iilist_cons ((x,y), xs) => () where { 
        val () = fprint! (stdout_ref, "(", x, ",", y, ") ")
        val () = print_iilist (xs)
        }
    | iilist_nil () => ()