coroutine

Une coroutine est utilisée pour exécuter plusieurs tâches en même temps à partir du même script.De telles tâches peuvent inclure la production de valeurs à partir d'entrées ou effectuer du travail sur une sous- routine lors de la résolution d'un problème plus important.Une tâche n'a même pas besoin d'avoir un point d'arrivée défini, mais elle doit définir des moments spécifiques à laquelle elle rend (paause) pour laisser d'autres choses être travaillées.

Utiliser les coroutines

Une nouvelle coroutine peut être créée en fournissant une fonction à coroutine.create().Une fois créée, une coroutine ne commence à s'exécuter qu'après le premier appel à coroutine.resume() qui transmet les arguments à la fonction.Ce rappel se produit lorsque la fonction s'arrête ou appelle coroutine.yield() et, lorsque cela se produit, coroutine.resume() retourne les valeurs retournées par la fonction, les valeurs envoyées à coroutine.yield() ou un message d'erreur.S'il y a une erreur, la deuxième valeur de retour est l'erreur lancée.

local function task(...)
	-- Cette fonction pourrait faire un peu de travail puis rendre une valeur
	coroutine.yield("first")  -- À être retourné par coroutine.resume()
	-- La fonction se poursuit une fois qu'elle est reprise à nouveau
	return "second"
end

local taskCoro = coroutine.create(task)
-- Rappel de l'appel pour la première fois, qui exécute la fonction depuis le début
local success, result = coroutine.resume(taskCoro, ...)
print(success, result)  --> vrai, d'abord (tâche appelée coroutine.yield()}
-- Continuez à exécuter la fonction jusqu'à ce qu'elle produise ou s'arrête
success, result = coroutine.resume(taskCoro)
print(success, result)  --> true, second (task halted because it returned "second")

Pendant la durée de vie de la coroutine, vous pouvez appeler coroutine.status() pour inspecter son statut:

<th>Signification</th>
  </tr>
</thead>

<tbody>
  <tr>
    <td><b>suspendu</b></td>

    <td>La coroutine attend d'être reprise. Les coroutines commencent dans cet état et y entrent lorsque leur fonction appelle <code>coroutine.yield()</code>.</td>
  </tr>

  <tr>
    <td><b>exécution</b></td>

    <td>La coroutine est en cours d'exécution en ce moment.</td>
  </tr>

  <tr>
    <td><b>normalement</b></td>

    <td>La coroutine attend le rendement d'une autre coroutine ; en d'autres termes, elle a repris une autre coroutine.</td>
  </tr>

  <tr>
    <td><b>mort</b></td>

    <td>La fonction a été interrompue (renvoyée ou lancée une erreur). La coroutine ne peut pas être utilisée plus tard.</td>
  </tr>
</tbody>

Emballage des coroutesines

Lorsque vous travaillez avec des coroutines, vous pouvez également renoncer à l'utilisation de l'objet coroutine et utiliser une fonction d'enveloppe à la place.Une telle fonction de wrapper reprendra une coroutine spécifique lorsqu'elle sera appelée et ne retournera que les valeurs rendues.Vous pouvez le faire en utilisant coroutine.wrap() :

-- Créer une coroutine et retourner une fonction wrapper qui la reprend
local f = coroutine.wrap(task)
-- Reprendre la coroutine comme si nous appelions coroutine.resume()
local result = f()
-- Si une erreur se produit, elle sera soulevée ici !
-- This differs from coroutine.resume() which acts similar to pcall()

La première valeur renvoyée de coroutine.resume() décrit si une coroutine a fonctionné sans erreurs.Cependant, les fonctions retournées par coroutine.wrap() ne feront pas cela : au lieu de cela, elles retourneront directement les valeurs retournées ou transmises à coroutine.yield(), si nécessaire.Si une erreur s'est produite lors de l'exécution de la fonction de coroutine, l'erreur se produit lors de l'appel de la fonction retournée.

Exemple de modèle producteur

Imaginez une tâche qui produit des répétitions d'un mot : chaque fois qu'elle produit une répétition, la suivante en produira une de plus.Par exemple, fournir Hello produira Hello , HelloHello , HelloHelloHello , etc.Pour ce faire, vous pouvez définir repeatThis() :

-- Cette fonction répète un mot à chaque fois que sa coroutine est reprise
local function repeatThis(word)
	local repetition = ""
	while true do
		-- Faites une répétition puis obtenez le resultats
		repetition = repetition .. word
		coroutine.yield(repetition)
	end
end

Pour exécuter cette fonction en tant que coroutine, vous pouvez utiliser coroutine.create() suivi de plusieurs appels à coroutine.resume() :

local repetitionCoro = coroutine.create(repeatThis)
print(coroutine.resume(repetitionCoro, "Hello"))  -- vrai, Bonjour
print(coroutine.resume(repetitionCoro))           -- vrai, HelloHello
print(coroutine.resume(repetitionCoro))           -- true, HelloHelloHello

Pour cette fonction de producteur, vous pouvez également utiliser coroutine.wrap() pour obtenir une fonction qui produit des valeurs :

local f = coroutine.wrap(repeatThis)
print(f("Hello"))  -- Bonjour
print(f())         -- BonjourBonjour
print(f())         -- HelloHelloHello