Études-Mathématique/Dictionnaire et accès aux entrées ajoutées

From Lazi wiki
Jump to: navigation, search

Question

La notation pour définir un dictionnaire permet d'accéder au dictionnaire entier ou aux autres entrées. Mais si le dictionnaire est modifié, comment faire pour accéder à la nouvelle version à partir d'une ancienne entrée ?

Étude

Est-ce nécessaire ?

Cas où cela peut être utile : Si un objet est construit avec un système d'héritage, on a alors la connaissance d'autres entrées sans pour autant qu'elle soit définie dans le dictionnaire où se trouve la fonction.

Donc c'est nécessaire.

Un this actualisé ?

Comme on ne connaît pas le nom des nouvelles entrée, ça ne peut être que par "this". Mais le "this" a pour valeur le dictionnaire de base.

Pour que "this" soit actualisé, il faudrait que les dictionnaires soit des fonctions qui ont "this" en argument. Si d est un dictionnaire, pour accéder à la liste des paires il faudrait faire "recurse d". Si on veut ajouter une paire: $F this → d this +le $T[k,v], remarquons que v peut utiliser la variable "this".

Avec cette modification on ne bénéficie plus de la simplification éventuelle dans translate du "recurse".

Simplifier les calculs

Quand il y a réellement utilisation de this, on ne peut pas vraiment simplifier. Mais quand this est inutilisé, on pourrait simplifier les fonctions $F x → body où x n'est pas utilisé par constantF body, puis dans compute on peut utiliser avoir les shortcuts :

  • constantF body x --> body
  • recurse constantF body --> body

Construction des dictionnaires

Il faudrait revoir toutes les fonctions de calcul sur les dictionnaires.

Exemples:

  • Si on veut ajouter à d une paire : $F this → d this +le $T[k,v] (qu'elle ait ou non une référence à "this").
  • Si on veut lire des informations: on utilise la liste "recurse d".
  • Si on veut modifier le dictionnaire par la fonction f sur les listes: $F this → f . d this

Manipulation des dictionnaires

Question

Il existe une phase de construction où l'on manipule des dydis (dynamic dictionary). Mais une fois le dictionnaire d entièrement construit on peut récupérer la version statique (par "recurse d"). A-t-on alors besoin de fonctions (comme dictApply) sur les dictionnaires statiques ?

Étude

Exemple "pairOfT"

pairOfT $T[tl,tr] se définit comme un dydi constant (car "this" n'est pas utilisé). Donc on peut ajouter "recurse" immédiatement pour avoir une version statique.

Si on voulait le faire dériver d'un type "container" qui fournirait des fonctions de mapping à partir des fonctions de base de pairOfT, on pourrait alors construire par héritage pairOfT.

Exemple d'un type dépendant de topT

Si le type est construit à partir de topT (par exemple le type des déductions, qui n'est pas statique). Dans ce cas une fois construit on peut l'utiliser comme un type statique.

Exemple : merger deux dydis

Par exemple si on veut que d2 hérite des membres de d1 où d2 est un dydi et d1 un stadi. À partir du dictMerge statique on peut faire recurse $F this → dictMerge d1 . d2 this

Cas général

Il y a toujours une phase de construction puis on obtient un dictionnaire statique. La phase de construction peut utiliser en général la version statique (voir l'exemple de merge ci-dessus).

Réponse

On a besoin des fonctions statiques, on fabrique les fonctions dynamiques à partir des statiques. Par exemple si on veut définir directement un statique: recurse $D[ x = y ].

Reconnaissance des dictionnaires

On a déjà une version des dictionnaires similaire, seulement le recurse est déjà mis. D'autre part avec ces dictionnaires il n'y a que deux version: avec constantF ou avec une fonction. Donc ça ne complique pas vraiment.

Syntaxe pour les dictionnaires statiques ?

Plutôt que recurse $D(...)[...] il serait plus facile d'utiliser la syntaxe $D(...)[...] et $Dy(...)[...].

Dans translate je pourrais ajouter un flag signifiant "statique".

Mais les versions statique et dynamique n'ont pas les mêmes contraintes pour la varexp entre parenthèses: dans le cas statique les entrées du dictionnaire doivent être celles définies. Et même il me parait plus simple que pour la version statique on n'accepte que la verexp VWord.

On peut supposer les versions dynamiques plus rares car c'est juste quand le dictionnaire doit être étendu et y accéder.

Une déclaration des entrées attendues ?

Cela permettrais juste des définitions du style $Let k = this .d 'k,

Syntaxe : $D(this@$D[nom1=varexp1,...,nomn=varexpn])[...]

où l'on peut éluder le "this", ça devient : $D($D[nom1=varexp1,...,nomn=varexpn])[...] , c'est un VDict avec la même syntaxe. On peut tout éluder: $D[...] ou encore $D(this)[...] ou encore $D()[...].

Autre méthode ?

De toute manière il faut prendre un argument pour accéder au nouveau dictionnaire. Je ne pense pas qu'il y ait de méthode plus simple qu'avec recurse puisqu'il y a une récursion.

Réponse

Cette modification des dictionnaires est nécessaire. Elle introduit des modifications dans :

  • Un dictionnaire est une fonction par liste où les entrées sont des mots.
  • Un objet (en tant que structure) est une fonction ayant en argument un dictionnaire et retournant un dictionnaire. L'argument sert à accéder au entrées du dictionnaire courant.
  • translate:
    • simplification en constantF body
    • SourcesFm contient un constructeur pour les dictionnaires et un pour les objets.
    • structure des objets avec une VarExp (particulière) à la place de la String. La VarExp est un VAssign Var VDict (la liste du dictionnaire peut être vide).
    • traduction des dictionnaires
    • reconnaissance des dictionnaires
  • compute:
    • shortcut constantF body x --> x
    • shortcut recurse constantF body --> body
  • mathématiques:
    • Créer les fonctions sur les objets.
  • Documentation sur la syntaxe des dictionnaires et objets.