Parcours
/
Factor
Factor
/
Exercices
/
La cale du maître d'équipage
La cale du maître d'équipage

La cale du maître d'équipage

Exercice d'apprentissage

Introduction

Pompes, vannes, tuyaux : tout ce qui détient une ressource du système d'exploitation (un fichier ouvert, une connexion réseau) doit être libéré quand on a fini de s'en servir. Le vocabulaire destructors de Factor enveloppe ces ressources dans un framework qui garantit le nettoyage, même quand une erreur vient interrompre ton code à mi-parcours.

La classe et le générique

Une classe rejoint le framework en étendant disposable et en implémentant le générique dispose* :

USING: accessors destructors kernel ;

TUPLE: pump < disposable opened ;

: <pump> ( -- pump )
    pump new-disposable t >>opened ;

M: pump dispose* f >>opened drop ;

new-disposable ( class -- obj ) alloue le tuple et l'enregistre auprès du framework : une exception entre l'allocation et le prochain point sûr ne peut pas provoquer de fuite de la ressource. Le framework garantit que dispose* s'exécute au plus une fois par objet ; des appels répétés à dispose ne font rien.

Les appelants publics utilisent dispose

dispose          ( obj -- )                ! release; safe to call twice
with-disposal    ( disposable quot -- )    ! scope one resource
with-destructors ( quot -- )               ! open a registry scope
&dispose         ( obj -- obj )            ! dispose on normal *or* failure exit
|dispose         ( obj -- obj )            ! dispose only if the scope unwinds

with-disposal est la forme pour une seule ressource : elle empile le disposable pour la quotation interne et le libère en sortant.

USING: destructors io ;

<pump> [
    "pumping" print
] with-disposal
! pump released on the way out — even if `print` had thrown

Pour plusieurs ressources, ouvre une portée with-destructors et enregistre chaque acquisition. &dispose (esperluette) signifie « toujours libérer en sortant, en cas de succès comme d'échec ». |dispose (barre verticale) signifie « libérer uniquement en cas d'échec », ce qui est utile quand le chemin de succès transmet la ressource à un appelant qui en prend possession.

[
    <pump> &dispose
    <pump> &dispose
    ! ... use the pumps ...
] with-destructors
! both pumps released

Pour un simple try/finally sans registre, cleanup (dans continuations) est la primitive de plus bas niveau, mais with-destructors est la forme idiomatique du Factor moderne.

Instructions

Tu es le bosco d'un cargo côtier. La cale, le compartiment le plus bas de la coque, recueille les eaux usées, et à chaque quart le matériel de cale doit être ouvert, mis en route, puis rangé. Quoi qu'il arrive pendant le pompage, le matériel doit finir par retrouver son état rangé.

Les tests te donnent <test-pump> pour acquérir des pompes neuves. Chaque pompe a un slot opened>> qui vaut t tant qu'elle est ouverte et f une fois qu'elle a été libérée.

1. Vider la cale

Définis drain-bilge pour libérer une seule pompe. Appeler drain-bilge deux fois sur la même pompe ne doit pas poser de problème : le framework s'en charge pour toi.

<test-pump> dup drain-bilge opened>> .   ! => f

2. Routine de pompage

Définis pump-out de façon à prendre une pompe et une quotation, à empiler la pompe sur la pile pour que la quotation l'utilise, puis à libérer la pompe ensuite, même si la quotation lève une exception.

<test-pump> [ drop ] pump-out   ! pump released

3. Routine de quart complet

Définis shift-routine de façon à prendre deux pompes et une quotation. Ouvre une portée de destructeur, enregistre les deux pompes pour une libération inconditionnelle, puis appelle la quotation. Les deux pompes finissent libérées, que la quotation se termine normalement ou qu'elle lève une exception.

La quotation reçoit les deux pompes sur la pile comme entrées.

<test-pump> <test-pump> [ 2drop ] shift-routine
! both pumps released

4. Pompage risqué

Parfois, une pompe est prêtée : tu ne veux la libérer que si quelque chose tourne mal, sinon l'équipe du quart suivant a besoin de la retrouver ouverte. Définis risky-pump-out de façon à prendre une pompe et une quotation, à enregistrer la pompe pour une libération en cas d'échec uniquement, puis à appeler la quotation avec la pompe sur la pile.

Si la quotation réussit, la pompe reste ouverte. Si la quotation lève une exception, la pompe est libérée et l'exception se propage.

<test-pump> [ drop ] risky-pump-out                ! stays open
<test-pump> [ drop "boom" throw ] risky-pump-out   ! pump released, throws

5. Un objet jetable personnalisé : la vanne

Complète la boîte à outils avec un tout nouvel objet jetable : une valve. Le tuple est déclaré pour toi :

TUPLE: valve < disposable is-open ;
  • Définis <valve> ( -- valve ) pour construire une nouvelle vanne via new-disposable, avec is-open initialisé à t.
  • Implémente M: valve dispose* pour faire basculer is-open à f.
<valve> is-open>> .                ! => t
<valve> dup dispose is-open>> .    ! => f
Modifie via GitHub Le lien s'ouvre dans une nouvelle fenêtre ou un nouvel onglet
Factor Exercism

Prêt à commencer La cale du maître d'équipage ?

Inscris-toi sur Exercism pour apprendre et maîtriser Factor avec 47 concepts163 exercices, et un vrai mentorat humain, le tout gratuitement.