Como posso fazer com que essa expressão seja do tipo string em vez de string -> string?

Quando testo sua função, obtenho:

# let remplace_positions lst c str =
  let rec acc lst c str n l_index ret =
    match (n >= String.length str, List.nth lst l_index = n) with
    | true, _ -> ret
    | _, true -> acc lst c (n+1) (l_index+1) (ret ^ (String.make 1 c))
    | _, _ -> acc lst c (n+1) (l_index+1) (ret ^ (String.make 1 (String.get str n)))
  in
  acc lst c str 0 0 "";;
Error: This expression has type int
       but an expression was expected of type string

Referindo-se ao (n+1)in line:

    | _, true -> acc lst c (n+1) (l_index+1) (ret ^ (String.make 1 c))

Isso ocorre porque você indicou que o terceiro argumento accdeveria ser um string, mas depois você passa um int.

Eu sugeriria que você está passando argumentos demais para accde qualquer forma, dificultando o controle deles. Se eles não mudarem, não há necessidade de que a função interna os tome como argumentos. A função interna será capaz de acessar ligações do escopo externo, desde que não sejam sombreadas.

Também podemos fatorar a transformação de um caractere em uma string.

let remplace_positions lst c str =
  let char_to_str c = String.make 1 c in
  let rec acc str n l_index ret =
    match (n >= String.length str, List.nth lst l_index = n) with
    | true, _ -> ret
    | _, true -> acc (n+1) (l_index+1) (ret ^ char_to_str c)
    | _, _ -> acc (n+1) (l_index+1) (ret ^ char_to_str (String.get str n))
  in
  acc str 0 0 ""

Mesmo erro, mas código um pouco mais fácil de ler.

Agora, vamos remover a passagem desnecessária do strargumento:

let remplace_positions lst c str =
  let char_to_str c = String.make 1 c in
  let rec acc n l_index ret =
    match (n >= String.length str, List.nth lst l_index = n) with
    | true, _ -> ret
    | _, true -> acc (n+1) (l_index+1) (ret ^ char_to_str c)
    | _, _ -> acc (n+1) (l_index+1) (ret ^ char_to_str (String.get str n))
  in
  acc 0 0 ""

Agora ele compila. Então vamos executá-lo.

# remplace_positions [1; 4] 'u' "hello";;
Exception: Failure "nth".

Onde é que isto deu errado?

Bem, vamos traçar isso:

remplace_positions [1; 4] 'u' "hello"

acc 0 0 ""
  n >= String.length "hello" -> false
  List.nth [1; 4] 0 = n -> false
acc 1 1 ("" ^ "h")
  n >= 5 -> false
  List.nth [1; 4] 1 = n -> false
acc 2 2 ("h" ^ "e")
  n >= 5 -> false
  List.nth [1; 4] 2 = n -> exception!

Você incrementou o índice da sua lista a ponto de ele tentar acessar a lista fora dos limites, resultando em uma exceção.

Para ser honesto, sua abordagem básica não vale a pena salvar. Usar List.ntheven com sucesso é ineficiente porque é uma operação O(n) em vez de O(1).

O que você precisa fazer, em última análise, é iterar sobre a lista e substituir os caracteres em cada um dos índices pelo seu caractere especificado. A correspondência de padrões em listas fornece a maneira mais idiomática de realizar essa iteração sobre a lista.

let rec replace_chars lst c str =
  let len = String.length str in
  let cs = String.make 1 c in
  match lst with
  | [] -> str
  | hd::tl ->
    let front_of_str = String.sub str 0 hd in
    let tail_of_str = String.sub str (hd + 1) (len - hd - 1) in
    replace_chars tl c (front_of_str ^ cs ^ tail_of_str)

Mas ter strings imutáveis ​​em OCaml torna isso confuso. Tudo isso de obter substrings e concatená-las de volta realmente ocupa muito espaço. Seria mais fácil se elas fossem mutáveis.

Felizmente é para isso que o Bytesmódulo serve. Podemos converter para um bytestipo mutável, modificá-lo e então converter de volta para um string.

let replace_chars lst c str =
  let b = Bytes.of_string str in
  let rec aux lst =
    match lst with
    | [] -> b
    | hd::tl -> (Bytes.set b hd c; aux tl)
  in
  String.of_bytes (aux lst)

Mas, na verdade, iterar sobre uma lista e aplicar uma operação a cada elemento já é algo que é feito por List.iter.

let replace_chars lst c str =
  let b = Bytes.of_string str in
  List.iter (fun i -> Bytes.set b i c) lst;
  String.of_bytes b