Esiste un modo elegante per escludere il primo valore di un intervallo?

Question

Diciamo che ho un range da 0 a 10:

range = 0...10 

Tre punti significano, che l'ultimo valore (10) è esclusa:

range.include? 10 
=> false 

Ora, c'è un modo simile ed elegante escludere il valore prima?
Per l'esempio precedente, questo significherebbe per includere tutti i valori che sono più grandi (>, non>=) di 0 e minore di 10.

Answer 1

No.

((0+1)..10) 

Answer 2

Forse potresti creare il tuo tipo di intervallo.

Answer 3

Ho due suggerimenti per te, non sono molto ideali ma sono il meglio che riesco a pensare.

Per prima cosa è possibile definire un nuovo metodo nella classe Range che esegue ciò che viene descritto. Sarebbe simile a questa:

class Range 
    def have?(x) 
    if x == self.begin 
     false 
    else 
     include?(x) 
    end 
    end 
end 

p (0..10).have?(0)  #=> false 
p (0..10).have?(0.00001) #=> true 

Non lo so, ho solo usato un sinonimo di "includere" come nome del metodo, forse si può pensare a qualcosa di meglio. Ma questa è l'idea.

E quindi si potrebbe fare qualcosa di un po 'più elaborato e definire un metodo sulla classe Range che contrassegna un intervallo come si desidera escludere il valore iniziale di e quindi modificare il metodo include? di Range per verificare quel segno.

class Range 
    def exclude_begin 
    @exclude_begin = true 
    self 
    end 

    alias_method :original_include?, :include? 
    def include?(x) 
    return false if x == self.begin && instance_variable_defined?(:@exclude_begin) 
    original_include?(x) 
    end 

    alias_method :===, :include? 
    alias_method :member?, :include? 
end 

p (0..10).include?(0)      #=> true 
p (0..10).include?(0.00001)    #=> true 
p (0..10).exclude_begin.include?(0)  #=> false 
p (0..10).exclude_begin.include?(0.00001) #=> true 

Anche in questo caso, si consiglia una migliore (più elegante?) Nome per il metodo di exclude_begin, ho solo scelto che dal momento che è in linea con il metodo di intervallo exclude_end?.

Modifica: Ne ho un altro per te, solo perché trovo questo problema così interessante. : P Questo sarà il lavoro solo nella più recente versione di Ruby 1.9, ma consentirà la seguente sintassi:

(0.exclude..10).include? 0  #=> false 
(0.exclude..10).include? 0.00001 #=> true 

Esso utilizza la stessa idea come il mio secondo suggerimento, ma memorizza il "marcatore di esclusione" nel numero invece della gamma. Devo usare SimpleDelegator di Ruby 1.9 per fare ciò (i numeri da soli non possono avere variabili di istanza o altro), motivo per cui non funzionerà nelle versioni precedenti di Ruby.

require "delegate" 

class Numeric 
    def exclude 
    o = SimpleDelegator.new(self) 
    def o.exclude_this?() true end 
    o 
    end 
end 

class Range 
    alias_method :original_include?, :include? 
    def include?(x) 
    return false if x == self.begin && 
        self.begin.respond_to?(:exclude_this?) && 
        self.begin.exclude_this? 
    original_include?(x) 
    end 

    alias_method :===, :include? 
    alias_method :member?, :include? 
end