AkitaOnRails.com tecnologia e carreira

expression ifTrue:[ a := 1 ] ifFalse:[ a := 2 ]

1
2
3
4
5
6
7
8
9

Onde ifTrue e ifFalse são representados como se fossem 'envio de mensagens' ao objeto true ou false. A primeira diferença é que se o objeto não for true ou false isso normalmente pode dar uma exception do tipo MustBeBoolean. Em Ruby tudo é true e apenas os objetos 'nil' e 'false' são considerados 'não-true'.

Outra coisa é que em Smalltalk podemos enviar várias mensagens ao mesmo objeto de uma só vez, em Ruby o método precisa devolver a si mesmo para encadear mensagens, mas fica parecido. 

Então, e se em Ruby pudéssemos fazer assim:

--- ruby
expression.if_true { a = 1 }.if_false { a = 2 }

Hm, acontece que podemos! Vejamos como ficaria isso:

1
2
3
4
5
6
7
8
9
10
11

class Object
  def if_true(&block)
    block.call if self
    self
  end

  def if_false(&block)
    block.call unless self
    self
  end
end

Podemos fazer isso graças aos blocos, que expliquei em detalhes no artigo anterior. Além disso já sabemos que todas as classes no Ruby são abertas, em especial a Object que é a pai de todas. Nesse caso todas as classes do Ruby passam a ter esta funcionalidade, não apenas TrueClass ou FalseClass.

Vejamos como ficaria com a notação de do..end em vez de chaves:

1
2
3
4
5

expression.if_true do
  a = 1
end.if_false do
  a = 2
end

Feinha.

Isso é apenas um exercício de metaprogramação no Ruby porque esta implementação não tem absolutamente nenhuma vantagem sobre a notação nativa de if; else; end. Como apontado em inúmeras discussões a respeito como esta a notação imperativa atual do Ruby não é ambígua e o interpretador não precisa trabalhar dispatch de métodos. Em algumas implementações de Smalltalk ifTrue;ifFalse é mais um syntatic sugar porque internamente eles também não fazem dispatching de métodos e fazem o branch condicional normal. Motivo: performance.

Existe outra diferença, em Ruby e Smalltalk podemos enviar múltiplos blocos a um mesmo método, mas Smalltalk tem uma sintaxe mais simples para isso, como é o caso do próprio ifTrue;ifFalse. No fundo o efeito é o mesmo. Se eu quiser muito mesmo posso não usar o ‘if’ imperativo do Ruby, mas não há nenhum ganho ao fazer isso. O Ruby poderia colocar um ‘syntatic sugar’ semelhante que permitisse usar a notação ‘puramente de objetos’ mas que internamente reconvertesse num if imperativo para não impactar a performance.

Outra coisa que Ruby faz de maneira ‘imperativa’: herança de classes. Em Ruby fazemos assim:

1
2

class Carro < Veiculo
end

Em Smalltalk (sem usar a IDE) se faz:

1
2
3
4
5
6
7
8
9
10
11

Ok, ok, se realmente quisermos fazer assim em Ruby podemos usar mais metaprogramação:

--- ruby
class Object
  def self.subclass name
    eval "class #{name} < #{self}; end"
  end
end

Veiculo.subclass :Carro

1
2
3
4
5
6
7
8
9
10
11
12

class Object
  def if(true_block = nil, false_block = nil)
    if self
      true_block.call if true_block
    else
      false_block.call if false_block
    end
  end
end

n = 10
puts ( n > 1 ).if( proc { "true" }, proc { "false" } )