"APL Object Notation" dans Dyalog APL

Question

Comment convertir n'importe quelle valeur APL Dyalog en un vecteur de caractères qui pourrait être passé à ⍎ pour obtenir la même valeur?

Comment cela devrait ressembler à:

 x←2 3⍴⍳6 
     x←1,⊂x 
     x←x,⊂'foo' 
     y←desired_function x 
     DPX y 
┌→─────────────────┐ 
│1,(⊂2 3⍴⍳6),⊂'foo'│ 
└──────────────────┘ 
     x≡⍎y 
1 

Mise à jour

L'idée est de convertir une valeur à un code source APL humaine modifiable pour pouvoir l'insérer dans une unité fonction de test, lorsqu'un nouveau scénario problématique a été trouvé. Je veux que ces scénarios de test soient dans le code source APL, pas dans les fichiers, car dans un framework avec lequel je travaille, le code source est bien géré par un système de contrôle de version, alors que les fichiers ne le sont pas. Et je veux qu'il soit modifiable par l'homme, pas seulement en série, pour qu'il soit plus facile de modifier les scénarios de test existants lorsque les arguments/résultats changent.

Answer 1

Je ne suis pas sûr à propos de Dyalog APL, mais la plupart des autres APL ont des fonctions intégrées à pour y parvenir.

Dans IBM APL2 (et donc aussi dans GNU APL) vous pouvez utiliser 2 ⎕TF pour convertir entre une valeur (en fait une variable avec cette valeur) et le code APL qui le produit (mais pas par l'intermédiaire ⍎ mais par un autre 2 ⎕TF):

 4 ⎕CR x 
┏→━━━━━━━━━━━━━━┓ 
┃1 ┏→━━━━┓ ┏→━━┓┃ 
┃ ↓1 2 3┃ ┃foo┃┃ 
┃ ┃4 5 6┃ ┗━━━┛┃ 
┃ ┗━━━━━┛  ┃ 
┗∊━━━━━━━━━━━━━━┛ 


     ⎕←text←2 ⎕TF 'x' 
x←1 (2 3⍴1 2 3 4 5 6) 'foo' 

    )erase x 
     2 ⎕TF text 
x 
     4 ⎕CR x 
┏→━━━━━━━━━━━━━━┓ 
┃1 ┏→━━━━┓ ┏→━━┓┃ 
┃ ↓1 2 3┃ ┃foo┃┃ 
┃ ┃4 5 6┃ ┗━━━┛┃ 
┃ ┗━━━━━┛  ┃ 
┗∊━━━━━━━━━━━━━━┛ 

Dans GNU APL vous pouvez également utiliser 10 ⎕CR à cette fin. Le résultat se compose de plusieurs déclarations APL donc vous devez ⍎¨ sur le résultat:

 10 ⎕CR 'x' 
x←1 00 00 ((⎕IO+1)⊃x)←2 3⍴1 2 3 4 5 6 ((⎕IO+2)⊃x)←'foo' 

     ⊃10 ⎕CR 'x' 
    x←1 00 00      
     ((⎕IO+1)⊃x)←2 3⍴1 2 3 4 5 6 
     ((⎕IO+2)⊃x)←'foo'   

Answer 2

À moins que je manque quelque chose, l'interprète ne fournit pas un mécanisme pour faire enregistrer & reconstruisent tout type possible de variable (il y a beaucoup de complexité avec les espaces de noms, les objets, les références à l'un d'entre eux, etc.). La sérialisation est peut-être la plus proche, mais (a) elle n'est pas lisible par l'homme et (b) c'est plus un mécanisme d'interprète qu'un outil pour les développeurs d'applications, donc je ne veux même pas en parler davantage - il y a de meilleures façons pour faire face à cela;)

Cependant, il y a une commande utilisateur qui vous permettra de le faire:

]save (Object) (Filename) 

si

]save x h:\temp\x 

sauvé à un unicode fichier h: \ temp \ x.dyalog qui pourrait également être édité en utilisant n'importe quel éditeur compatible Unicode (ou même) modifier h: \ temp \ x.dyalog) .

En faisant

]load h:\temp\x 

vous pouvez charger cet objet dans l'espace de travail. Vous pouvez également utiliser

]xyz←load h:\temp\x -noname 

pour affecter la valeur à xyz au lieu de charger dans x à nouveau.

Et il y a plus ... Je suppose que votre question est le résultat de vouloir être en mesure de reproduire certaines données. Connaissez-vous le "système de fichiers de composants" qui offre un moyen facile d'enregistrer des variables comme x dans des fichiers et de les recharger à partir de là? Exemple:

{x ⎕fappend ⍵ ⋄ ⎕FUNTIE ⍵}'h:\temp\x'⎕FCREATE 0 

pour sauver x puis

{r←⎕fread ⍵,1 ⋄ ⎕FUNTIE ⍵ ⋄ r}'h:\temp\x'⎕FTIE 0 

relise. (Disclaimer: ces exemples sont trop simplistes car il n'y a pas de gestion des erreurs dans le cas où le fichier que vous créez existe déjà - généralement cela doit également être pris en compte, mais cela aurait été trop de distraction pour cette petit échantillon ...)

Donc, finalement, je pense que ma véritable préoccupation concerne le contexte de ce problème et le but que vous essayez d'atteindre. Dans toute ma vie APL j'ai rarement vu des choses qui n'étaient "pas faisables" - mais parfois le chemin est différent de ce que vous attendez (connaissant d'autres langues) ...

Answer 3

Je ne sais pas s'il y a un moyen de le faire avec ⍎, mais je mentionnerai que Dyalog Version 15.0 a 2 I-Beams à sérialiser et à désérialiser.

http://help.dyalog.com/15.0/Content/Language/Primitive%20Operators/Serialise%20Array.htm

par exemple,

]disp x 
┌→┬─────┬───┐ 
│1│0 1 2│foo│ 
│ │3 4 5↓ │ 
└─┴~───→┴──→┘ 

    y← 0(220⌶) 0(219⌶) 1(219⌶) 1(220⌶) x 

    ]disp y 
┌→┬─────┬───┐ 
│1│0 1 2│foo│ 
│ │3 4 5↓ │ 
└─┴~───→┴──→┘ 

     y ≡ x 
1 

En outre, vous pouvez vous joindre à nos forums que vous arriveriez plus d'utilisateurs Dyalog APL si vous demandez là votre question.

http://www.dyalog.com/forum/

Cordialement,

Vince

Answer 4

À mon avis, Execute & "sous forme de transfert" ne sont pas des solutions optimales, pour plusieurs raisons:

• structures complexes rapidement devenir difficile à lire
• Exécuter est un relativement lourd/i outil inefficace pour invoquer, comparer avec d'autres solutions
• Si vous ne faites pas attention, vous vous exposez à des attaques par "injection", du code malveillant dans des fichiers supposés contenir des constantes mais qui sont en cours d'exécution au démarrage de votre application.

Selon ce que vos données ressemble, JSON pourrait être une bonne façon d'aller - c'est un format conçu spécialement pour cela:

Dans Dyalog 15.0:

 fromJSON←7159⌶ ⋄ toJSON←7160⌶ 
     (namespace←⎕NS '').life←42 
     toJSON (⍳4) 'Hello' namespace 
[[1,2,3,4],"Hello",{"life":42}] 

L'inconvénient de JSON est qu'il ne peut pas représenter des tableaux de dimension supérieure. Vous aurez donc besoin de masser les choses un peu si vous avez besoin: matrices

 toJSON ↓3 4⍴⍳12 
[[1,2,3,4],[5,6,7,8],[9,10,11,12]] 
     ↑fromJSON '[[1,2,3],[5,6,7]]' 
1 2 3 
5 6 7 

Dans la version 16.0, à sortir à la fin de ce mois-ci, les expériences des poutres en I sont devenus une fonction système ⎕JSON.

Answer 5

⎕SE.Dyalog.Utils.repObj

Par exemple:

 x←2 3⍴⍳6 
     x←1,⊂x 
     x←x,⊂'foo' 
     y←⎕SE.Dyalog.Utils.repObj x 
     ]Display y 
┌→─────────────────────┐ 
│1 (2 3⍴1-⎕io-⍳6) 'foo'│ 
└──────────────────────┘ 
     x≡⍎y 
1 

Try it online!