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

Ruby Development
1

Issue #5550 has been reported by Tsuyoshi Sawada.

Feature #5550: Hash#depth, Hash#flat_length for recursive hashes

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

2

Issue #5550 has been updated by Yukihiro M…

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

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

3

Issue #5550 has been updated by Alexey M…

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

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

4

Issue #5550 has been updated by Thomas S…

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

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

5

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

Status changed from Feedback to Rejected

No feedback, looks hopeless to me. Closing.

–
Yusuke E. [email protected]

Feature #5550: Hash#depth, Hash#flat_length for recursive hashes

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