ruby tuples relational

¿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


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


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"