Calcul de rubis et de lambda

Question

J'essaie de comprendre le lambda-calcul avec procs et ruby. Voici un code:

puts -> x { -> y {x.call(y) } } 
# => #<Proc:0x2a3beb0@C:/first-ruby.rb:1 (lambda)> 

puts -> x { x + 2}.call(1) 
# => 3 

Qu'est--> exemple ci-dessus dans signifient? La méthode call transmet-elle la valeur à l'appelant, de sorte que dans le premier exemple, la valeur y est passée à y et dans le deuxième exemple, 1 est passée à ? Dans le deuxième exemple, pourquoi 1 est-il évalué à x?

Answer 1

Que signifie -> dans l'exemple ci-dessus?

-> fait partie de la syntaxe littérale pour lambdas, comme, par exemple, ' fait partie de la syntaxe littérale des chaînes.

La méthode .call simplement passer la valeur de à l'appelant,

La méthode call est la méthode qui, bien, appelle (ou exécute) le lambda. Les arguments de la méthode call sont liés aux paramètres du lambda.

donc en première valeur exemple yy est transmis à et dans le deuxième exemple 1 est passé à x.

n, dans le premier exemple, y est transmis à la lambda externe et liée à son paramètre x. Dans le deuxième exemple, 1 est passé au lambda et lié à son paramètre x.

Dans le deuxième exemple pourquoi comment 1 est-il évalué à x?

1 n'évalue pas à x. 1 est une valeur immédiate, et en Ruby, les valeurs immédiates toujours évaluent à eux-mêmes. 1 sera toujours évaluer à 1, jamais à ou toute autre chose.

Answer 2

Ceci est un raccourci pour l'expression lambda pur:

lmbd = -> arg{ something to do with arg } # With ->{} notation 

lmbd = lambda { |arg| something to do with arg } # Standard notation 

Dans votre premier exemple vous invoquez méthode met avec l'objet Proc (lambda), et c'est la raison pour laquelle vous voyez #<Proc:0x2a3beb0@C:/first-ruby.rb:1 (lambda)> dans la sortie. Dans le deuxième exemple, vous appelez puts avec la méthode lmbd.call (1), c'est-à-dire que le résultat du calcul lambda est mis en sortie.

Donc, si vous avez LMBD variables qui est l'objet lambda, vous pouvez passer comme un argument et l'obtenir est résultat par Invoke lmbd.call():

lmbd = -> greeting{ puts "#{greeting}, lambda-expression!" } 

def say_hello l, text 
    l.call(text) 
end 

say_hello lmbd, "Aloha" # => Aloha, lambda-expression! 

Answer 3

Définissons une fonction en utilisant Ruby lambda.

def plus_two # no args here 
    ->(x) {x + 2} # args go here 
end 

# assign a value 
x = 1 

# call it 
plus_two.call(x) 
# => 3 

Votre premier exemple est un peu plus complexe mais en utilisant cette idée, vous devriez être capable de trouver des méthodes fonctionnelles. J'étudie Scala et la programmation fonctionnelle est basée sur ces principes de substitution. Essayez de faire une certaine récursivité en utilisant ceux-ci.

C'est comme appeler des fonctions de fonctions n fois. Quel serait alors le cas de base?

Quant au Lambda Calcul https://github.com/mackorone/lambda/blob/master/intro.pdf

Essayez de garder les choses simples et montrer les étapes plutôt que d'essayer de comprendre ce qui est en train de faire une seule ligne. Oui, ils sont gentils mais si vous ne pouvez pas le lire, vous ne pouvez pas le comprendre.

est ici quelque chose que je viens juste travailler sur:

require 'date' 

num = DateTime.now.to_time.utc.to_datetime.ajd - 2451545.0 
@t = num/36525.0 

# the terms in reverse order form for the array 
@l0_a = [1.0/-19880000.0, 
     1.0/-152990.0, 
     1.0/499310.0, 
     0.0003032028, 
     36000.76982779, 
     280.4664567] 

# make an enumerator 
@l0_e = @l0_a.each 

# make a lambda to pass the enumerator to. 
def my_lambda 
    ->(x) {x.reduce {|acc, el| acc * @t + el} % 360} 
end 

puts my_lambda.call(@l0_e) 

Ceci est la longitude moyenne de la formule du soleil en utilisant des méthodes de recenseur et bien sûr un lambda.