for fun I implemented asObjectOf: MCSmalltalkhubRepository owner: 'StephaneDucasse' project: 'asObjectOf' user: '' password: '' On Fri, Jun 30, 2017 at 12:03 PM, Stephane Ducasse <stepharo.self@gmail.com> wrote:
Hi
recently I started to read a book on machine learning and they manipulate dictionary of dictionary. (So I started my own implementation and I will switch to DataFrame).
Now it occurred to me that when we program complex objects we do not need a compact literal syntax for our objects. But when we manipulate data objects it is super handy.
I ended up doing a lot of
self new addRow: 'Claudia Puig' withTaggedValues: {('Snakes on a Plane' -> 3.5). ('Just My Luck' -> 3.0). ('The Night Listener' -> 4.5). ('Superman Returns' -> 4.0). ('You, Me and Dupree' -> 2.5)}.
And I was not in the mood to write a class for the taggedValues and writing a class would not have really help me.
Now we also have STON but STON is not yet part of the language grammar. So we have to have an explicit conversion call.
STON fromString: 'Point[10,20]'
We were brainstorming with marcus and we could have a first nice extension:
{ 'x' -> 10 .'y' -> 20 } asObjectOf: #Point.
10@20
Now in addition I think that there is a value in having an object literal syntax.
I pasted the old mail of igor on object literals because I like the idea since it does not add any change in the parser. Do you remember what were the problem raised by this solution (beside the fact that it had too many # and the order was like in ston not explicit).
I would love to have another pass on the idea of Igor.
Stef
---------- Forwarded message ---------- From: Igor Stasenko <siguctua@gmail.com> Date: Fri, Oct 19, 2012 at 1:09 PM Subject: [Pharo-project] Yet another Notation format: Object literals To: Pharo Development <Pharo-project@lists.gforge.inria.fr>
Hi, as i promised before, here the simple smalltalk-based literal format. It based on smalltalk syntax, and so, unlike JSON, it doesn't needs to have separate parser (a normal smalltalk parser used for that).
The idea is quite simple: you can tell any object to represent itself as an 'object literal' , for example:
(1@3) asObjectLiteral --> #(#Point 1 3)
{ 1@2. 3@4. true. false . nil } asObjectLiteral
-> #(#Array #(#Point 1 2) #(#Point 3 4) true false nil)
(Dictionary newFromPairs: { 1->#(1 2 3) . 'foo' -> 'bar' }) asObjectLiteral -> #(#Dictionary 1 #(#Array 1 2 3) 'foo' 'bar')
Next thing, you can 'pretty-print' it (kinda):
#(#Dictionary 1 #(#Array 1 2 3) 'foo' 'bar') printObjectLiteral
'#(#Dictionary 1 (#Array 1 2 3) ''foo'' ''bar'')'
and sure thing, you can do reverse conversion:
'#(#Dictionary 1 (#Array 1 2 3) ''foo'' ''bar'')' parseAsObjectLiteral
a Dictionary('foo'->'bar' 1->#(1 2 3) )
Initially, i thought that it could be generic (by implementing default Object>>#asObjectLiteral), but then after discussing it with others, we decided to leave
Object>>#asObjectLiteral to be a subclass responsibility. So, potentially the format allows to represent any object(s) as literals, except from circular referencing objects, of course.
The implementation is fairly simple, as you may guess and contains no new classes, but just extension methods here and there.
Take it with grain and salt, since it is just a small proof of concept. (And if doing it for real it may need some changes etc). Since i am far from areas right now, where it can be used, i don't want to pursue it further or advocate if this is the right way to do things. Neither i having a public repository for this project..
So, if there anyone who willing to pick it up and pursue the idea further, please feel free to do so and make a public repository for project.