Question

I am having two lists in SML, lets say list A [(a,b,c),(d,e,f)] and list B [b,e]. I want to count how many occurrence of each item in B that matches the second element of each triple in A. The output should be 2. Because b and e each occurs once in A.

This is my code so far but my counter is always set to 0 when I move from one element to another in B. I know in Java this will just be a simple double for loop.

fun number_in_months (d : (int * int * int ) list, m : (int) list) = 
    if null m then 0 
    else if null d then number_in_months(d, tl m)
    else if (#2(hd d)) = (hd m) then 1 + number_in_months (tl d, m)
    else number_in_months(tl d, m)

Answer 1

As you mention, it would be a nested/double loop in any imperative programming language. What you are actually missing is the second loop.

Your “inner” loop goes through all elements of d, and when this is done, your “outer” loop tries to pop the top element of m and start all over, as seen from this line of your code:

else if null d then number_in_months(d, tl m)

However as you can see, you have just tested the list d to be empty and you supply this (exact same list) to your recursive call on the tail of m, which will then fall in this same case for each successive call until m is also empty and you return 0.

Thus what you are missing is to “keep a copy” of the original input list m. This can be done in various ways, but an inner (helper) function is properly the most used one and it even “looks” like a nested loop

fun number_in_months (d, m) =
    let
      fun nim' ([], y::ys) = nim (d, ys)                 (* 1 *)
        | nim' (_, []) = 0                               (* 2 *)
        | nim' ((_, x2, _) :: xs, yss as (y::ys)) = ...  (* 3 *)
    in
      nim'(d, m)
    end

Using pattern matching the above code gets much simpler and less error prone. In case 1, the “inner” loop has gone through all elements in d, thus the recursive call using d from the outer function which is not changed at any time. In case 2, the “outer” loop has gone through all elements of m and we return 0 (the neutral element of addition). In case 3 we do the actual work. Here pattern matching is used such that we don’t need to enforce the type of the argument and we don’t need to pull out the 2nd element of the triple, we already have it in the variable x2. All that is needed is to do the computation and make a recursive call with xs and yss.

When doing it this way, the inner (helper) function is using a “copy” of the original input list d and stepping through its elements (potentially modifying it), but we always got a reference to the original input list, which we can use if/when needed.