Рекурсия в OCaml: обратная с Concat

Question

У меня есть вопрос относительно потока выполнения в рекурсивных функциях в OCaml.Это сценарий:

У меня есть две рекурсивные функции, Concat и Reverse .Обратные звонки Конкат.Может ли кто-нибудь объяснить, что происходит, когда я, например, отправляю список [1;2;3]?

let rec concat (l1,l2) =
match l1 with
[] -> l2
| (h::t) -> h::(concat (t,l2));;

let rec reverse (l: int list) =
match l with
[] -> []
| (h :: t) -> concat (reverse t, [h]);;

// Call
let list1 = [1; 2; 3] ;;
reverse list1 ;;

Я знаю, что это не оптимальный способ перевернуть список, но сейчас меня интересует только то, как две рекурсивные функции работают друг с другом.

Спасибо!

Answer 1

Функции, рекурсивные или нет, оцениваются, сначала оценивая все свои аргументы в неопределенном порядке, а затем вызывая функцию с ними.

Так, например, concat (reverse t, [h]) сначала оценит обратное, а затем вызовет concat.

Answer 2

Если вы аннотируете concat как два списка целых чисел:

let rec concat (l1, l2 : int list * int list) =
. . .

Вы можете попросить верхний уровень (OCaml REPL) отслеживать вызовы функций и возвращать значения.Это может сказать вам точно, что вы хотите знать.

$ rlwrap ocaml
        OCaml version 4.06.1
. . .
# trace concat;;
concat is now traced.
# trace reverse;;
reverse is now traced.

# reverse [1; 2; 3];;
reverse <-- [1; 2; 3]
reverse <-- [2; 3]
reverse <-- [3]
reverse <-- []
reverse --> []
concat <-- ([], [3])
concat --> [3]
reverse --> [3]
concat <-- ([3], [2])
concat <-- ([], [2])
concat --> [2]
concat --> [3; 2]
reverse --> [3; 2]
concat <-- ([3; 2], [1])
concat <-- ([2], [1])
concat <-- ([], [1])
concat --> [1]
concat --> [2; 1]
concat --> [3; 2; 1]
reverse --> [3; 2; 1]
- : int list = [3; 2; 1]