¿Usando Tuples en Ruby?
relational (6)
¿Alguien usa tuplas en Ruby? Si es así, ¿cómo se puede implementar una tupla? Los hashes de Ruby son agradables y funcionan casi igual de bien, pero realmente me gustaría ver algo como la clase Tuple en Python, donde puedes usar .
notación para encontrar el valor que está buscando. Estoy queriendo esto para poder crear una implementación de D , similar a Dee para Python.
Basado en el hecho de que hablas de hashes y. notación Voy a suponer que te refieres a un tipo diferente de tupla que el tipo (1. "a")
. Probablemente estés buscando la clase Struct
. p.ej:
Person = Struct.new(:name, :age)
me = Person.new
me.name = "Guy"
me.age = 30
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
Si bien esto no es estrictamente una tupla (no se puede hacer la notación con puntos de los miembros), puede asignar una lista de variables de una lista, que a menudo resolverá problemas con ruby pass-by-value cuando busque una lista de valores de retorno.
P.ej
:linenum > (a,b,c) = [1,2,3]
:linenum > a
=> 1
:linenum > b
=> 2
:linenum > c
=> 3
Puedes hacer algo similar a la desestructuración:
def something((a, b))
a + b
end
p something([1, 2])
Esto imprime 3
como se esperaba.
Soy el autor de Gem for Ruby tuples .
Le proporcionan dos clases:
-
Tuple
en general -
Pair
en particular
Puedes inicializarlos de diferentes maneras:
Tuple.new(1, 2)
Tuple.new([1, 2])
Tuple(1, 2)
Tuple([1, 2])
Tuple[1, 2]
Ambas clases tienen algunos métodos auxiliares:
-
length
/arity
- que devuelve el número de valores dentro de tupla -
first
/last
/second
(solo par) - que devuelve los elementos correspondientes -
[]
que le da acceso a un elemento en particular
Puedes burlarte de las tuplas de Scala 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 puedes 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 la 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"