Utilisation de tuples dans Ruby?

Question

Est-ce que quelqu'un utilise des tuples dans Ruby? Si oui, comment peut-on implémenter un tuple? Les hachages Ruby sont sympas et fonctionnent presque aussi bien, mais j'aimerais vraiment voir quelque chose comme la classe Tuple en Python, où vous pouvez utiliser la notation . pour trouver la valeur que vous cherchez. Je le veux afin que je puisse créer une implémentation de D, similaire à Dee pour Python.

Answer 1

OpenStruct?

bref exemple:

require 'ostruct' 

person = OpenStruct.new 
person.name = "John Smith" 
person.age  = 70 
person.pension = 300 

puts person.name  # -> "John Smith" 
puts person.age  # -> 70 
puts person.address # -> nil 

Answer 2

Basé sur le fait que vous parlez de hash et. notation Je vais supposer que vous voulez dire un type différent de tuple que le tri (1. "a"). Vous recherchez probablement la classe Struct. par exemple:

Person = Struct.new(:name, :age) 
me = Person.new 
me.name = "Guy" 
me.age = 30 

Answer 3

Bien que ce ne soit pas strictement un tuple (ne peut pas faire la notation dot des membres), vous pouvez attribuer une liste de variables à partir d'une liste, qui souvent résoudre des problèmes avec rubis être passe par -value lorsque vous êtes après une liste de valeurs de retour.

E.g.

:linenum > (a,b,c) = [1,2,3] 
:linenum > a 
    => 1 
:linenum > b 
    => 2 
:linenum > c 
    => 3 

Answer 4

Vous pouvez faire quelque chose avec destructuration similaire:

def something((a, b)) 
    a + b 
end 

p something([1, 2]) 

Cette imprime 3 comme prévu.

Answer 5

Je suis l'auteur de Gem for Ruby tuples.

Vous disposez de deux classes:

• Tuple en général
• Pair en particulier

Vous pouvez les initialiser de différentes manières:

Tuple.new(1, 2) 
Tuple.new([1, 2]) 
Tuple(1, 2) 
Tuple([1, 2]) 
Tuple[1, 2] 

Les deux les classes ont des méthodes auxiliaires:

• length/arity - qui renvoie nombre de valeurs à l'intérieur de tuple
• first/last/second (seule paire) - qui renvoie un des éléments correspondants
• [] qui vous donne un accès à l'un des éléments particuliers

Answer 6

Vous pouvez railler Scala tUPLES avec cette astuce:

Tuple = Struct.new(:_1, :_2) 

2.2.5 :003 > t = Tuple.new("a", "b") 
=> #<struct Tuple _1="a", _2="b"> 
2.2.5 :004 > t._1 
=> "a" 
2.2.5 :005 > t._2 
=> "b" 

mais ici vous ne pouvez pas avoir destructuration:

2.2.5 :012 > a, b = t 
=> {:_1=>"a", :_2=>"b"} 
2.2.5 :013 > a 
=> {:_1=>"a", :_2=>"b"} 
2.2.5 :014 > b 
=> nil 

Mais grâce à cette astuce: https://gist.github.com/stevecj/9ace6a70370f6d1a1511 destructuration fonctionnera:

2.2.5 :001 > Tuple = Struct.new(:_1, :_2) 
=> Tuple 
2.2.5 :002 > t = Tuple.new("a", "b") 
=> #<struct Tuple _1="a", _2="b"> 
2.2.5 :003 > t._1 
=> "a" 
2.2.5 :004 > class Tuple ; def to_ary ; to_a ; end ; end 
=> :to_ary 
2.2.5 :005 > a, b = t 
=> #<struct Tuple _1="a", _2="b"> 
2.2.5 :006 > a 
=> "a" 
2.2.5 :007 > b 
=> "b"