Issue #5478 has been updated by Alexey Muranov.


Magnus Holm wrote:
>  
>  From a theoretical point of view, a relation has a heading + a set
>  that holds tuples (arrays):
>  
>    class Relation
>      attr_reader :header, :values
>  
>      def inittialize(header, values)
>        @header = header
>        @values = values
>      end
>    end
>  
>    Relation.new(%w[id name], Set[[1, 'Magnus'], [2, 'Alexy']])
>  
>  Of course, there are many other ways to represent it (depending on
>  your requirements). Sometimes you want to use a set of hashes. I don't
>  quite see how the merging of Set and Hash makes it easier to represent
>  relations though. It's still a two-dimensional data-structure, so you
>  either need a Set that contains a Hash or a tuple (Set, Array/Hash).

I agree, i was simply pointing out that set is, in my opinion, a more basic data structure than associative array, and both associative arrays and relations can be either built on top of it, or simply represented by sets.  In particular, it seems wrong to me that Set uses Hash in implementation, and not the other way around.

As Hash class already exists and is the native class for associative arrays, i proposed a way to transform it into set so that to still be able to use it as an associative array and so that most of the current syntax works.  Also this would give a common WYSIWYG :) syntax for both sets and associative arrays: { 1, { 2 => 3 }, 4, {5} }.

I was thinking like this: how to simplify Hash to use it as a base class for both Set and Hash? And i ended up with a data structure that was just a set. Then i thought: how now to build Hash back on top of it? And i decided that there were almost nothing to build, sets can be used as associative arrays, just store (key,value) pairs in them and add methods for fetching and inserting by key.  Of course, there need to be a way to set default_value for associative arrays, etc.

I agree with your examples of how to represent Relation, they both use Set as top-level structure.  As you pointed out, you can just use a set of associative arrays, in my proposed literal syntax:
{ { "id" => "1", "name" => "Magnus" },
  { "id" => "2", "name" => "Alexey", "country" => "France" } }
This might not be the most efficient way, and you would use instead:
Relation.new(%w[id name country], { [1, "Magnus", nil], [2, "Alexey", "France"] })
----------------------------------------
Feature #5478: import Set into core, add syntax
http://redmine.ruby-lang.org/issues/5478

Author: Konstantin Haase
Status: Open
Priority: Normal
Assignee: 
Category: 
Target version: 3.0


=begin
A set is a central data structure. However, a lot of Ruby developers use arrays for situations where it would be more reasonable to use a set. One reason for that is that it is way easier to use Array then Set at the moment, another one is that developers are simply not aware it exists.

I propose moving Set from the stdlib to core and possibly add a syntax or a method on array for creating Set literals.

First class syntax suggestions:

    <1, 2, 3>  # might be tricky to parse
    #[1, 2, 3] # would collide with comments
    $[1, 2, 3]
    ${1, 2, 3}

Method suggestions:

    ~[1, 2, 3]
    +[1, 2, 3]

Whitespace separated String Sets could look like this:

    %w<foo bar blah> # creates an array at the moment 
    #w[foo bar blah] # would collide with comments
    $w[foo bar blah] # would collide with sending :[] to $w
    $w{foo bar blah}

    ~%w[foo bar blah] # not really shorter than using an array with strings
    +%w[foo bar balh] # not really shorter than using an array with strings

Maybe it's ok to not have a whitespace separated syntax, I'm just brainstorming here.

The issue with the method approach is that it would create an Array to send the message to first.

I favor the <1, 2, 3> syntax, possibly without the ability to create a whitespace separated version.

I'd be willing to work on a patch not only for MRI but also for JRuby and Rubinius if you would consider this to be useful.
Although I would need help with the parser.
=end



-- 
http://redmine.ruby-lang.org