"APL Object Notation" in Dyalog APL
How can I convert any APL Dyalog value to a character vector that can be passed to in ⍎
order to get the same value?
How it should look like:
x←2 3⍴⍳6
x←1,⊂x
x←x,⊂'foo'
y←desired_function x
DPX y
┌→─────────────────┐
│1,(⊂2 3⍴⍳6),⊂'foo'│
└──────────────────┘
x≡⍎y
1
Update
The idea is to convert the value into human-editable APL source code so that he can insert it into the unit test function when a new problem scenario is found. I want these test scripts in the APL source code, not files, because in the environment I work with, the source code is well source controlled by the source code, but the files are not. And I want it to be human editable, not just serialized, so that it is easier to modify existing test scripts when the arguments / results change.
source to share
In my opinion, Execute and "transfer form" are not optimal solutions for a number of reasons:
- Complex structures quickly become difficult to read.
- Execution is a relatively heavy / inefficient tool to invoke, compare with other solutions.
- If you're not careful, you open yourself up to "injection" attacks, malicious code in files that should contain constants but are executed when your application starts up.
Depending on your data, JSON might be a nice way - it's a format designed for just that:
In Dyalog 15.0:
fromJSON←7159⌶ ⋄ toJSON←7160⌶
(namespace←⎕NS '').life←42
toJSON (⍳4) 'Hello' namespace
[[1,2,3,4],"Hello",{"life":42}]
The disadvantage of JSON is that it cannot represent higher-dimensional arrays. Therefore, you need to lose a little weight if you want 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
In version 16.0, released later this month, experimental I-Beams became a ⎕JSON system feature.
source to share
I don't know if there is a way to do this with ⍎, but I mentioned that Dyalog Version 15.0 has 2 I-Beams to serialize and deserialize.
http://help.dyalog.com/15.0/Content/Language/Primitive%20Operators/Serialise%20Array.htm
eg.
]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
Alternatively, you can join our forums as you will reach more Dyalog APL users if you post your question there.
Hello,
Vince
source to share
Not sure about APL Dyalog, but most other APLs have built-in functions to achieve this.
In IBM APL2 (and therefore also GNU APL) you can use 2 ⎕TF to convert between a value (actually a variable with that value) and the APL code that produces it (although not through ⍎ , but through another 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┃ ┗━━━┛┃
┃ ┗━━━━━┛ ┃
┗∊━━━━━━━━━━━━━━┛
In GNU APL, you can also use 10 ⎕CR for this purpose. The result consists of multiple APL statements, so you need ⍎¨ :
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'
source to share
If I am missing something, the interpreter does not provide a mechanism for saving and restoring any possible variable type (there is a lot of complications with namespaces, objects, references to any of them, etc.). "Serialization" may come close, but (a) it is not human readable and (b) it is more of an interpreter mechanism than a tool for application developers, so I don't even want to talk about it further - there are better ways to deal with it;)
However, there is a custom command that will allow you to do this:
]save (Object) (Filename)
So
]save x h:\temp\x
saved it to a unicode file h: \ temp \ x.dyalog, which can also be edited with any Unicode compatible editor (or even) to edit h: \ temp \ x.dyalog).
By making
]load h:\temp\x
you can load this object into the workspace. Alternatively use
]xyz←load h:\temp\x -noname
to assign the value xyz
instead of loading in x
again.
And there is more ... I assume your question is the result of a desire to reproduce some data. Did you know about a "component filesystem" that offers an easy way to save variables of type x
to files and reload them from there? Example:
{x ⎕fappend ⍵ ⋄ ⎕FUNTIE ⍵}'h:\temp\x'⎕FCREATE 0
to save x
and then
{r←⎕fread ⍵,1 ⋄ ⎕FUNTIE ⍵ ⋄ r}'h:\temp\x'⎕FTIE 0
to read it again. (Disclaimer: These examples are overly simplistic, since in case the file you are creating already exists, etc., this usually needs to be taken care of as well, but that would be too much of a distraction for this small sample. ..)
So finally, I think my real concern has to do with the context of this issue and the goal you are trying to achieve. In my entire APL life, I've rarely seen things that were "not doable", but sometimes the path is different from what you expect (knowing other languages) ...
source to share