Forum: Ruby-dev [ruby-trunk - Feature #5550][Open] Hash#depth, Hash#flat_length for recursive hashes

Issue #5550 has been reported by Tsuyoshi Sawada.

----------------------------------------
Feature #5550: Hash#depth, Hash#flat_length for recursive hashes
http://redmine.ruby-lang.org/issues/5550

Author: Tsuyoshi Sawada
Status: Open
Priority: Normal
Assignee:
Category:
Target version:


I often have a hash whose value is recursively a hash, which may look 
like the following:

    {"Japan" =>
        {"Hokkaido" => "Sapporo", ...},
        {"Honhuu" =>
            {"Aomori" => "Hirosaki", ...},
            {"Akita" => ...},
            ...
        },
        {"Shikoku" => ...},
        ...
    }

In these cases, it will be convenient if there is a way to know the 
(maximum) depth of he original hash, and the numbers of all the 
"terminal nodes". I would like to propose two methods Hash#depth and 
Hash#flat_length, whose Ruby implementation can be as follows:

    class Hash
  def depth
    1 + (values.map{|v| Hash === v ? v.depth : 1}.max)
  end
  def flat_length
    values.inject(0){|sum, v| sum + (Hash === v ? v.flat_length : 1)}
  end
    end

Issue #5550 has been updated by Yukihiro Matsumoto.

Status changed from Open to Feedback

Hashの本質はkey-valueのマッピングなので、valueが再帰的にHashであることを想定した(再帰的なHashでなければ役に立たない)メソッドを追加することには抵抗があります。
わずか６行のmonkey patchingを避けるためにすべてのRubyに追加すべきメソッドですか？
----------------------------------------
Feature #5550: Hash#depth, Hash#flat_length for recursive hashes
http://redmine.ruby-lang.org/issues/5550

Author: Tsuyoshi Sawada
Status: Feedback
Priority: Normal
Assignee:
Category:
Target version:


I often have a hash whose value is recursively a hash, which may look 
like the following:

    {"Japan" =>
        {"Hokkaido" => "Sapporo", ...},
        {"Honhuu" =>
            {"Aomori" => "Hirosaki", ...},
            {"Akita" => ...},
            ...
        },
        {"Shikoku" => ...},
        ...
    }

In these cases, it will be convenient if there is a way to know the 
(maximum) depth of he original hash, and the numbers of all the 
"terminal nodes". I would like to propose two methods Hash#depth and 
Hash#flat_length, whose Ruby implementation can be as follows:

    class Hash
  def depth
    1 + (values.map{|v| Hash === v ? v.depth : 1}.max)
  end
  def flat_length
    values.inject(0){|sum, v| sum + (Hash === v ? v.flat_length : 1)}
  end
    end

Issue #5550 has been updated by Alexey Muranov.


Excuse me, can you be more precise with your example please? Ruby does 
not accept it (after removing the dots "...")?  Are you talking about 
nested hashes?  How about creating a class Tree that would inherit from 
Hash and define additional methods there?
----------------------------------------
Feature #5550: Hash#depth, Hash#flat_length for recursive hashes
http://redmine.ruby-lang.org/issues/5550

Author: Tsuyoshi Sawada
Status: Feedback
Priority: Normal
Assignee:
Category:
Target version:


I often have a hash whose value is recursively a hash, which may look 
like the following:

    {"Japan" =>
        {"Hokkaido" => "Sapporo", ...},
        {"Honhuu" =>
            {"Aomori" => "Hirosaki", ...},
            {"Akita" => ...},
            ...
        },
        {"Shikoku" => ...},
        ...
    }

In these cases, it will be convenient if there is a way to know the 
(maximum) depth of he original hash, and the numbers of all the 
"terminal nodes". I would like to propose two methods Hash#depth and 
Hash#flat_length, whose Ruby implementation can be as follows:

    class Hash
  def depth
    1 + (values.map{|v| Hash === v ? v.depth : 1}.max)
  end
  def flat_length
    values.inject(0){|sum, v| sum + (Hash === v ? v.flat_length : 1)}
  end
    end

Issue #5550 has been updated by Thomas Sawyer.


I take it you meant `nested hash`. I think your methods will infinite 
loop on recursive hash --and that needs to be considered.

I understand #depth, Array might use such a method too. But 
#flat_length, I don't quite get what is being counted.

----------------------------------------
Feature #5550: Hash#depth, Hash#flat_length for recursive hashes
http://redmine.ruby-lang.org/issues/5550

Author: Tsuyoshi Sawada
Status: Feedback
Priority: Normal
Assignee:
Category:
Target version:


I often have a hash whose value is recursively a hash, which may look 
like the following:

    {"Japan" =>
        {"Hokkaido" => "Sapporo", ...},
        {"Honhuu" =>
            {"Aomori" => "Hirosaki", ...},
            {"Akita" => ...},
            ...
        },
        {"Shikoku" => ...},
        ...
    }

In these cases, it will be convenient if there is a way to know the 
(maximum) depth of he original hash, and the numbers of all the 
"terminal nodes". I would like to propose two methods Hash#depth and 
Hash#flat_length, whose Ruby implementation can be as follows:

    class Hash
  def depth
    1 + (values.map{|v| Hash === v ? v.depth : 1}.max)
  end
  def flat_length
    values.inject(0){|sum, v| sum + (Hash === v ? v.flat_length : 1)}
  end
    end

Issue #5550 has been updated by mame (Yusuke Endoh).

Status changed from Feedback to Rejected

No feedback, looks hopeless to me.  Closing.

--
Yusuke Endoh <mame@tsg.ne.jp>
----------------------------------------
Feature #5550: Hash#depth, Hash#flat_length for recursive hashes
https://bugs.ruby-lang.org/issues/5550#change-33202

Author: sawa (Tsuyoshi Sawada)
Status: Rejected
Priority: Normal
Assignee:
Category:
Target version:


I often have a hash whose value is recursively a hash, which may look 
like the following:

    {"Japan" =>
        {"Hokkaido" => "Sapporo", ...},
        {"Honhuu" =>
            {"Aomori" => "Hirosaki", ...},
            {"Akita" => ...},
            ...
        },
        {"Shikoku" => ...},
        ...
    }

In these cases, it will be convenient if there is a way to know the 
(maximum) depth of he original hash, and the numbers of all the 
"terminal nodes". I would like to propose two methods Hash#depth and 
Hash#flat_length, whose Ruby implementation can be as follows:

    class Hash
  def depth
    1 + (values.map{|v| Hash === v ? v.depth : 1}.max)
  end
  def flat_length
    values.inject(0){|sum, v| sum + (Hash === v ? v.flat_length : 1)}
  end
    end