Aprenda e entenda mais sobre Ruby criando sua própria ... filelinguagem de programação Friday,...

José Valim @josevalimblog.plataformatec.com

Aprenda e entenda mais sobre Ruby criando sua própria

linguagem de programação

Friday, November 4, 2011

http://blog.plataformatec.com


blog twitterID


Aprenda e entenda mais sobre Ruby criando sua própria

linguagem de programação




Eu trabalho nablog.plataformatec.com.br


Core Team Member


ElixirOrientação a Objetos e

sintaxe elegante para a Erlang VM


Erlang VM

+ Processos concorrentes

+ Baseados em mensagems

+ “Hot Code Swapping”

+ Baixo consumo de memória


A Linguagem Erlang

+ Pequena e fácil de aprender

+ Programação funcional

- Sintaxe burocrática

- Falta “Orientação a Objetos”


ElixirOrientação a Objetos e

sintaxe elegante para a Erlang VM


<3 Ruby <3


@tenderl♥veFriday, November 4, 2011

* O que eu aprendi sobre o Ruby

* E se?


O que eu aprendi sobre o Ruby


Sobre a sintaxe


puts “hi”


puts “hi” Lexer


puts “hi” Lexer[:identifier, “puts”],[:string, “hi”]



Parser



[:call, “puts”,[ [:string, “hi”]]]

Parser




Parser

SemanticAnalysis




Parser

SemanticAnalysis [:call, “puts”,[

[:string, “hi”]]]




Parser

SemanticAnalysis [:call, “puts”,[

[:string, “hi”]]]

Native /Bytecode


Gramática flexível


def foo 1endfoo #=> 1self.foo #=> 1


def foo 1endfoo #=> 1self.foo #=> 1

foo = 2foo #=> 2self.foo #=> 1


foo


foo Lexer


foo Lexer

[:identifier, “foo”]


foo Lexer


Parser


foo Lexer



Parser


foo Lexer



Parser

SemanticAnalysis


foo Lexer



Parser

SemanticAnalysis ?


foo Lexer



Parser

SemanticAnalysis

Native /Bytecode

?


def bar foo = 1 fooend



[:method,:bar,[ [:assign, "foo", [:integer,1]], [:identifier,"foo"]]]

lexer + parser



[:method,:bar,[ [:assign, "foo", [:integer,1]], [:identifier,"foo"]]]

lexer + parser

[:method,:bar,[ [:assign, "foo", [:integer,1]], [:var,"foo"]]]

semantic analysis


def bar(arg) arg.classendbar /foo/m


def bar(arg) arg.classendbar /foo/m

bar, foo, m = 0, 1, 2bar /foo/m


def show @user = User.find(self.params[:id]) if @user.name =~ %r/^Ph\.D/i self.render :action => "show" else self.flash[:notice] = "Ph.D required" self.redirect_to "/" endend


def show @user = User.find(params[:id]) if @user.name =~ /^Ph\.D/i render :action => "show" else flash[:notice] = "Ph.D required" redirect_to "/" endend


Quiz


Quiz

array = [1,2,3]


Quiz

array = [1,2,3]array.length+1


Quiz

array = [1,2,3]array.length+1#=> 4


Quiz


array.length +1


Quiz


array.length +1#=> ArgumentError


Quiz



array.length + 1


Quiz



array.length + 1#=> 4


O “Object Model”


object = Object.newdef object.greet(name) puts "Hello #{name}"endobject.greet("Matz")


Métodos em Ruby são armazenados

em módulos


module Greeter def greet(name) "Hello #{name}" endend

class Person include Greeterend

Person.new.greet "Matz"


class Person def greet(name) "Hello #{name}" endend

Person.new.greet "Matz"


Person.is_a?(Module) #=> trueClass.superclass #=> Module


object.class.ancestors#=> [Object, Kernel, BasicObject]



object.class.ancestors.any? do |r| r.method_defined?(:greet)end#=> false




object.singleton_class. method_defined?(:greet)#=> true




object.singleton_class. method_defined?(:greet)#=> true

object.singleton_class.is_a?(Module)#=> true


E se?


... não existissem blocos?


<3 Blocos <3


File.open "rubyconf.txt" do |f| f.write "ao vivo"end


File.open "rubyconf.txt", do |f| f.write "ao vivo"end


File.open("rubyconf.txt", do |f| f.write "ao vivo"end)


do_it = do |f| f.write "ao vivo"end

File.open "rubyconf.txt", do_it


Sem blocos

+ Não precisamos mais de yield, &block

+ Passar mais de um bloco é mais natural


... tivessemos Array e Hash

comprehensions?


n = [1,2,3,4]

[x * 2 for x in n]

# => [2,4,6,8]


n = [1,2,3]

[x * 2 for x in n, x.odd?]

# => [2,6]


n = [1,2,3,4]

[[x,y] for x in n, y in n, x * x == y]

# => [[1,1],[2,4]]


n = [1,2,3,4]

{x => y for x in n, y in n, x * x == y}

# => { 1 => 1, 2 => 4 }


... tivessemos interfaces?


def form_for(object) case object when Hash # ... when Array # ... else # ... endend


def form_for(object :: Hash) # ...end

def form_for(object :: Array) # ...end

def form_for(object) # ...end


+ Facilita manutenção

+ Facilita documentação

- Não tem duck typing

Multi-methods


Haskell / Go interfaces

interface ActiveModel::Compliance def :to_key def :persisted?end

def form_for(object :: ActiveModel::Compliance) # ...end


... tivessemos partial application?


_ tem semântica especial em diversas linguagens

de programação


_ = 1_ # => nil


x, *_ = [1,2,3,4,5]


Invés de:

names.each { |x| puts(x) }


Invés de:

names.each { |x| puts(x) }

Poderíamos:

names.each &puts(_)


puts(_)#=> lambda { |x| puts(x) }

respond_to?(_, _)#=> lambda { |x,y| respond_to?(x,y) }


Resumindo ...


<3 Elixir <3github.com/josevalim/elixir


createyourproglang.com



Perguntas?




blog twitterID


Perguntas?




Estamos [email protected]


mailto:[email protected]

mailto:[email protected]

Aprenda e entenda mais sobre Ruby criando sua própria ... filelinguagem de programação Friday,...

Documents

Transcript of Aprenda e entenda mais sobre Ruby criando sua própria ... filelinguagem de programação Friday,...