Procs y lambdas

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

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:

• http://nereida.deioc.ull.es/~lpp/perlexamples/node154.html
• http://community.logicalbricks.com/node/111ssss

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")

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:

https://t.me/HackTzi

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

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

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

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

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

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"

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

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

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

“Lo primero que vamos hacer es declarar un Proc… Digamos que quiero declarar un lambda”

WTF!??

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…

Documentación de block_given?

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

Buena informacion para comprender mejor esta parte

Que terminal está usando?

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