Ruby 1.9 - nowości i zmiany

KRUG, Kraków 27.10.2009

Radosław Bułat

Blog: http://radarek.jogger.pl

Ruby (on Rails) developer w

diff ruby1.8 ruby1.9

Zmiany w interpreterze
- maszyna wirtualna (YARV)
- natywne wątki
Zmiany w języku
- składnia
- semantyka
- core
- stdlib

Maszyna wirtualna YARV

interpretacja "bajtkodu"
- do tej pory bezpośrednia interpretacja sparsowanego drzewa (parse tree) - wolne i niefektywne
natywne wątki zastąpiły zielone wątki (green threads)
- obecny GIL (Global Interpreter Lock) nie pozwala na jednoczesne działanie
- można zwolnić GIL na poziomie API C - funkcja rb_thread_blocking_region
mniejsze zużycie pamięci

Wydajność

There are lies, statistics, and benchmarks
Proste benchmarki - 2-4x szybszy od 1.8

Wydajność cd.

W praktyce może zależeć od wielu czynników, np.:
- wykorzystania GC
- wielkości stosu
- rodzaju wąskiego gardła

Nowy operator lambdy: ->

mul2_first  = lambda {|x| x * 2 }
mul2_second = ->(x) { x * 2 }

# można także ominąć () ale w ten sposób raczej pogarszamy czytelność
mul2_third  = -> x { x * 2 }

w odróżnieniu od tradycyjnej lambdy jest to operator a nie metoda
dodana by umożliwić używania domyślnych parametrów, &block params

l = ->(a, b = 100, *c, &d) do
  p [a, b, c, d.()]
end

l.(1, 2, 3, 4) { 5 }

[1, 2, [3, 4], 5]

Stara lambda na sterydach

ponoć były problemy (parser) by stara lambda obsługiwała domyślne parametry, &block params
przyszedł ktoś mądry, który tego nie wiedział i zrobił to

l = lambda do |a, b = 100, *c, &d|
  p [a, b, c, d.()]
end

l.call(1, 2, 3, 4) { 5 }

[1, 2, [3, 4], 5]

Splat operator

operator splat jest teraz bardziej elastyczny

arr1 = %w(foo bar baz)
arr2 = [1, 2, 3]
[*arr1, "a", *arr2]
#=> ["foo", "bar", "baz", "a", 1, 2, 3]

Bloki

zmieniony zasięg parametrów - lokalny w stosunku do bloku

i = "hello"
3.times {|i| puts i }
puts i

semantyka parametrów taka jak metod, a więc nie zadziała już

h = {}
[1, 2, 3].each_with_index do |@a, h["a"]|
  p [@a, h["a"]]
end

proc jest aliasem do Proc.new, a nie jak do tej pory lambda

Parametry metod

wymagane parametry po opcjonalnych

def foo(a, b = 10, *rest, c)
  p [a, b, rest, c]
end

class MyArray < Array
  def []=(*args, value)
    p [args, value]
  end
end

arr = MyArray.new
arr[1, 2, 3] = "foo"
arr[100] = "bar"

Parametry metod cd.

grupowanie parametrów

def foo(a, (b, c, *d))
  p [a, b, c, d]
end

foo(1, 2)         # a = 1, b = 2, c = nil, d = []
foo(1, [])        # a = 1, b = nil, c = nil, d = []
foo(1, [2, 3])    # a = 1, b = 2, c = 3, d = []
foo(1, [2, 3, 4]) # a = 1, b = 2, c = 3, d = [4]

Hash

Nowa składnia dla kluczy będącymi symbolami:

# stary sposób
{:a => 1, :b => 2}

# nowy sposób
{a: 1, b: 2}

User.find(:all, :order => "login", :limit => 5)
User.find(:all, order: "login", limit: 5)

BasicObject - nadklasa Object

Object.superclass => BasicObject
bazową (domyślną) klasą pozostaje wciąż Object
przydatne przy pisaniu wrapperów, proxy

Enumerable - nowe metody take, take_while, group_by, drop, min_by, max_by, count, minmax

sporo nowych metod
Enumerable.instance_methods(false).size - 22 dla 1.8, 47 dla 1.9

a = [5, 3, 1, 1, 4, 8, 7]
a.take(2) #=> [5, 3]
a.take_while {|e| e != 1 }
a.group_by {|e| e % 2 } #=> {1=>[5, 3, 1, 1, 7], 0=>[4, 8]}
a.minmax #=> [1, 8]
a.count {|e| e < 6 } #=> 6

Zewnętrzne iteratory - Enumerator

wewnętrzne iteratory są prostsze w użyciu
ale mają wady - jak iterować równolegle po wielu kolekcjach?

numbers = [10, 100, 123]
pairs = { "one" => "foo", "two" => "bar", "three" => "baz" }

e1 = numbers.each
e2 = pairs.each

loop do
  p [e1.next, e2.next]
end

Enumerator#with_index

map_with_index, select_with_index - zawsze czegoś brakuje
Enumerator#with_index opakowuje iterator dodając dodatkowy parametr indeksu

file = File.open(__FILE__)
file.each_line.with_index do |line, i|
  puts "#{i}: #{line}"
end

Enumerator.new

tworzy nowy, zewnętrzny iterator
nie trzeba konwertować za pomocą enum_for

fib = Enumerator.new do |y|
 a = b = 1
 loop do
   y << a
   a, b = b, a + b
 end
end

p fib.take(10) #=> [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

Kodowania znaków

do tej pory brak wsparcia kodowania znaków
String nie jest już "enumerable" (wyliczenie czego? linii? znaków? bajtów?)
each_line, each_char, each_byte
poprawna obsługa metod takich jak reverse, size (length), [], slice itp.

# encoding: utf-8

puts "ąęć".reverse #=> "ćęą"
puts "ąęć".size #=> 3
puts "ąęć".bytesize #=> 6
puts "ąęć"[0] #=> "ą"

Klasa Encoding

każdy string posiada jakieś kodowanie
różne stringi mogą posiadać różne kodowania w "tym samym programie"

# encoding: utf-8

s = "Hello World!"
puts s.encoding.class
puts s.encoding.name

Encoding
UTF-8

Nowa pseudostała __ENCODING__

# encoding: utf-8

puts "Ten plik został zakodowany przy użyciu kodowania: #{__ENCODING__.name}"

Ten plik został zakodowany przy użyciu kodowania: UTF-8

Konwersja do innego kodowania

# encoding: utf-8

str = "ąęć"
puts str.encoding
p str.bytes.to_a

str_iso = str.encode("iso-8859-2")
puts str_iso.encoding
p str_iso.bytes.to_a

UTF-8
[196, 133, 196, 153, 196, 135]
ISO-8859-2
[177, 234, 230]

(default_)external_encoding, (default_)internal_encoding

data = File.read(
    "/etc/passwd",
    external_encoding: "ascii",
    internal_encoding: "utf-8"
)
puts data.encoding

UTF-8

Hash - zachowana kolejność kluczy

h = {}; h["c"] = 3; h["a"] = 1; h["b"] = 2
h.each do |k, v|
  p [k, v]
end

1.8
```
["a", 1]
["b", 2]
["c", 3]
```
1.9
```
["c", 3]
["a", 1]
["b", 2]
```

Aktualizacja silnika regexpów (Oniguruma)

text = "Yukihiro Matsuomoto"

m = text.match(/(?<first_name>\w+)\s+(?<last_name>\w+)/)
puts m["first_name"] #=> "Yukihiro"
puts m["last_name"]  #=> "Matsumoto"

```
/(?<foo>.*)/ =~ "bar"

puts foo
```

Symbol#to_proc wbudowane w core

a = ["1", "2", "3", "4"]
puts a.map(&:to_i).inject(:+)

Object#tap

ułatwiaj debugowanie długich, łańcuchowych wywołań

["foo", "bar", "baz"].sort.grep(/foo/).tap {|o| p o }.map(&:size)

Nowa biblioteka w stdlib: prime

biblioteka operująca na liczbach pierwszych
wyznaczanie liczb pierwszych, sprawdzanie liczby czy pierwsza

require "prime"
puts 600851475143.prime_division.max.first

require "prime"
puts (2..1000).select(&:prime?)
puts (2..1000).count(&:prime?)

Ruby vs Python

$ cat hello_world.rb 
puts "Hello World!"

$ ruby-trunk -v
ruby 1.9.2dev (2009-10-17 trunk 25387) [x86_64-linux]

```
Hello World!
```

Hello World!

Ruby vs Python

$ cat hello_world.py
print "Hello World!"

```
$ python3 --version
Python 3.0.1+
```

  File "/home/radarek/blog/prezentacja/code/hello_world.py", line 1
    print "Hello World!"
                       ^
SyntaxError: invalid syntax

Ruby 1.9 - nowości i zmiany

Radosław Bułat

Ruby 1.9 - nowości i zmiany

KRUG, Kraków 27.10.2009

Radosław Bułat

Blog: http://radarek.jogger.pl

diff ruby1.8 ruby1.9

Maszyna wirtualna YARV

Wydajność

Wydajność cd.

Nowy operator lambdy: ->

Stara lambda na sterydach

Splat operator

Bloki

Parametry metod

Parametry metod cd.

Hash

BasicObject - nadklasa Object

Enumerable - nowe metody take, take_while, group_by, drop, min_by, max_by, count, minmax

Zewnętrzne iteratory - Enumerator

Enumerator#with_index

Enumerator.new

Kodowania znaków

Klasa Encoding

Konwersja do innego kodowania

(default_)external_encoding, (default_)internal_encoding

Hash - zachowana kolejność kluczy

Aktualizacja silnika regexpów (Oniguruma)

Symbol#to_proc wbudowane w core

Object#tap

Nowa biblioteka w stdlib: prime

Ruby vs Python

Hello World!

Ruby vs Python

SyntaxError: invalid syntax

Dziękuję za uwagę!

Radosław Bułat

Blog: http://radarek.jogger.pl