[ANN] Ron 0.1.0 Released

Discussion in 'Ruby' started by Caleb Clausen, Oct 10, 2006.

  1. Ron version 0.1.0 has been released!

    http://rubyforge.org/projects/ron

    Well, who needed another serialization format? Not me, but that's what
    I've made. Ruby Object Notation (Ron) is a textual format for the
    representation of Ruby data structures. It's somewhat like YAML, XML,
    or (most of all) JSON. However, since it is defined entirely within and
    as a subset of Ruby, it has the slick property that Ron expressions are
    legal Ruby. Thus it is very like JSON, except that it's Ruby-centered
    instead of being JavaScript-centered.

    Another way to look at Ron is as a purely declarative language for
    creating (almost) any type of Ruby data structure.

    Ruby already has formats for representing a literal Array, Hash, Set,
    String, Symbol, Integer, etc. Ron simply reuses the same notations for
    those data types. The major new feature of Ron is that it provides a
    literal syntax for representing arbitrary Ruby Objects.

    Say you have a class that looks like this:

    class K
    attr :a
    attr :b
    end

    A Ron literal that represents a K instance might look like this:

    K-{:mad:a=>1, :mad:b=>2}

    Better yet, if you provide setters as well as getters, you can leave
    off the @ signs:

    class K
    attr_accessor :a,:b
    end

    K-{:a=>1, :b=>2}


    This construct breaks encapsulation, so use the capability with
    moderation and prudence, please.

    An existing object can be rendered into Ron form with a call to
    Ron.dump:

    Ron.dump([1,2,3]) #=>"[1, 2, 3]"

    Ron.load is the inverse operation; it takes a Ron-formatted string and
    converts it back to a live Ruby object. (This is just an alias of
    eval.):

    Ron.load("K-{:mad:a=>1, :mad:b=>2}") #=> #<K:mad:a=2, @b=2>


    bugs and limitations
    Currently, some types of ruby object cannot be dumped. In some
    cases, this is because it is impossible to (correctly) dump those
    objects. In others, it's merely difficult. Here are the ones I
    think I should eventually be doing, mostly with ParseTree help:

    (anonymous) Class and Module
    Method
    UnboundMethod
    Proc

    These are very difficult, and I don't see how to approach them
    correctly (but it would be very nice...):

    Thread
    Continuation

    These are more or less impossible:

    File
    Dir
    Process
    IO
    Caleb Clausen, Oct 10, 2006
    #1
    1. Advertising

  2. This looks really interesting. So you overloaded the - operator on
    classes to achieve the K - {} ?

    --
    Cheers,
    zimbatm

    http://zimbatm.oree.ch
    Jonas Pfenniger, Oct 10, 2006
    #2
    1. Advertising

  3. Joel VanderWerf, Oct 10, 2006
    #3
  4. Caleb Clausen

    Dr Nic Guest

    Dr Nic, Oct 10, 2006
    #4
  5. On 10/10/06, Joel VanderWerf <> wrote:
    > How does it compare with amarshal?
    >
    > http://raa.ruby-lang.org/project/amarshal/


    Both are ruby-based serialization packages/languages. Amarshal
    generates imperative code, tho, whereas in Ron I've tried to take a
    purely declarative approach.
    For instance the amarshal representation of [1,2,3] (taken from the website) is:

    v = []
    v[0] = Array.allocate()
    v[0] << 1
    v[0] << 2
    v[0] << 3
    v[0]

    In Ron, it's merely: "[1,2,3]". A more interesting example would be a
    recursive data structure, say an array containing itself. Here's
    amarshal (extrapolating , haven't tried this):

    v = []
    v[0] = Array.allocate()
    v[0] << v[0]
    v[0]

    Versus Ron:

    Recursive(v1_={}, [v1_])


    Since this is essentially a declarative problem, my declarative syntax
    should be shorter and (hopefully) more readable in most cases.


    > At first glance, the notation
    >
    > K-{:a=>1, :b=>2}
    >
    > for a literal instance of K seems new and interesting.


    Well, thanks. As to Jonas's question about this syntax, yes, it's just
    a matter of defining Class#-.
    Caleb Clausen, Oct 10, 2006
    #5
  6. Caleb Clausen

    Trans Guest

    Re: Ron 0.1.0 Released

    Jonas Pfenniger wrote:
    > This looks really interesting. So you overloaded the - operator on
    > classes to achieve the K - {} ?


    I agree, interesting. I would recommend howerver using something other
    then '-', b/c there is talk of using that for trait-like extensions to
    class/module in future versions of Ruby. '<<' comes to mind a possilble
    alternative.

    K << { a:1, b:2 }

    T.
    Trans, Oct 12, 2006
    #6
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Tom Hawkins

    [ANN] Confluence 0.7.1 Released

    Tom Hawkins, Oct 23, 2003, in forum: VHDL
    Replies:
    0
    Views:
    493
    Tom Hawkins
    Oct 23, 2003
  2. Tom Hawkins

    [ANN] InFormal 0.1.1 Released

    Tom Hawkins, Nov 9, 2004, in forum: VHDL
    Replies:
    2
    Views:
    483
    Tom Hawkins
    Nov 9, 2004
  3. Obaid R.

    Ron Grossi: God is not a man

    Obaid R., Apr 22, 2005, in forum: Python
    Replies:
    28
    Views:
    558
    Nolan Caudill
    May 1, 2005
  4. Pit Capitain
    Replies:
    3
    Views:
    101
    Pit Capitain
    Nov 23, 2005
  5. Caleb Clausen

    [ANN] Ron 0.1.2 Released

    Caleb Clausen, Jan 4, 2010, in forum: Ruby
    Replies:
    1
    Views:
    87
    Joel VanderWerf
    Jan 11, 2010
Loading...

Share This Page