---
# System prepended metadata

title: Walid 23 / 06 / 2022

---

# 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


