# Walid 23 / 06 / 2022

Suppression de VarOf

Delta(t) = évalue les fonctions à évaluation retardée de t
evalExpr : accès aux champs + GlobalVar

t' : [l->r] (t) = evalExpr(Delta(evalExpr(sigma(replaceGlobalVarNonFail(r)))) where sigma= Matching(evalExpr(Delta(evalExpr(l))),t) % pas d'évaluation de t

evalExprl) : si GlobalVar contient variable de réécriture

s : s1; (g(x_)->r);
s : s1; ruleDelayEval("",g,[arg g],"g",f,[arg f],"f")
t : 1+GlobalVar("toto")
z : applyToExpr(s,t)

evalExpr(blockEval(delayEval(f,u)) :

storeExpr("toto", f(x_,y_)) ; (g(x_,y_) --> GlobalVar("toto") + blockEval(GlobalVar(x_)))

StoreExpr(GlobalVar("toto"), f(x_,y_)) ; evalExpr(GlobalVar("toto")) applied to g(a,b)

# Rajouter une stratégie
## 1ère méthode: par ajout d'un constructeur

Etapes pour créer un nouveau constructeur, e.g. `NewConstructor`, dans le type ocaml `strategy` (qui permet de faire des combinaisons de stratégies sans modification du parseur):

1. ajouter le constructeur `newConstructor` dans types.ml
2. modifier les fonctions d`affichage et conversions de ce type vers le bas niveau` voir le manuel. L'affichage est utilisé pour l'affichage des stratégies dans les extenions. Et la conversion est utilisée dans l'application des extensions aux strategies.
3. ecrire la fonction ocaml `newConstructor` qui implemente la sémantique de la nouvelle strategie
4. modifier la fonction `convert_strategy_to_function` en associant `NewConstructor` à newConstructor
5. pour ne pas modifier le parseur, il suffit de créer une fonction `funConstructorNewConstructor` qui sera igonrée par le parseur, mais Ocaml va la remplacer par NewConstructor. Cette fonction sera appelée dans le language utilisateur et combinée à d'autre strategies*)
`let funConstructorNewConstructor t = NewConstructor t ;;` (* ajout d`un constructeur (augmenter la grammaire), le parseur va interpréter f comme ce construteur *)

## 2ième méthode: par fonctions à évaluation retardées

(* On veut ajouter une fonction newStrategy
1. definir cette fonction newStrategy dans Ocaml
2. créer une règle réecriture identité ruleDelayEval(x_,newStrategy,[x_],"label")
*)

let cond' = apply_subst sigma cond in
if eval_condition(check_if_postMatchingSearch cond cond')

(*===========================================================================*)
(*-------------------------------- topDown ----------------------------------*)
(*===========================================================================*)
let rec topDown` strat t = fail_as_identity(composition [fail_as_identity(strat) ;
most_childs (fail_as_identity(topDown` strat))]) t
;;
(* itération jusqu`à un point fixe, si échec retourne le dernier résultat de l`itération*)
let rec topDown strat t = composition [safe_iterate(strat) ; most_childs (fail_as_identity(topDown strat))] t

(* most_childs = descente dans tous les fils et échoue si toutes les applications échouent, si certains fils échouent se comporte comme l`identité; fail_as_identity : ne sert peut-être à rien; *)
;;

(*===========================================================================*)
(*-------------------------------- outerMost -------------------------------*)
(*===========================================================================*)
(* Matching_Error : utilisé pour le filtrage et pour toutes les stratégies pour une raison de compositionalité *)
let rec outerMost strat t =
begin match t with
| Var(_,_)
| Terme(_,[]) ->
begin
try strat t
with Matching_Error(msg,exp1,exp2) -> t (*Matching_Error : utilisé quand strat ne s`applique ne s`applique pas - valable pour toutes les stratégies*)
end
| _ -> try strat t
with Matching_Error(msg,exp1,exp2) -> most_childs (outerMost strat) t
end;;

(* essai d`une nouvelle version de outerMost qui n`échoue pas - devrait être équivalente à la précédente *)
(*let rec outerMost strat t = if (is_leaf t) then (fail_as_identity(strat t))
else leftChoice [strat ; most_childs (outerMost strat)] t
;;
*)

(* version de outermost qui échoue *)
(*let rec outerMost strat t = if (is_leaf t) then (strat t)
else leftChoice [strat ; most_childs (outerMost strat)] t
;;
*)

(*===========================================================================*)
(*-------------------------------- bottomUp --------------------------------*)
(*===========================================================================*)
let rec bottomUp strat t = composition [most_childs (fail_as_identity(bottomUp strat)) ;
fail_as_identity strat] t ;;

(*===========================================================================*)
(*-------------------------------- innerMost -------------------------------*)
(*===========================================================================*)
let rec innerMost strat t = leftChoice [most_childs (innerMost strat) ; strat] t ;;

# Documentation Symbtrans

## Ce que fait symbtrans
- différence avec d`autres logiciels: Tom, mathematica, maple
- interaction symbtrans-parseur?

## Representation des types
- Définition
- Haut niveau
- tree, strategy, extension
- condition dans tree
- Bas niveau
- terme, extension_oc
- Structures
- liste d`association
- globalVar
- Conversions entre types
- applatissement des listes
- schéma
- conditions
- Conversion entre types symbtrans et types ocaml
- stratégies -> fonctions
- condition -> booléen
- extensions -> fonctions
- chaines de caractère
- Quoi faire pour modifier quelque chose?
- Interaction avec le parseur
- Interaction avec htmlview
- Affichage

## Algorithmes
- Filtrage modulo associativité
- Application de règles
- fonctions dans le terme droit
- evaluation des globalVar
- Application de stratégies
- Application d`extensions
- diffDebug
- htmlView
- Affichage (les principes notamment pour modifier)
- Synthèse d`extensions
- Combinaision d`extensions

## Tests
- Expliquer les tests

## Améliorations
### Comment restructurer les objets bas niveau et haut niveau de michel
### Optimisation
### Tests supplémentaires