El uso de tuplas en Ruby?

Question

¿Alguien usa tuplas en Ruby? Si es así, ¿cómo puede uno poner en práctica un par de valores? hashes de rubí son agradables y el trabajo casi tan bien, pero realmente les gustaría ver algo así como la clase de tupla en Python, donde se puede utilizar la notación . para encontrar el valor para el que está buscando. Estoy queriendo de este modo que pueda crear una implementación de D , similar a Dee para Python.

Answer 1

OpenStruct ?

Breve ejemplo:

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

Con base en el hecho de que se habla de valores hash y. notación voy a suponer que quiere decir un tipo diferente de tupla que el (1. "a") tipo. Probablemente se esté buscando la clase Struct. por ejemplo:

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

Answer 3

Si bien esto no es estrictamente una tupla (no se puede hacer la notación de puntos de los miembros), puede asignar una lista de variables de una lista, que a menudo va a resolver los problemas con el rubí siendo pase por valor cuando está después una lista de valores de retorno.

por ejemplo.

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

Answer 4

Soy el autor de para Ruby Gem tuplas .

Está provisto de dos clases:

• Tuple en general
• Pair en particular

Puede inicializar de diferentes maneras:

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

Tanto de las clases tienen algunos métodos auxiliares:

• length / arity - que devuelve número de valores dentro de tupla
• first / last / second (sólo par) - que devuelve un elementos correspondientes
• [] que proporciona un acceso a una serie de elementos particulares

Answer 5

Puede burlarse de la Scala tuplas con este truco:

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"

pero aquí no se puede tener desestructuración:

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

Pero gracias a este truco: https://gist.github.com/stevecj/9ace6a70370f6d1a1511 desestructuración funcionará:

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"

Answer 6

Puede hacer algo similar con la desestructuración:

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

p something([1, 2])

Esto muestra 3 como se esperaba.