使用折叠/映射比较SML中的两个列表？

Question

Say I have two lists, [1,2,3] and [9,2,3] . Say I'm given a third value, 2 . If I want to find out if this value is in both lists, but I can only use foldl/foldr/map to do so (no let environments or custom recursion outside of map/foldr/foldl), how can I do so? This is a homework question for a programming class and I've been stuck on it for a week now.

Answer 1

There is a number of things you can do to approach this assignment:

1. Write a stub for the function, so you know what you're dealing with:

    fun isInBoth (xs, ys, z) = ... 

   where this function returns something of type bool .

2. Think about how you might solve this if it were just membership in one list:

    (* Using built-in functions *) fun isInList (xs, z) = List.exists (fn x => x = z) xs (* Using recursion directly *) fun isInList ([], z) = false | isInList (x::xs, z) = x = z orelse isInList (xs, z) 

3. Rule out the use of map , since this produces a 'b list , not a bool .

4. Proceed to solve this using folding for just one list:

    fun isInList (xs, z) = foldl (fn (x, acc) => ...) ... xs 

   where acc is the value that foldl accumulates upon each recursive call.

   The first ... must reflect whether the presence of the value x in the list makes a difference to the result of the function, or if any previously regarded element made a difference (using acc as a proxy).

   The second ... is a bool that represents the default value in case xs is empty, and is the base case for the recursion that foldl performs.

   Be aware that folding in Standard ML is an eager process: It goes through the whole list, beyond when it has come to the conclusion that an element is present. For that reason, on average, List.exists is a better combinator for searching a single list. In lazily evaluated languages, folding might be equivalent.

5. Proceed to solve this for two lists, trivially:

    fun isInBoth (xs, ys, z) = isInList (xs, z) andalso isInList(ys, z) 

6. (Optionally,) consider how one might intertwine these two recursive calls and create pairwise folding. Actually, there's a function called ListPair.foldl that works like this:

    (* Finds the largest positive integer in two lists, or 0 *) fun max3 (x, y, z) = Int.max (x, Int.max(y, z)) fun maxTwoLists (xs, ys) = ListPair.foldl max3 0 (xs, ys) 

   but it comes with an annoying side-effect:

    val huh = maxTwoLists ([1,2,3], [1,2,3,4]) (* gives 3 *) 

   So if you want to iterate through two lists and regard their elements pairwise, and continue looking in the one list when the other ends, and stop folding in case your criterion is met or no longer can be met, you are dealing with a recursion scheme that neither List.foldl nor ListPair.foldl supports out of the box. If this were not a school exercise that demanded folding, this would be one solution:

    fun isInList (xs, z) = List.exists (fn x => x = z) xs fun isInBoth (x::xs, y::ys, z) = x = z andalso isInList (y::ys, z) orelse (* no needs to look at more xs *) y = z andalso isInList (x::xs, z) orelse (* no needs to look at more ys *) isInBoth (xs, ys, z) (* keep looking in both *) | isInBoth ([], ys, z) = false (* not found in xs *) | isInBoth (xs, [], z) = false (* not found in ys *) 

   Abstracting the recursion pattern into a function similar to ListPair.foldl probably isn't that useful.

Answer 2

You can simply use some form of guarantee from the foldl function, combined with the and operator as :

fun intersection l1 l2 v = (#1 (foldl (fn (x,y) => if (x = (#2 y)) then (true, (#2 y)) else y) (false, v) l1)) andalso (#1 (foldl (fn (x,y) => if (x = (#2 y)) then (true, (#2 y)) else y) (false, v) l2))

This is elegant, simple and in one-line (though, arguably, for style purposes you probably want it to be in more than one line).