Procs y lambdas

Clase 13 de 39 • Curso de Ruby

Contenido del curso

Introducción

Bases del lenguaje

Proyecto

Tomar examen

Comentarios

Daniel Alejandro Cumaco Robayo

student•

porque no profundizan? es que ni documentacion dejan!! el curso parece que lo hacen a la carrera :(, dejo una fuente para aclarar mas la diferencia entre, proc, lambdas y blocks

aqui

Daniel Alberto Esquinazi

student•

Pense que era el unico, no me esta gustando para nada la forma en que se presetan los temas. Muy pobre el curso hasta lo que va.

Francisco Camilo Hernández Alvarado

student•

Hola, muy cierto, deberian dejar material, y ejercicios.

Victor Manuel Franco Cañon

student•

Proc

Un bloque no es un objeto, es parte de la sintaxis de ejecución de un método, por tanto no tiene las funcionalidades de un objeto.
Podemos simular la funcionalidad de un objetos al pasar un bloque como un “proc”, la sintaxis dice que antes del nombre de la variable de método se bebe utilizar el signo “&” el cual le indica a ruby que el bloque que se esta pasando en realidad se trata de un objeto “proc”
Un método solo puede recibir un bloque, pero puede recibir varios “proc”
Es las lenta la ejecución de un proc que la de un bloque

Procedimiento return en un proc

Siempre que intentemos utilizar la palabra reservada return en un proc debemos tener en cuenta que :

Para un proc se debe llamar un metodo y dentro del método declarar el procedimiento que a utilizar.
Si no lo hacemos de este modo nos retornara Error “local jump error” porque esta tratando de ejecutar un return de primer nivel

Lambda

Una “lambda” es una función anónima (sin nombre), su sintaxis es “lambda {…}” o también utilizando la sintaxis de flecha “->(){}”
Hay similitudes muy grandes entre los “procs” y las “lambdas”, lo que los diferencia es que un “proc” se comporta como un bloque, mientras que una “lambda” se comporta como un método
A una “lambda” se le pueden pasar argumentos, pero al igual que a un metodo estos deben pasarse en el mismo orden que fueron llamados y son obligatorios, lo que no sucede en un “proc” pues para este es opcional
Cuando se hace “return” de una desde una “lambda” se detiene la ejecución del método (lambda), pero no se detiene la ejecución de donde fue llamado (otro método), caso contrario si estamos trabajando con bloques que si termina la ejecucion del metodo donde fue llamado

Conceptos extraídos de:

Luis Agustin Suaña Jala

student•

Gracias

María Sierra

student•

Muchas gracias por la aclaraciones!

María Sierra

student•

Datos especiales: Procs y lambdas

Hey, chicos si no entendieron muy bien lo de los Procs y las lambdas, o quedaron con muchas dudas. Este vídeo lo explica perfectamente

Este es el código que verán el vídeo más un pequeños apuntes:

# Procs
# Los procs se comportan como bloques. Se recomienda pasar el Proc de forma explícita
def run_proc_w_random_number(proc)
    proc.call(rand(100))
end

proc = Proc.new { |number| puts "#{number}" }
run_proc_w_random_number(proc)

# No tan buen en performace la siguiente, pero no se recomienda
def run_proc_w_random_number(&proc)
    proc.call(rand(100))
end

run_proc_w_random_number { |number| puts "#{number}" }

# Lambdas
# Las lambdas utiliza un return de la misma forma que hace un método
def return_from_proc
    a = Proc.new { return 10 }.call
    puts 'This will never be printed'
end

def return_from_lambda
    # a = lambda { return 10 }.call
    a = -> { return 10 }.call
    puts "The lambda returned #{a}"
end

return_from_proc
return_from_lambda

Ejercicio de la clase

En Ruby un Proc o lambda es una clase especial que hace una referencia a un método. Estos lambdas son utilizados para hacer programación funcional.

# 1. Declarar un proc
saludar = Proc.new { |nombre| puts "Hola #{nombre}" }

# 2. LLamar a ese procedimiento
saludar.call("Carmen")

Eliaz Bobadilla

student•

Gracias!

María Sierra

student•

Hey!! 😉 Si alguien sigue por aquí y está estudiando Ruby, hace poco unos amigos y yo hemos creado un grupo de Telegram para Devs, si te interesa unirte, aquí el link:

Por cierto, amo muchísimo la sintaxis de Ruby 😍 (igualmente quede como un ocho en está clase) Video para entenderla mejor:

Este vídeo lo explica perfectamente

Eliaz Bobadilla

student•

Genial!

Nico Melgarejo Sabelle

student•

Mejoraría el código de la actividad así:

class Transaction
	def exec
		puts "ejecutando transaccion"
		if block_given?
			yield
		else
			puts "no se recibio un bloque. Transaccion abortada"
		end
	end
end

Luego al ejecutar el código se entenderá que si no se recibe un bloque fallará la transacción

Eliaz Bobadilla

student•

Buena idea.

Noé Lara

student•

¿Osea que un Prcc es Hacer un método en una variable?

Santiago Patiño Montes

student•

Es mas hacer un bloque de codigo en una variable

Jose Ernesto Tamay Balam

student•

Eso me suena como a las funciones anonimas de JS

Roger Christian Cansaya Olazabal

student•

Los Proc: Es una clase con metodos ya establecidos y en este caso lo usan para crear funciones pero al crear una nueva instancia "saludar" esta recibe todas los metodos por defecto y aparte hace lo que creas dentro de las llaves.

saludar = Proc.new { |nombre| puts "hola #{nombre}" }

Bueno si le agregaba una linea hubiera quedado mas clara la explicacion. y para resumir:

tx.exec { put "Despues de la transaccion" }

tx.exec # Es una instancia de la clase transaccion llamando el metodo exec. { put "Despues de la transaccion" } # block o bloque que se ingresa.

class Transaction
    def exec
        puts "Ejecutando Transaccion"
        if block_given?
            puts "Ingreso Bloque" #<<<<< linea nueva 
            yield
        end
    end
end

Rafael Holzhacker

student•

Tuve que estudiar más de una hora solo sobre blocks, procs y lambdas. Deberian profundizar en el tema

Alexander Nova Arevalo

student•

yield, de aca se copia JS con los generators, JUMMM

Nico Melgarejo Sabelle

student•

Un bloque es el código que se encuentra entre braces

{ todo esto será un bloque de codigo a ejecutar }

También lo que está escrito entre un do y un end

def try
  if block_given?
    yield
  else
    "no block"
  end
end
try                  #=> "no block"
try { "hello" }      #=> "hello"
try do "hello" end   #=> "hello"

Rafael Holzhacker

student•

https://www.rubyguides.com/2016/02/ruby-procs-and-lambdas/

herbert Ramos ccasa

student•

soy el unico que tiene que poner el video en 0.5x , para poder entenderlo? no veo la necesidad de correr tanto

David Santiago Pulido Gómez

student•

Yo lo tengo en 2x, me parece que se digiere muy fácilmente

Eliaz Bobadilla

student•

Tambien, pero yo lo llevo en 1.5x

Noé Lara

student•

Honestamente y para mejorar en un futuro, no entendi muy bien este apartado.

María Sierra

student•

Te recomiendo este video para entender mejor.

Link chulo al video 🎞

Deleted .

student•

"Lo primero que vamos hacer es declarar un Proc.. Digamos que quiero declarar un lambda"

WTF!??

Erick Edgardo Marroquin Escobar

student•

Me costó demasiado pero al fin creo entender que son los bloques:

En resumen son funciones anónimas que pueden se pasadas a los métodos. En la imagen que adjunto pueden verlo cree un método llamado "greet_block" (estaba confundido al inicio pero es un método) el cual recibe como parámetro un nombre y lo imprime en consola. gracias a la palabra reservada "yield" yo puedo recibir dentro del método el bloque que le estoy pasando (lo que está en corchetes donde llamo el método)

Si pongo parentesis a yield es para pasarle parámetros al método que estoy invocando entonces gracias a eso puedo imprimir mensajes diferentes ya que el bloque que estoy pasando tiene mensajes distintos, lo que esta en parentesis en yield se recibe como n en el bloque que estoy pasando. Espero que con la imagen sea más claro....

Nico Melgarejo Sabelle

student•

Documentación de block_given?

Alexander Nova Arevalo

student•

http://community.logicalbricks.com/node/111

Buena informacion para comprender mejor esta parte

Cristian Alejandro Velasco Cernas

student•

Que terminal está usando?

María Sierra

student•

La terminal que trae MacOs, creo

Wilmer Diaz

student•

Estuve indagando y deseo compartir el siguiente código, que muestra la diferencia de los bloques especiales proc y lambda.

# Definiendo un proc
a_proc = Proc.new { puts "Hi from proc" }
#Definiendo una lambda
a_lambda = -> { puts "Hi from lambda" }  
#Definiendo el método con argumento proc y lambda
def print_number(a_proc, a_lambda)
    a_proc.call
    yield #Se asociará al bloque de la última línea
    puts "Hi from method" #Una impresión asociada a el método
    a_lambda.call
end

print_number(a_proc, a_lambda) {puts "Hi from yield"}

Tomado de este post

# Procs
# Los procs se comportan como bloques. Se recomienda pasar el Proc de forma explícita
def run_proc_w_random_number(proc)
    proc.call(rand(100))
end

proc = Proc.new { |number| puts "#{number}" }
run_proc_w_random_number(proc)

# No tan buen en performace la siguiente, pero no se recomienda
def run_proc_w_random_number(&proc)
    proc.call(rand(100))
end

run_proc_w_random_number { |number| puts "#{number}" }

# Lambdas
# Las lambdas utiliza un return de la misma forma que hace un método
def return_from_proc
    a = Proc.new { return 10 }.call
    puts 'This will never be printed'
end

def return_from_lambda
    # a = lambda { return 10 }.call
    a = -> { return 10 }.call
    puts "The lambda returned #{a}"
end

return_from_proc
return_from_lambda

# Definiendo un proc
a_proc = Proc.new { puts "Hi from proc" }
#Definiendo una lambda
a_lambda = -> { puts "Hi from lambda" }  
#Definiendo el método con argumento proc y lambda
def print_number(a_proc, a_lambda)
    a_proc.call
    yield #Se asociará al bloque de la última línea
    puts "Hi from method" #Una impresión asociada a el método
    a_lambda.call
end

print_number(a_proc, a_lambda) {puts "Hi from yield"} 

Procs y lambdas

Introducción

Lo que aprenderás sobre Ruby

Qué es Ruby y para qué sirve este lenguaje

Instalación de Ruby

Bases del lenguaje

Tipos de datos I: Integer, float

Tipos de datos II: Strings

Tipos de datos III: Symbols

Tipos de datos IV: Arrays

Tipos de datos V: Hashes

Uso de condicionales

Uso de ciclos

Rangos

Uso de Regex

Procs y lambdas

Programación Orientada a Objetos en Ruby Comenzando la creación de nuestra clase

Programación Orientada a Objetos en Ruby: Módulos

Programación Orientada a Objetos: Clases y Objetos

Concurrencia vs Paralelismo: Threads en Ruby

Bundler y gemas

Testing en Ruby

Testing con MiniTest

Diferencias entre Ruby 2.5 y 3

Proyecto

Introducción al proyecto

Instalar Ruby 2D

Overview Ruby 2D

Arquitectura

Estructurando el proyecto

Vista básica

Programando la base para los movimientos

Programando el movimiento de nuestro snake

Test de nuestras acciones

Implementando el timer del movimiento

Actualizando la vista

Preparando el cambio de dirección

Recapitulación de la arquitectura

Moviendo la serpiente con el teclado

Creciendo la serpiente y programando la condición de derrota

Generando comida aleatoria: uso de rand y stub en pruebas

Condición de salida y conclusiones

Retos del curso