Ruby 2.7.0 programmeerimiskeele väljaanne

Pärast aastat arendust avaldatud väljalase Ruby 2.7.0, dünaamiline objektorienteeritud programmeerimiskeel, mis pakub arendamisel suurt efektiivsust ja on omandanud parimaid omadusi Perlilt, Javalt, Pythoni, Smalltalkilt, Eiffelilt, Adalt ja Lispilt. Projekti kood on litsentseeritud BSD („2-clause BSDL“) ja „Ruby“ litsentside alusel, mis viitab viimasele GPL litsentsi versioonile ja on täielikult ühilduv GPLv3-ga. Ruby 2.7 on seitsmes oluline väljaanne, mis on ette valmistatud planeeritud arendusprotsessi käigus, kus iga aasta jooksul tehakse funktsionaalsete parenduste ettevalmistamiseks ning iga 2-3 kuu tagant ilmuvad paranduste väljaanded.

Peamised parandused:

• Eksperimentaalne toetamine mustritega (Pattern matching), mis võimaldavad läbi vaadata antud objekti ja määrata väärtuse, kui mustriga on vastavus.

  case [0, [1, 2, 3]]
  in [a, [b, *c]]
  p a #=> 0
  p b #=> 1
  p c #=> [2, 3]
  lõpp

  case {a: 0, b: 1}
  in {a: 0, x: 1}
  :unreachable
  in {a: 0, b: var}
  p var #=> 1
  lõpp

• Interaktiivses arvutusterminalis irb (REPL, Read-Eval-Print-Loop) on tekkinud mitmerealine redigeerimise võimalus, mida on teostatud readline-ühilduva raamatukoguga reline, mis kirjutatud Ruby keeles. Integreeritud on rdoc tugi, mis võimaldab vaadata irb-s antud klasside, moodulite ja meetodite kohta dokumentatsiooni. Ridade koodis, mis kuvatakse läbi Binding#irb ning baasklasside objektide uurimise tulemused, esitatakse värviline süntaksihäälestus.
  
• Lisatud on kompaktsuse prügikoguja (Compaction GC), mis suudab teostada mäluala defragmenteerimist, lahendades jõudluse vähenemise ja mälutarbimise suurenemise probleemid, mis tulenevad mälu fragmenteerimisest mõnede multitegelike Ruby rakenduste töö käigus. Objekti pakkimiseks virnas pakutud metoodika GC.compact, mis võimaldab vähendada kasutatavate mälulehtede arvu ja optimeerida virna operatsioonide jaoks
  CoW (copy-on-write).
• Tehtud argumendi lahterdamine, mis on määratud positsiooni alusel loendis («def foo(a,b,c)») ja võtmesõnade alusel («def foo(key: val)»). Võtmesõnade alusel ja positsiooni alusel argumendi automaatne konverteerimine on deewitud ebaõnnestunuks ja ei ole Ruby 3.0 haru jaoks toetatud. Eriti on ebaõnnestunuks deklareeritud viimane argument võtmeparameteritena, võtmesõnade alusel argumentide edastamine viimasena häältetoetuse sõelale ja viimase argumendi jagamine positsioonilisteks ja võtmeargumentideks.

  def foo(key: 42); end; foo({key: 42}) # hoiatus
  def foo(**kw); end; foo({key: 42}) # hoiatus
  def foo(key: 42); end; foo(**{key: 42}) # OK
  def foo(**kw); end; foo(**{key: 42}) # OK

  def foo(h, **kw); end; foo(key: 42) # hoiatus
  def foo(h, key: 42); end; foo(key: 42) # hoiatus
  def foo(h, **kw); end; foo({key: 42}) # OK
  def foo(h, key: 42); end; foo({key: 42}) # OK

  def foo(h={}, key: 42); end; foo(«key» => 43, key: 42) # hoiatus
  def foo(h={}, key: 42); end; foo({«key» => 43, key: 42}) # hoiatus
  def foo(h={}, key: 42); end; foo({«key» => 43}, key: 42) # OK

  def foo(opt={}); end; foo( key: 42 ) # OK

  def foo(h, **nil); end; foo(key: 1) # ArgumentError
  def foo(h, **nil); end; foo(**{key: 1}) # ArgumentError
  def foo(h, **nil); end; foo(«str» => 1) # ArgumentError
  def foo(h, **nil); end; foo({key: 1}) # OK
  def foo(h, **nil); end; foo({«str» => 1}) # OK

  h = {}; def foo(*a) a end; foo(**h) # []
  h = {}; def foo(a) a end; foo(**h) # {} ja hoiatus
  h = {}; def foo(*a) a end; foo(h) # [{}]
  h = {}; def foo(a) a end; foo(h) # {}

• Võimalus numbriteeritud muutuja nimede vaikimisi kasutamine ploki parameetrite jaoks.

  [1, 2, 3].each { puts @1 } # nagu [1, 2, 3].each { |i| puts i }

• Eksperimentaalne tugi vahemikele ilma algväärtuseta.

  ary[..3] # sarnane ary[0..3]
  rel.where(sales: ..100)

• Lisatud meetod Enumerable#tally, mis loendab, kui mitu korda iga element esineb.

  [«a», «b», «c», «b»].tally
  #=> {«a»=>1, «b»=>2, «c»=>1}

• Lubatud privaatse meetodi kutsumine literaliga «self»

  def foo
  lõpp
  private :foo
  self.foo

• Lisatud meetod Enumerator::Lazy#eager, et genereerida tavalist loendust «laisk» (Enumerator::Lazy) loendusest.

  a = %w(foo bar baz)
  e = a.lazy.map {|x| x.upcase }.map {|x| x + «!» }.eager
  p e.class #=> Enumerator
  p e.map {|x| x + «?» } #=> [«FOO!?», «BAR!?», «BAZ!?»]

• Experimenteeriva JIT-kompilaatori arendamine on jätkunud, mis võimaldab oluliselt tõsta Ruby keeles kirjutatud rakenduste jõudlust. Ruby JIT-kompilaator salvestab alguses C keeles kirjutatud koodi kettale ja seejärel kutsub välja välise C kompaile, et genereerida masinainstruktsioone (toetatakse GCC, Clang ja Microsoft VC++ kutseid). Uues versioonis on rakendatud inline-laotamise meetod vajadusel, tagatud on optimeerimisrežiimide valikuline rakendamine kompileerimisel, vaikimisi „—jit-min-calls“ väärtust on suurendatud 5-lt 10000-le ja „—jit-max-cache“ väärtust 1000-lt 100-le.
• Parandatud on CGI.escapeHTML, Monitor ja MonitorMixin jõudlust.
• Module#name, true.to_s, false.to_s ja nil.to_s tagastavad nüüd stringi, mis on määratud objekti jaoks muutumatu.
• RubyVM::InstructionSequence#to_binary meetodiga genereeritavate binaarfailide suurust on vähendatud;
• Olenemata on värskendatud sisseehitatud komponentide versioone, sealhulgas
  Bundler 2.1.2, RubyGems 3.1.2,
  Racc 1.4.15,
  CSV 3.1.2, REXML 3.2.3,
  RSS 0.2.8,
  StringScanner 1.0.3;
• Põhitrükkist on väliseks gem-paketiks viidud järgmised raamatukogud
  CMath (cmath gem),
  Scanf (scanf gem),
  Shell (shell gem),
  Synchronizer (sync gem),
  ThreadsWait (thwait gem),
  E2MM (e2mmap gem).
• Rubygems.org-is on avaldatud vaikimisi pakutavad stdlib moodulid:
  benchmark,
  cgi,
  delegate,
  getoptlong,
  net-pop,
  net-smtp,
  open3,
  pstore,
  singleton. Ei ole kantud rubygems.org'i mooduleid monitor
  observer,
  timeout,
  tracer,
  uri,
  yaml, mis tarnitakse ainult ruby-core'iga.
• Ruby kogumiseks on nüüd vajalik C-kompilaator, mis toetab C99 standardit.

Allikas: opennet.ru