类型不匹配的OCaml？

Question

I have a problem, OCaml thinks the a and s parameters of my function are unit list s, but they have to be 'a list and string respectively. The function has to output the list elements separated by the given separator.

The result has to be a string, with the below input: "This-is-label"

PS I know about match, but I can`t use it

let rec function1 a s =
    if a = [] then failwith "Empty list" else 
    if List.tl a = [] then List.hd a else
    if List.tl a != [] then List.hd a; s; function1 List.tl a s
    ;;

function1 ["This"; "is"; "label"] "-";;

Answer 1

It seems you expect this expression to be a string:

List.hd a; s; function1 List.tl a s

However, the meaning of the ; operator is to evaluate the expression at the left and then ignore its value. (It is also considered bad form if the type isn't unit.) Then evaluate the expression at the right, which is the value of the expression.

So this expression says to evaluate List.hd a , then forget the value. Then evaluate s , then forget the value. Then evaluate the recursive call.

So the first problem is to assemble these things into a string.

The ^ operator concatenates two strings. So something like this is closer to what you want:

List.hd a ^ s ^ function1 (List.tl a) s

Note that you need to parenthesize the call to List.tl . Otherwise it looks like two separate parameters to function1 .

Answer 2

The problem in your code are missing () around List.tl a in the recursive call. Also ^ must be used to concatenate the strings instead of ; . The code is still very un-ocaml like.

There really is no good way to do this without pattern matching. If this is a homework assignment where you aren't allowed to use pattern matching then please give your instructor a big kick in the behind.

The order of arguments also would be better the other way around, have the separator as first argument. That way you can bind the function to a separator and reuse it many times.

Two alternative implementations:

let rec join s = function
| [] -> "" (* or failwith "Empty list" if you insist *)
| [x] -> x
| x::xs -> x ^ s ^ join s xs

let join s a =
  let (res, _) =
    List.fold_left
      (fun (acc, sep) x -> (x ^ sep ^ acc, s))
      ("", "")
      a
   in
   res