Question

I’m trying to make a function in SML that takes a list and an int and returns a list of all elements that are less than the int int * int list -> int list I wrote the following code:

- fun less (e, L) = 
=   map (fn a => if a < e then a else []) L;

also with the following code it doesnt work also:

- fun less (e, L) = 
=   map (fn a => if a < e then a) L;

and the error im getting is :

stdIn:22.15-22.38 Error: types of if branches do not agree [overload]
  then branch: 'Z
  else branch: 'Y list
  in expression:
    if a < e then a else nil

I think the problem is with the else part but I dont know what to put in it to work, anybody have any suggestion? I should use either map, foldl, or foldr functions.

EDIT:

- fun less (e, L) = 
=   let
=       val acc = []
=   in
=       foldr (fn a => if a < e then a::acc else acc) acc L
=   end;

still gives me error, the following error :

stdIn:241.3-241.54 Error: operator and operand don't agree [overload]
  operator domain: 'Z * 'Y -> 'Y
  operand:         'X -> 'X list
  in expression:
    foldr (fn a => if <exp> < <exp> then <exp> :: <exp> else acc)

Answer 1

The error message is clear; since a has type int and [] has type 'a list, their types are mismatched.

The problem is you chose the wrong high-order function for the task. The filter on List structure is best suited here:

fun less (e, L) = filter (fn a => a < e) L

You could use recursion to implement less explicitly, or use foldl/foldr to accumulate filtered lists. However, map seems irrelevant here.

EDIT:

I will give a hint about using foldl/foldr. You start with empty list as the accumulator. Prepend an element to the accumulator whenever that element is smaller than e; otherwise, return the accumulator.

EDIT 2:

You forgot to pass acc as an argument in the lambda function:

fun less (e, L) = foldr (fn (a, acc) => if a < e then a::acc else acc) [] L

And the let..in..end part is redundant because you use [] as the accumulator only.