Estoy pasando por una fase de tratar de evitar variables temporales y el uso excesivo de condicional, donde puedo usar un estilo de codificación más fluido. Me ha gustado mucho usar#tap en lugares donde quiero obtener el valor que necesito devolver, pero haga algo con él antes de devolverlo.

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

Vs. el procedimiento:

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

Obviamente, los ejemplos anteriores son simples, pero este es un estilo de codificación bastante común en la comunidad ruby. A veces uso#inject para pasar un objeto a través de una serie de filtros también:

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

Vs. el procedimiento:

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

Ahora me enfrento al uso repetido de una condición como la siguiente y busco un enfoque más fluido para manejarla:

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

a solución (ligeramente) más limpia es evitar la variable temporal a costa de la duplicación:

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

No puedo evitar sentir el deseo de usar algocas me gusta#tap aquí sin embargo.

¿Qué otros patrones podría seguir aquí? Me doy cuenta de que esto es solo azúcar sin sentido para algunas personas y que debería pasar a problemas más interesantes, pero estoy tratando de aprender a escribir en un estilo más funcional, así que tengo curiosidad por saber qué han determinado los rubítes a largo plazo. ser buenas maneras de abordar situaciones como esta. Estos ejemplos están enormemente simplificados.