CODEWITHSUNDEEP
functional-programmingocaml
user836353222
user836353222

Reputation: 17

expression has type 'a list -> 'b list but an expression was expected of type 'b list

This is my function

let rec helper inputList = function
  | [] -> []
  | a :: b :: hd -> 
    if a = b then helper ([b::hd]) 
    else a :: helper (b::hd)

It's not complete, however I can't see why I keep getting the error in the title at helper ([b::hd]). I've tried helper (b::hd) or helper (b::hd::[]) however all come up with errors. How do I make it so that it works?

Upvotes: 1

Views: 990

Answers (2)

willeM_ Van Onsem
willeM_ Van Onsem

Reputation: 476659

There are multiple errors here. One is that the keyword function means we have an implicit parameter over which we are working. So the pattern matching happens on that "invisible" parameter. But here you defined probably the explicit one: inputList. So we can remove that one:

let rec helper = function
  | [] -> []
  | a :: b :: hd -> if a = b then helper ([b::hd]) else a :: helper (b:: hd)

Next there is a problem with the types: in the recursion, you use:

  1. helper ([b::hd]); and
  2. a :: helper (b:: hd)

But you put these on the same line, and that makes no sense, since the first one passes a list of lists of elements, and the second a list of elements. So the result of the first one would be a list of list of elements, and the second one a list of elements. It does not make sense to merge these.

If I understood correctly that you want to ensure that no two consecutive elements should occur that are equal, then we should rewrite it to:

let rec helper = function
  | [] -> []
  | a :: b :: hd -> if a = b then helper (b::hd) else a :: helper (b:: hd)

You have defined two patterns here:

  1. one for the empty list; and
  2. one for a list with at least two elements.

The second one will perform recursion on the tail of the list b :: hd. So that means that eventually when we pass it a list with n elements, it will recursively work on a list with n-1 elements, n-2 elements, etc. But eventually it will have one element. And there is no case for that. So we need to add a case for the one element pattern:

let rec helper = function
  | [] -> []
  | h :: [] -> h :: []
  | a :: b :: hd -> if a = b then helper (b::hd) else a :: helper (b:: hd)

Upvotes: 1

Jeffrey Scofield
Jeffrey Scofield

Reputation: 66803

When you use function you are supplying a pattern for the parameter of the function. But you already have a parameter named inputList. So this function helper is expecting two parameters (but it ignores the first).

You can fix this by removing inputList.

You also have a problem in your first recursive call to helper. Your expression [b :: hd] is a list of lists. I suspect that you want something more like just b :: hd here.

There is at least one other problem, but I hope this helps get you started.

Upvotes: 2

Related Questions