Trilhas
/
Factor
Factor
/
Exercícios
/
Porão do Contramestre
Porão do Contramestre

Porão do Contramestre

Exercício de aprendizagem

Introdução

Bombas, válvulas, mangueiras: tudo que ocupa um recurso do sistema operacional (um arquivo aberto, uma conexão de rede) precisa ser liberado quando você termina de usá-lo. O vocabulário destructors do Factor envolve tudo isso num framework que garante a limpeza, mesmo quando um erro interrompe seu código no meio.

A classe e o genérico

Uma classe entra no framework estendendo disposable e implementando o genérico 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 ) aloca a tupla e a registra no framework: uma exceção entre a alocação e o próximo ponto seguro não pode vazar o recurso. O framework garante que dispose* roda no máximo uma vez por objeto, então chamadas repetidas de dispose não têm efeito.

Quem chama de fora usa 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 é a forma para um único recurso: ela empilha o disposable para a quotation interna e o libera na saída.

USING: destructors io ;

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

Para mais de um recurso, abra um escopo with-destructors e registre cada aquisição. &dispose (e comercial) quer dizer "sempre libere na saída, com sucesso ou com falha". |dispose (barra vertical) quer dizer "libere apenas em caso de falha", o que é útil quando o caminho de sucesso passa o recurso para quem chamou e vai assumir a posse dele.

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

Para um try/finally puro, sem registro, cleanup (em continuations) é a primitiva de nível mais baixo, mas o with-destructors é a forma idiomática e moderna no Factor.

Instruções

Você é o contramestre de um cargueiro costeiro. A sentina, o compartimento mais baixo do casco, acumula águas residuais, e a cada turno o equipamento da sentina precisa ser aberto, acionado e guardado. Aconteça o que acontecer no meio do bombeamento, o equipamento precisa terminar de volta ao seu estado guardado.

Os testes fornecem <test-pump> para você obter bombas novas. Cada bomba tem um slot opened>> que lê t enquanto está aberta e f depois que ela é descartada.

1. Drenar a sentina

Defina drain-bilge para liberar uma única bomba. Chamar drain-bilge na mesma bomba duas vezes deve ser inofensivo: o framework cuida disso para você.

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

2. Rotina de bombeamento

Defina pump-out para receber uma bomba e uma quotation, empurrar a bomba para a pilha para a quotation usar, e liberar a bomba em seguida, mesmo que a quotation lance uma exceção.

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

3. Rotina de turno completo

Defina shift-routine para receber duas bombas e uma quotation. Abra um escopo de destrutor, registre as duas bombas para liberação incondicional e depois chame a quotation. As duas bombas acabam liberadas, quer a quotation termine normalmente, quer lance uma exceção.

A quotation recebe as duas bombas na pilha como entradas.

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

4. Bombeamento arriscado

Às vezes uma bomba está emprestada: você só quer descartá-la se algo der errado; caso contrário, o próximo turno precisa que ela fique aberta. Defina risky-pump-out para receber uma bomba e uma quotation, registrar a bomba para liberação apenas em caso de falha e chamar a quotation com a bomba na pilha.

Se a quotation terminar com sucesso, a bomba fica aberta. Se a quotation lançar uma exceção, a bomba é liberada e a exceção se propaga.

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

5. Um disposable personalizado: a válvula

Complete o conjunto de ferramentas com um disposable novinho em folha: uma valve. A tupla já está declarada para você:

TUPLE: valve < disposable is-open ;
  • Defina <valve> ( -- valve ) para construir uma válvula nova via new-disposable, com is-open definido como t.
  • Implemente M: valve dispose* para mudar is-open para f.
<valve> is-open>> .                ! => t
<valve> dup dispose is-open>> .    ! => f
Editar via GitHub O link abre em uma nova janela ou aba
Factor Exercism

Tudo pronto para começar Porão do Contramestre?

Crie sua conta no Exercism para aprender e dominar Factor com 47 conceitos163 exercícios e mentoria humana de verdade, tudo de graça.