Chiedo solo se c'è una scorciatoia sintassi per prendere due procs e unirsi a loro in modo che l'uscita di uno è passato all'altro, equivalente a:Come combinare due proc in uno?
a = ->(x) { x + 1 }
b = ->(x) { x * 10 }
c = ->(x) { b.(a.(x)) }
Ciò sarebbe venuto in aiuto quando si lavora con le cose come method(:abc).to_proc e :xyz.to_proc
Più zucchero, non proprio raccomandato nel codice di produzione
class Proc
def *(other)
->(*args) { self[*other[*args]] }
end
end
a = ->(x){x+1}
b = ->(x){x*10}
c = b*a
c.call(1) #=> 20
a = Proc.new { |x| x + 1 }
b = Proc.new { |x| x * 10 }
c = Proc.new { |x| b.call(a.call(x)) }
bisogno di più zucchero! – Gunchars
Si prega di spiegare che cosa manca lo zucchero da questa risposta? –
Scusate se non ero chiaro: vi sono dati 'a' e' b'. Devi prendere 'c'. Ovviamente puoi scrivere un nuovo proc, ma mi chiedo se c'è un modo più breve, come "b.wrap a" o qualcosa del genere. – Gunchars
è possibile creare un'operazione di unione in questo modo
class Proc
def union p
proc {p.call(self.call)}
end
end
def bind v
proc { v}
end
allora si può usare in questo modo
a = -> (x) { x + 1 }
b = -> (x) { x * 10 }
c = -> (x) {bind(x).union(a).union(b).call}
Molto bello! Perché non lo consiglieresti? – Gunchars
Riaprire classi integrate (come Proc), è sempre rischioso a causa di altre librerie che potrebbero fare lo stesso, o future modifiche a Ruby stessa. –
Sono sorpreso che non sia nella libreria standard da qualche parte. Sembra una cosa abbastanza utile. – Gunchars