Estou passando por uma fase de tentativa de evitar variáveis temporárias e uso excessivo de condicionais, onde posso usar um estilo de codificação mais fluido. Gostei muito de usar#tap nos locais em que quero obter o valor necessário para retornar, mas faça algo antes de devolvê-l

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

Vs. o procedimento:

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, os exemplos acima são simples, mas esse é um estilo de codificação bastante comum na comunidade ruby. Às vezes eu vou usar#inject para passar um objeto por uma série de filtros também:

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

Vs. o procedimento:

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

gora, estou enfrentando o uso repetido de uma condição como a seguinte e procurando uma abordagem mais fluida para lidar com ela:

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

solução (ligeiramente) mais limpa é evitar a variável temporária ao custo da duplicaçã

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

Não posso deixar de sentir o desejo de usar algoquas gostar#tap aqui embor

Que outros padrões devo seguir aqui. Sei que tudo isso é apenas açúcar sem sentido para algumas pessoas e que eu deveria passar para problemas mais interessantes, mas estou tentando aprender a escrever com um estilo mais funcional, por isso estou curioso para saber o que os rubiistas de longo prazo determinaram ser boas maneiras de lidar com situações como essa. Esses exemplos são extremamente simplificados.