Bonjour,

Je suis en train de préparer le système de description de contraintes
pour les algorithmes de descente sur les polyhèdres (i.e. simplexe et
variantes locales) que l'on utilise dans les approximations de
problèmes NP-difficiles

J'essaie d'encapsuler le type ['a] dans un type ['a expr]

type 'a expr =
  | Constante of 'a
  | Variable of int
  | Operateur of 'a expr * 'a expr * ('a -> 'a -> 'a)
  | Application of 'a expr * ('a -> 'a)

let inj = function x -> Constante x

let inj1 f = function expression ->
  match expression with
   | Constante v -> Constante f v
   | Variable _ | Operateur _ | Application _ ->
      Application (expression, f)

let inj2 f = fun x y ->
  match (x, y) with
    | (Constante s, Constante t) -> Constante (f s t)
    | _ -> Operateur (x, y, f)

val inj  : 'a -> 'a expr
val inj1 : ('a -> 'a) -> ('a expr -> 'a expr)
val inj2 : ('a -> 'a -> 'a) -> ('a expr -> 'a expr -> 'a expr)
val eval : 'a env -> 'a expr -> 'a

Maintenant je veux traverser la syntaxe abstaite et optimiser le
traitement des opérateurs les plus simples (*, +, /, ...) et pour les
reconnaître j'utilise l'égalité physique (==)

Seulement, les opérateurs Pervasive.qqch ne semblent pas se comporter
comme les fonctions définies par l'utilisateur :

let f = function x -> x + 1
let a = (1, f)
let (_, g) = a

f == g
- : bool = true

let a = (1, (+))
let (_, g) = a

(+) == g
- : bool = false

let a = (1, Pervasives.(+))
let (_, g) = a

Pervasives.(+) == g
- : bool = false


Pourquoi ce comportement ? Comment contourner le problème ?

        Diego Olivier

-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners