Discussion :

[KaiserSoze]

Bonjour,
J'ai surement codé comme un pied, mais un de mes programmes fonctionnent parfaitement bien en mode interprété (ocaml) et en bytecode (ocamlc) mais quand je le compile vrmnt (avec ocamlopt) la compilation se passe bien, mais l'execution affiche un "Erreur de Segmentation".

Je ne savais pas qu'il était possible que ca bugge uniqument avec ocamlopt.
Je me demande s'il y aurait une raison quelconque à ce qu'un code marche avec ocamlc et pas avec ocamlopt, et quelle est cette raison... ou alors c'est un bug de ocamlopt(ce qui serait étonnant...).

Je précise que je suis sur Linux/Ubuntu Maverick Meerkat, j'utilise que version de ocaml qui vient directement des dépots, et qui est(si l'on en croit la version interactive ocaml) la version 3.11.2

[TropMDR]

A priori tu as une fonction récursive non terminale, et tu exploses ta pile, et soit tu as une plus grosse taille de pile en bytecode, soit tu récupères l'exception.

Il ne te reste plus qu'à éliminer tes récursion non terminales !

[KaiserSoze]

Merci, je crois que c'est bien ca (et désolé du retard de ma réponse).

Ceci-dit, existe-t-il des cas ou il est impossible de transformer une fonction récursive non-terminal, en fonction récursive terminal? Car je ne vois pas comment me debrouiller, et ca ne m'etonnerait pas que ce soit impossible...

[gasche]

Tu peux toujours le faire en convertissant ton programme à un style par passage de continuations.

Par exemple,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
type 'a t =
  | Empty
  | Node of 'a t * 'a * 'a t
 
let rec fold init f = function
  | Empty -> init
  | Node (left, node, right) ->
    f (fold init f left) node (fold init f right)

Donne dans une des versions tail-rec :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
let fold' init f t =
  let rec fold init f t k = match t with
    | Empty -> k init
    | Node (left, node, right) ->
      fold init f left (fun val_left ->
        fold init f right (fun val_right ->
          k (f val_left node val_right)
        )
      )
  in fold init f t (fun x -> x)

L'idée c'est que k représente "ce qu'on va faire ensuite à la valeur de retour". On peut y mettre n'importe quelle fonction, y compris une fonction qui relance 'fold' ensuite, ça reste un appel terminal. Au début on donne (fun x -> x) pour k : quand on a calculé la valeur de retour de l'ensemble de la fonction, on la renvoie à l'identique.
C'est un peu une généralisation des transformations avec ajout d'un accumulateur, mais au lieu de passer "les données qu'on a déjà calculées" en accumulateur, on passe "les transformations qu'il va falloir faire ensuite".