Kombinatorowa metoda, taka jak dotknij, ale może zwrócić inną wartość?

Question

Przechodzę przez fazę prób unikania zmiennych tymczasowych i nadużywania warunkowego, w którym mogę użyć bardziej płynnego stylu kodowania. Bardzo podobało mi się używanie #tap w miejscach, w których chcę uzyskać wartość, którą muszę zwrócić, ale zrób coś, zanim zwrócę ją.

def fluid_method 
    something_complicated(a, b, c).tap do |obj| 
    obj.update(:x => y) 
    end 
end 

Vs. proceduralnych:

def non_fluid_method 
    obj = something_complicated(a, b, c) 
    obj.update(:x => y) 
    obj # <= I don't like this, if it's avoidable 
end 

Oczywiście powyższe przykłady są proste, ale jest to dość powszechne kodowania styl we wspólnocie rubinowym jednak. Ja czasami użyć #inject aby przekazać obiekt przez serię filtrów TOO:

things.inject(whatever) do |obj, thing| 
    thing.filter(obj) 
end 

Vs. proceduralnych:

obj = whatever 
things.each do |thing| 
    obj = thing.filter(obj) 
end 
obj 

Teraz jestem w obliczu powtarzanego stosowania warunku jak na poniższej ilustracji, a patrząc na podejście bardziej płynu do przenoszenia go:

def not_nice_method 
    obj = something_complex(a, b, c) 
    if a_predicate_check? 
    obj.one_more_method_call 
    else 
    obj 
    end 
end 

Rozwiązanie (nieznacznie) Cleaner jest do uniknąć tymczasową zmienną kosztem powielania:

def not_nice_method 
    if a_predicate_check? 
    something_complex(a, b, c).one_more_method_call 
    else 
    something_complex(a, b, c) 
    end 
end 

nie mogę pomóc, ale czuje chęć korzystania coś prawie jak#tap tutaj.

Jakie inne wzory mogę tutaj śledzić. Zdaję sobie sprawę, że jest to po prostu bezsensowny cukier dla niektórych osób i że powinienem po prostu przejść do bardziej interesujących problemów, ale próbuję nauczyć się pisać w bardziej funkcjonalnym stylu, więc jestem ciekawy, co ustalili długoterminowi rubiści być dobrym sposobem radzenia sobie z takimi sytuacjami. Te przykłady są bardzo uproszczone.

Answer 1

Definiowanie Object#as:

class Object 
    def as 
    yield self 
    end 
end 

I teraz można napisać:

def not_sure_this_is_nice_enough_method1 
    something_complex(a, b, c).as do |obj| 
    a_predicate_check? ? obj.one_more_method_call : obj 
    end 
end 

Answer 2

znalazłem metodę w gem aspektów, które może być to, czego szukali: Kernel#ergo

So Twoja oryginalna metoda:

def not_nice_method 
    obj = something_complex(a, b, c) 
    if a_predicate_check? 
    obj.one_more_method_call 
    else 
    obj 
    end 
end 

może w końcu wygląda mniej więcej tak:

require 'facets/kernel/ergo' 

def nice_method 
    something_complex(a, b, c).ergo do |_| 
    a_predicate_check? ? _.one_more_method_call : _ 
    end 
end 

Answer 3

muszę zrobić coś takiego i lubię odpowiedź tokland, ale nie chciałem zanieczyszczać obiektu dla małego skryptu pisałem. Zamiast tego wykorzystały tap na tablicy:

[something_complicated].tap { |s| s[0] = new_cool_thing)}.first 

Answer 4

def best_nice_method 
    something_complex(a, b, c).tap |obj| 
    break obj.one_more_method_call if a_predicate_check? 
    end 
end 

Magia jest break w tap zwraca inną wartość.