À l'aide de "retour" dans un bloc Ruby

Je suis en train d'utiliser Ruby 1.9.1 pour un langage de script incorporé, de sorte que "l'utilisateur final" le code est écrit en Ruby bloc. Un problème, c'est que je voudrais que les utilisateurs soient en mesure d'utiliser le "retour" de mots clés dans les blocs, ils n'ont pas besoin de s'inquiéter à propos de rendement implicite des valeurs. Avec cela à l'esprit, c'est le genre de chose que j'aimerais être capable de faire:

def thing(*args, &block)
  value = block.call
  puts "value=#{value}"
end

thing {
  return 6 * 7
}

Si j'utilise le 'retour' dans l'exemple ci-dessus, j'obtiens un LocalJumpError. Je suis conscient que c'est parce que le bloc en question est un Proc et pas un lambda. Le code fonctionne, si je retire le 'retour', mais je préfère vraiment être en mesure d'utiliser le 'retour' dans ce scénario. Est-ce possible? J'ai essayé de convertir le bloc à un lambda, mais le résultat est le même.

InformationsquelleAutor MetaFu | 2010-02-24
  1. 163

    Simplement utiliser next dans ce contexte:

    $ irb
irb(main):001:0> def thing(*args, &block)
irb(main):002:1>   value = block.call
irb(main):003:1>   puts "value=#{value}"
irb(main):004:1> end
=> nil
irb(main):005:0>
irb(main):006:0* thing {
irb(main):007:1*   return 6 * 7
irb(main):008:1> }
LocalJumpError: unexpected return
        from (irb):7:in `block in irb_binding'
        from (irb):2:in `call'
        from (irb):2:in `thing'
        from (irb):6
        from /home/mirko/.rvm/rubies/ruby-1.9.1-p378/bin/irb:15:in `<main>'
irb(main):009:0> thing { break 6 * 7 }
=> 42
irb(main):011:0> thing { next 6 * 7 }
value=42
=> nil
    • return renvoie toujours à partir de la méthode, mais si vous testez ce code de la cisr vous n'avez pas de méthode, c'est pourquoi vous avez LocalJumpError
    • break retourne la valeur de la bloquer et se termine à son appel. Si votre bloc a été appelé par yield ou .call, puis break des pauses de cet itérateur trop
    • next retourne la valeur de la bloquer et se termine à son appel. Si votre bloc a été appelé par yield ou .call, puis next retourne la valeur de la ligne où yield a été appelé
    • pause dans un proc va lever une exception
    • pouvez-vous citer où vous obtenir cette information à partir de ce "suivant retourne la valeur de la bloquer et de fin d'appel". J'ai envie d'en lire plus sur elle.
    • C'est à partir de Le Langage de Programmation Ruby livre (je ne l'ai pas sous la main en ce moment) si je me souviens bien. Je viens de vérifier sur google et je crois que c'est à partir de ce livre: librairie.immateriel.fr/fr/read_book/9780596516178/... et les 2 prochaines pagex à partir de là (c'est pas mon contenu et de mes pages, je viens de googlé). Mais je recommande vraiment original du livre, il a beaucoup plus de pierres précieuses expliqué.
    • Aussi, j'ai répondu dans ma tête, la seule vérification de choses dans la cisr, c'est pourquoi ma réponse n'est pas technique ou complète. Pour plus d'informations à vérifier Le Langage de Programmation Ruby livre.
    • Je souhaite que cette réponse était au top. Je ne peux pas upvote assez.
    InformationsquelleAutor MBO
  2. 18

    Vous ne pouvez pas le faire en Ruby.

    La return mot-clé toujours retours de la méthode ou lambda dans le contexte actuel. Dans les blocs, il sera de retour à partir de la méthode de fermeture a été défini. Il ne peut pas être fait renvoyer de la appel méthode ou lambda.

    La Rubyspec démontre que c'est en effet le bon comportement pour Ruby (certes pas une réelle mise en œuvre, mais le but de la pleine compatibilité avec C Ruby):

    describe "The return keyword" do
# ...
describe "within a block" do
# ...
it "causes the method that lexically encloses the block to return" do
# ...
it "returns from the lexically enclosing method even in case of chained calls" do
# ...
    InformationsquelleAutor molf
  3. 3

    Vous êtes à la recherche à partir du mauvais point de vue.
    C'est une question de thing, pas le lambda.

    def thing(*args, &block)
  block.call.tap do |value|
    puts "value=#{value}"
  end
end

thing {
  6 * 7
}
    InformationsquelleAutor Simone Carletti
  4. 1

    Où est chose invoquée? Êtes-vous à l'intérieur d'une classe?

    Vous pouvez envisager d'utiliser quelque chose comme ceci:

    class MyThing
  def ret b
    @retval = b
  end

  def thing(*args, &block)
    implicit = block.call
    value = @retval || implicit
    puts "value=#{value}"
  end

  def example1
    thing do
      ret 5 * 6
      4
    end
  end

  def example2
    thing do
      5 * 6
    end
  end
end
    InformationsquelleAutor giorgian
  5. 1

    Je crois que c'est la bonne réponse, malgré les inconvénients:

    def return_wrap(&block)
  Thread.new { return yield }.join
rescue LocalJumpError => ex
  ex.exit_value
end

def thing(*args, &block)
  value = return_wrap(&block)
  puts "value=#{value}"
end

thing {
  return 6 * 7
}

    Ce hack permet aux utilisateurs d'utiliser le retour dans leur procs sans conséquences, l'autonomie est préservée, etc.

    L'avantage de l'utilisation de Thread ici est que, dans certains cas, vous n'obtiendrez pas le LocalJumpError - et le retour se fera dans la place la plus inattendue (en jeu d'une méthode de niveau supérieur, de façon inattendue en ignorant le reste de son corps).

    Le principal inconvénient est le risque de surcharge (vous pouvez remplacer le Fil+de jointure avec juste la yield si ce n'est assez de votre scénario).

    InformationsquelleAutor Cezary Baginski
  6. 0

    J'ai eu le même problème l'écriture d'un DSL pour un framework web en ruby... (le framework web Anorexique sera rock!)...

    de toute façon, j'ai creusé le rubis internes et trouvé une solution simple à l'aide de la LocalJumpError retourné quand un Proc appels de retour... il fonctionne bien dans les tests jusqu'à présent, mais je ne suis pas sûr que c'est plein de preuve:

    def thing(*args, &block)
  if block
    block_response = nil
    begin
      block_response = block.call
    rescue Exception => e
       if e.message == "unexpected return"
          block_response = e.exit_value
       else
          raise e 
       end
    end
    puts "value=#{block_response}"
  else
    puts "no block given"
  end
end

    l'instruction if dans le segment du sauvetage pourrait probablement ressembler à quelque chose comme ceci:

    if e.is_a? LocalJumpError

    mais c'est un territoire inexploré pour moi, donc je vais m'en tenir à ce que j'ai testé jusqu'à présent.

    InformationsquelleAutor Myst
  7. 0

    J'ai trouvé un moyen, mais il implique la définition d'une méthode comme une étape intermédiaire:

    def thing(*args, &block)
  define_method(:__thing, &block)
  puts "value=#{__thing}"
end

thing { return 6 * 7 }
    InformationsquelleAutor s12chung