Utilizzando tuple in Ruby?

Question

C'è qualcuno che usa tuple in Ruby? Se sì, come può uno implementare una tupla? hash di Ruby sono belle e il lavoro quasi altrettanto bene, ma mi piacerebbe davvero vedere qualcosa di simile alla classe Tuple in Python, dove è possibile utilizzare la notazione . per trovare il valore per il quale si sta cercando. Ho voglia questo modo che io possa creare un'implementazione di D , simile a Dee per Python.

Answer 1

OpenStruct ?

Breve esempio:

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

Sulla base del fatto che si parla di hash e. notazione ho intenzione di assumere si intende un diverso tipo di tuple rispetto alla (1. "a") sorta. Probabilmente stai cercando per la classe Struct. ad esempio:

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

Answer 3

Anche se questo non è strettamente una tupla (non può fare la notazione del punto di membri), è possibile assegnare una lista di variabili da una lista, che spesso sarà risolvere i problemi con il rubino essendo passaggio per valore quando si sta dopo un elenco di valori di ritorno.

es.

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

Answer 4

Sono l'autore di Gem per Ruby tuple .

Si sono dotati di due classi:

• Tuple in generale
• Pair in particolare

È possibile inizializzare in diversi modi:

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

Entrambe le classi hanno alcuni metodi secondari:

• length / arity - che restituisce il numero di valori all'interno tuple
• first / last / second (solo coppia) - che restituisce un corrispondente elementi
• [] che ti dà un accesso a un determinato gli elementi

Answer 5

Si può prendere in giro la Scala tuple con questo trucco:

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"

ma qui non si può avere destrutturazione:

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

Ma grazie a questo trucco: https://gist.github.com/stevecj/9ace6a70370f6d1a1511 destrutturazione funziona:

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

Si può fare qualcosa simile con la destrutturazione:

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

p something([1, 2])

Questo stampa 3 come previsto.