Kiedy stosować lambda, kiedy stosować Proc.nowy?

W celu zapewnienia dalszych wyjaśnień:

To wyjaśnia, dlaczego proc są elastyczne, jeśli chodzi o arytmetykę (liczbę argumentów), podczas gdy lambda nie. Bloki nie wymagają podania wszystkich argumentów, ale metody tak (chyba że domyślnie podano). Chociaż podanie domyślnego argumentu lambda nie jest opcją w Rubim 1.8, jest teraz obsługiwane w Rubim 1.9 z alternatywną składnią lambda (jak zauważył webmat):

concat = ->(a, b=2){ "#{a}#{b}" }
concat.call(4,5) # => "45"
concat.call(1)   # => "12"

I Michiel de Mare (op) jest niepoprawny co do Procs i lambda zachowujących się tak samo z arytmetyką w Ruby 1.9. Zweryfikowałem, że nadal zachowują zachowanie od 1.8, jak określono powyżej.

break wypowiedzi nie mają sensu ani w Procach, ani w lambdach. W Procs, break zwróci Ci Proc.nowy, który został już ukończony. I nie ma sensu odrywać się od lambdy, ponieważ jest to zasadniczo metoda, a nigdy nie odrywałbyś się od najwyższego poziomu metody.

next, redo, i raise zachowują się tak samo zarówno w Procs, jak i Lambda. Podczas gdy retry nie jest dozwolone w żadnym z nich i spowoduje wyjątek.

I wreszcie, metoda proc nie powinna być nigdy używana, ponieważ jest niespójna i ma nieoczekiwane zachowanie. W Ruby 1.8 it rzeczywiście zwraca lambda! W Rubim 1.9 zostało to naprawione i zwraca Proc. Jeśli chcesz utworzyć Proc, trzymaj się Proc.new.

Aby uzyskać więcej informacji, Gorąco polecam O 'Reilly' s język programowania Ruby, który jest moim źródłem większości tych informacji.

Znalazłem tę stronę, która pokazuje, jaka jest różnica między Proc.new i lambda. Zgodnie ze stroną, jedyną różnicą jest to, że lambda jest ścisła co do liczby akceptowanych argumentów, podczas gdy Proc.new zamienia brakujące argumenty na nil. Oto przykładowa sesja IRB ilustrująca różnicę:

irb(main):001:0> l = lambda { |x, y| x + y }
=> #<Proc:0x00007fc605ec0748@(irb):1>
irb(main):002:0> p = Proc.new { |x, y| x + y }
=> #<Proc:0x00007fc605ea8698@(irb):2>
irb(main):003:0> l.call "hello", "world"
=> "helloworld"
irb(main):004:0> p.call "hello", "world"
=> "helloworld"
irb(main):005:0> l.call "hello"
ArgumentError: wrong number of arguments (1 for 2)
    from (irb):1
    from (irb):5:in `call'
    from (irb):5
    from :0
irb(main):006:0> p.call "hello"
TypeError: can't convert nil into String
    from (irb):2:in `+'
    from (irb):2
    from (irb):6:in `call'
    from (irb):6
    from :0

Strona zaleca również używanie lambda, chyba że chcesz zachować tolerancję błędu. Zgadzam się z tym sentymentem. Używanie lambdy wydaje się nieco bardziej zwięzłe, a przy tak nieznacznej różnicy wydaje się lepszym wyborem w średniej sytuacji.

Jeśli chodzi o Ruby 1.9, przepraszam, nie zajrzałem jeszcze do 1.9, ale nie wyobrażam sobie, żeby tak bardzo to zmienili(nie wierz mi jednak na słowo, wygląda na to, że słyszałeś o pewnych zmianach, więc prawdopodobnie się mylę).

Proc jest starszy, ale semantyka powrotu jest dla mnie wysoce przeciwstawna (przynajmniej gdy uczyłem się języka), ponieważ:

1. Jeśli używasz proc, najprawdopodobniej używasz jakiegoś paradygmatu funkcjonalnego.
2. Proc może powrócić z zakresu załączającego (patrz poprzednie odpowiedzi), który jest w zasadzie goto i wysoce niefunkcjonalny z natury.

Lambda jest funkcjonalnie bezpieczniejsza i łatwiejsza do rozumowania - zawsze używam jej zamiast proc.

Niewiele mogę powiedzieć o subtelnych różnicach. Mogę jednak zauważyć, że Ruby 1.9 umożliwia teraz opcjonalne parametry dla Lambda i bloków.

Oto nowa składnia stabby lambda pod 1.9:

stabby = ->(msg='inside the stabby lambda') { puts msg }

Ruby 1.8 nie miał takiej składni. Podobnie jak konwencjonalny sposób deklarowania bloków/lambda nie obsługuje opcjonalnych args:

# under 1.8
l = lambda { |msg = 'inside the stabby lambda'|  puts msg }
SyntaxError: compile error
(irb):1: syntax error, unexpected '=', expecting tCOLON2 or '[' or '.'
l = lambda { |msg = 'inside the stabby lambda'|  puts msg }

Ruby 1.9 obsługuje jednak opcjonalne argumenty nawet ze starą składnią:

l = lambda { |msg = 'inside the regular lambda'|  puts msg }
#=> #<Proc:0x0e5dbc@(irb):1 (lambda)>
l.call
#=> inside the regular lambda
l.call('jeez')
#=> jeez

Krótka odpowiedź: liczy się to, co return robi: lambda zwraca z siebie, a proc zwraca z siebie i funkcji, która go wywołała.

Mniej jasne jest, dlaczego chcesz użyć każdego. lambda jest tym, czego oczekujemy w sensie programowania funkcyjnego. Jest to w zasadzie anonimowa metoda z bieżącym zakresem automatycznie powiązanym. Z tych dwóch, lambda jest tym, którego prawdopodobnie powinieneś używać.

Proc, Z drugiej strony, jest naprawdę przydatny do implementacji sam język. Na przykład można za ich pomocą zaimplementować polecenia "if" lub pętle "for". Każdy zwrot znaleziony w proc zwróci się z metody, która go wywołała, a nie tylko z polecenia "if". Tak działają języki, jak działają wyrażenia "jeśli", więc domyślam się, że Ruby używa tego pod okładkami i po prostu ujawnili to, ponieważ wydawało się potężne.

Będzie to potrzebne tylko wtedy, gdy tworzysz nowe konstrukcje językowe, takie jak pętle, konstrukcje if-else itp.

Dobrym sposobem na to jest to, że lambda są wykonywane we własnym zakresie (tak jakby były wywołaniem metody), podczas gdy Procs mogą być postrzegane jako wykonywane w linii z wywołaniem metody, przynajmniej jest to dobry sposób na podjęcie decyzji, którego użyć w każdym przypadku.

Nie zauważyłem żadnych komentarzy na temat trzeciej metody w questonie, "proc", która jest przestarzała, ale inaczej traktowana w 1.8 i 1.9.

Oto dość szczegółowy przykład, który ułatwia dostrzeżenie różnic między trzema podobnymi wywołaniami:

def meth1
  puts "method start"

  pr = lambda { return }
  pr.call

  puts "method end"  
end

def meth2
  puts "method start"

  pr = Proc.new { return }
  pr.call

  puts "method end"  
end

def meth3
  puts "method start"

  pr = proc { return }
  pr.call

  puts "method end"  
end

puts "Using lambda"
meth1
puts "--------"
puts "using Proc.new"
meth2
puts "--------"
puts "using proc"
meth3

Closures in Ruby to dobry przegląd tego, jak bloki, lambda i proc działają w Rubim, z Rubim.

Understanding Ruby Blocks, Procs and Lambdas autorstwa Roberta Sosińskiego jasno wyjaśnia te koncepcje programowania i wzmacnia wyjaśnienia za pomocą przykładowego kodu. Obiekty metody są również powiązane i pokryte.

Lambda działa zgodnie z oczekiwaniami, podobnie jak w innych językach.

Polecenie return W proc utworzone przez Proc.new zwróci nie tylko kontrolę samą w sobie, ale także z otaczającej ją metody .

def some_method
  myproc = Proc.new {return "End."}
  myproc.call

  # Any code below will not get executed!
  # ...
end

Można argumentować, że Proc.new wstawia kod do metody enclosing, tak jak block. Jednak Proc.new tworzy obiekt, podczas gdy block jest częścią obiektu.

I jest jeszcze jedna różnica pomiędzy lambda i Proc.new, co jest ich obsługą (błędnych) argumentów. lambda narzeka na to, podczas gdy Proc.new ignoruje dodatkowe argumenty lub uważa brak argumentów za zero.

irb(main):021:0> l = -> (x) { x.to_s }
=> #<Proc:0x8b63750@(irb):21 (lambda)>
irb(main):022:0> p = Proc.new { |x| x.to_s}
=> #<Proc:0x8b59494@(irb):22>
irb(main):025:0> l.call
ArgumentError: wrong number of arguments (0 for 1)
        from (irb):21:in `block in irb_binding'
        from (irb):25:in `call'
        from (irb):25
        from /usr/bin/irb:11:in `<main>'
irb(main):026:0> p.call
=> ""
irb(main):049:0> l.call 1, 2
ArgumentError: wrong number of arguments (2 for 1)
        from (irb):47:in `block in irb_binding'
        from (irb):49:in `call'
        from (irb):49
        from /usr/bin/irb:11:in `<main>'
irb(main):050:0> p.call 1, 2
=> "1"

BTW, proc W Rubim 1.8 tworzy lambda, podczas gdy w Rubim 1.9+ zachowuje się jak Proc.new, co jest naprawdę mylące.

Aby rozwinąć odpowiedź akordeonu:

Zauważ, że Proc.new tworzy proc poprzez przekazanie bloku. Wierzę, że lambda {...} jest parsowane jako rodzaj dosłownego, a nie wywołania metody, które przekazuje blok. return ing z wewnątrz bloku dołączonego do wywołania metody powróci z metody, a nie z bloku, a przypadek Proc.new jest tego przykładem w grze.

(to jest 1.8. Nie wiem jak to się przekłada na 1.9.)

Jestem trochę spóźniony, ale jest jedna wielka, ale mało znana rzecz o Proc.new w ogóle nie wspominana w komentarzach. As by documentation :

Proc::new może być wywołany bez bloku tylko w ramach metody z dołączonym blokiem, w którym to przypadku blok jest konwertowany do Proc obiekt.

To powiedziawszy, Proc.new lets to chain yielding methods:

def m1
  yield 'Finally!' if block_given?
end

def m2
  m1 &Proc.new
end

m2 { |e| puts e } 
#⇒ Finally!

Różnica w zachowaniu z {[0] } jest IMHO najważniejszą różnicą między 2. Ja też wolę lambdę, bo mniej pisze niż Proc.Nowe: -)