Ontem foi liberado o preview 1 da versão 2.0 da linguagem Ruby. Para quem quiser dar uma olhada sem depender da RVM, dá para fazer o seguinte em um sistema como o Linux:

1. Faça o download do arquivo aqui;
2. Extraia o conteúdo:
   tar xvjf ruby-2.0.0-preview1.tar.bz2
3. Vá para a pasta que foi extraída:
   cd ruby-2.0.0-preview1
4. Configure para instalar em uma pasta qualquer, como no exemplo:
   ./configure --prefix=/home/taq/apps/ruby
5. Compile:
   make
6. Instale:
   make install
7. Agora você já deve ter uma instalação funcional do 2.0 na pasta que você indicou. Se você usa o RVM, agora precisa comentar a seguinte linha no seu .bashrc:
   # [[ -s "$HOME/.rvm/scripts/rvm" ]] && . "$HOME/.rvm/scripts/rvm"
8. E adicionar o path da nova instalação, também no .bashrc:
   export PATH=$PATH:/home/taq/apps/ruby/bin
9. Pronto, abrindo um novo terminal, que carregará o .bashrc modificado, já deve ter a versão nova:
   $ ruby -v
   ruby 2.0.0dev (2012-11-01 trunk 37411) [i686-linux]

Como eu gosto de dar uma fuçada no código, eu prefiro instalar assim, depois é só apagar o diretório de atualização, restaurar o .bashrc e está tudo ok. Vamos dar uma olhada em algumas das novidades dessa versão (lembrando que me baseei em alguns exemplos que já existem por aí):

Literais para arrays de símbolos

Mais uma contribuição para digitar menos coisas. A primeira forma é a forma convencional de criar o array, e a segunda é o que foi introduzido na versão 2.0, o %i (também funciona com o %I).

Keyword arguments

Esse não precisa explicar muito também: dá para identificar/nomear os argumentos na declaração de um método.

Module#prepend

Aqui temos um comportamento interessante. Vamos levar em conta esse exemplo da implementação atual:

Vejam bem: após utilizar include, o módulo M aparece logo após a classe C, e quando invocamos o método x, ele é invocado em C, retornando x. Agora vamos testar com prepend:

Utilizando prepend ao invés de include, o módulo é inserido antes da própria classe na cadeia, e quando invocado o método x, é o método de M que responde, produzindo [x].

Refinements

Quem nunca adorou o jeito que podemos "abrir" as classes do Ruby e alterar o seu comportamento? Pois bem, com a versão 2.0 podemos utilizar os refinements para fazer isso em um escopo mais limitado. Vamos supor que gostaríamos que a classe Fixnum tivesse um método chamado minutes que retornasse os segundos correspondentes, mas que isso funcionasse apenas no escopo limitado de uma classe ou módulo, e não de maneira geral. Utilizando refine e using podemos fazer isso (dando uma verificada no que foi alterando usando refinements):

Onigmo

Onigmo vai ser o novo engine de expressões regulares da versão 2.0. Ela parece ser bem baseada em Perl e aqui tem vários recursos que podem estar presentes nesse engine. Como exemplo de novidades, podemos utilizar esse aqui:

Ali é declarado o seguinte: (?(cond)yes|no), onde se cond for atendida, é avaliado yes, senão, no, por isso que foo, iniciando e terminando com caracteres minúsculos, casa com no, foO com maíusculo no final não casa com nada e Foo casa com yes.

Lazy loading

Vamos imaginar que criamos um Enumerator baseado nos números naturais. É um conjunto meio, longo, digamos. E se quiséssemos pegar somente os 5 primeiros números ímpares desse conjunto, utilizando um iterador como select?

Alguém tem um CTRL+C aí? :-p

Mas agora com a versão 2.0 podemos utilizar (assim como em Clojure, Erlang, Haskell etc) o conceito de lazy evaluation ali nos Enumerators, utilizando o método ... lazy, dã, para indicar isso, como nos exemplos:

Bem melhor, hein?

Em termos de performance também fica interessante. Nem tanto para coleções pequenas:

Mas que fica interessante se essa coleção crescer um pouco, melhorando conforme cresce:

Enfim, tem uma série de coisas bem legais por aí, e conforme eu for sabendo e sobrando um tempo, publico por aqui. :-)

Comentários

Comentários fechados.

Sem nenhum comentário.