dispose* ( disposable -- )
Factor handbook » The language » Deterministic resource disposal » Writing new destructors

Prev:	new-disposable ( class -- disposable )
Next:	disposables

Vocabulary
destructors

Inputs

disposable

a disposable object

Outputs
None

Generic word contract
Releases operating system resources associated with a disposable object. Disposable objects include streams, memory mapped files, and so on.

Notes
This word should not be called directly. It can be implemented on objects with a disposed slot to ensure that the object is only disposed once.

Definition

IN: destructors

GENERIC: dispose* ( disposable -- )

Methods

USING: accessors alien.cxx.demangle.libstdcxx destructors
generalizations libc ;

M: (free)-destructor dispose* alien>> (free) 0 ndrop ;


USING: accessors destructors ecdsa.private generalizations
openssl.libcrypto ;

M: BN_clear_free-destructor dispose*
    alien>> BN_clear_free 0 ndrop ;


USING: accessors destructors generalizations openssl.libcrypto ;

M: BN_clear_free-destructor dispose*
    alien>> BN_clear_free 0 ndrop ;


USING: accessors core-foundation destructors generalizations ;

M: CFRelease-destructor dispose* alien>> CFRelease 0 ndrop ;


USING: accessors core-graphics destructors generalizations ;

M: CGColorSpaceRelease-destructor dispose*
    alien>> CGColorSpaceRelease 0 ndrop ;


USING: accessors core-graphics destructors generalizations ;

M: CGContextRelease-destructor dispose*
    alien>> CGContextRelease 0 ndrop ;


USING: accessors destructors ecdsa.private generalizations
openssl.libcrypto ;

M: EC_POINT_clear_free-destructor dispose*
    alien>> EC_POINT_clear_free 0 ndrop ;


USING: accessors db.postgresql.ffi destructors generalizations ;

M: PQfreemem-destructor dispose* alien>> PQfreemem 0 ndrop ;


USING: accessors destructors generalizations python.ffi ;

M: Py_DecRef-destructor dispose* alien>> Py_DecRef 0 ndrop ;


USING: accessors destructors generalizations openssl.libssl ;

M: SSL_CTX_free-destructor dispose*
    alien>> SSL_CTX_free 0 ndrop ;


USING: accessors destructors generalizations openssl.libssl ;

M: SSL_free-destructor dispose* alien>> SSL_free 0 ndrop ;


USING: accessors destructors generalizations openssl.libssl ;

M: X509_free-destructor dispose* alien>> X509_free 0 ndrop ;


USING: accessors compression.zstd.ffi destructors
generalizations ;

M: ZSTD_freeCCtx-destructor dispose*
    alien>> ZSTD_freeCCtx 1 ndrop ;


USING: accessors compression.zstd.ffi destructors
generalizations ;

M: ZSTD_freeDCtx-destructor dispose*
    alien>> ZSTD_freeDCtx 1 ndrop ;


USING: accessors compression.zstd.ffi destructors
generalizations ;

M: ZSTD_freeDStream-destructor dispose*
    alien>> ZSTD_freeDStream 1 ndrop ;


USING: accessors destructors generalizations openal ;

M: alcCloseDevice*-destructor dispose*
    alien>> alcCloseDevice* 0 ndrop ;


USING: accessors destructors generalizations openal ;

M: alcDestroyContext-destructor dispose*
    alien>> alcDestroyContext 0 ndrop ;


USING: accessors audio.engine audio.engine.private destructors
kernel sequences ;

M: audio-clip dispose*
    [ dup audio-engine>> clips>> remove! drop ]
    [ al-source>> flush-source ] bi ;


USING: accessors audio.engine destructors kernel openal ;

M: audio-engine dispose*
    dup stop-audio
    [ [ alcDestroyContext ] when* f ] change-al-context
    [ [ alcCloseDevice* ] when* f ] change-al-device drop ;


USING: accessors destructors io.sockets.secure.openssl openssl
openssl.libcrypto ;

M: bio dispose* handle>> BIO_free ssl-error ;


USING: accessors broadcast-server destructors kernel ;

M: broadcast-server dispose*
    [ receive-socket>> dispose ] [ broadcast-socket>> dispose ]
    bi ;


USING: accessors destructors io.buffers libc ;

M: buffer dispose* ptr>> free ; inline


USING: accessors destructors llvm.ffi llvm.wrappers ;

M: buffer dispose* value>> LLVMDisposeMemoryBuffer ;


USING: accessors destructors generic io.ports kernel ;

M: buffered-port dispose*
    [
        [ buffer>> &dispose drop ]
        [ M\ buffered-port dispose* (call-next-method) ] bi
    ] with-destructors ;


USING: accessors destructors llvm.ffi llvm.wrappers ;

M: builder dispose* value>> LLVMDisposeBuilder ;


USING: accessors bunny.model destructors kernel opengl ;

M: bunny-buffers dispose*
    [ array>> ] [ element-array>> ] bi delete-gl-buffer
    delete-gl-buffer ;


USING: accessors bunny.cel-shaded destructors opengl.shaders ;

M: bunny-cel-shaded dispose* program>> delete-gl-program ;


USING: accessors bunny.model destructors opengl ;

M: bunny-dlist dispose* list>> delete-dlist ;


USING: bunny.fixed-pipeline destructors kernel ;

M: bunny-fixed-pipeline dispose* drop ;


USING: accessors destructors io.streams.c ;

M: c-stream dispose* handle>> fclose ;


USING: assocs cache destructors ;

M: cache-assoc dispose* clear-assoc ;


USING: accessors cairo.ffi destructors generalizations ;

M: cairo_destroy-destructor dispose*
    alien>> cairo_destroy 0 ndrop ;


USING: accessors cairo.ffi destructors generalizations ;

M: cairo_surface_destroy-destructor dispose*
    alien>> cairo_surface_destroy 0 ndrop ;


USING: checksums destructors kernel ;

M: checksum-state dispose* drop ;


USING: accessors destructors opencl opencl.ffi opencl.private ;

M: cl-buffer dispose* handle>> clReleaseMemObject cl-success ;


USING: accessors destructors opencl opencl.ffi opencl.private ;

M: cl-context dispose* handle>> clReleaseContext cl-success ;


USING: accessors destructors opencl opencl.ffi opencl.private ;

M: cl-event dispose* handle>> clReleaseEvent cl-success ;


USING: accessors destructors opencl opencl.ffi opencl.private ;

M: cl-kernel dispose* handle>> clReleaseKernel cl-success ;


USING: accessors destructors opencl opencl.ffi opencl.private ;

M: cl-program dispose* handle>> clReleaseProgram cl-success ;


USING: accessors destructors opencl opencl.ffi opencl.private ;

M: cl-queue dispose* handle>> clReleaseCommandQueue cl-success ;


USING: accessors destructors opencl opencl.ffi opencl.private ;

M: cl-sampler dispose* handle>> clReleaseSampler cl-success ;


USING: accessors cuda.contexts destructors generalizations ;

M: clean-up-context-destructor dispose*
    alien>> clean-up-context 0 ndrop ;


USING: accessors cuda.gl destructors kernel ;

M: cuda-buffer dispose*
    [ [ free-resource ] when* f ] change-resource
    buffer>> dispose ; inline


USING: accessors cuda.memory destructors generalizations ;

M: cuda-free-destructor dispose* alien>> cuda-free 0 ndrop ;


USING: accessors curl.ffi curl.private destructors
generalizations ;

M: curl_easy_cleanup-destructor dispose*
    alien>> curl_easy_cleanup 0 ndrop ;


USING: accessors curses curses.ffi curses.private destructors ;

M: curses-window dispose* ptr>> delwin curses-error ;


USING: accessors db destructors kernel namespaces ;

M: db-connection dispose*
    dup db-connection [
        [ dispose-statements H{ } clone ]
        change-insert-statements
        [ dispose-statements H{ } clone ]
        change-update-statements
        [ dispose-statements H{ } clone ]
        change-delete-statements [ db-close f ] change-handle
        drop
    ] with-variable ;


USING: accessors destructors furnace.db ;

M: db-persistence dispose* pool>> dispose ;


USING: accessors cuda.contexts destructors generalizations ;

M: destroy-context-destructor dispose*
    alien>> destroy-context 0 ndrop ;


USING: accessors destructors discord kernel ;

M: discord-bot dispose*
    f >>reconnect? t >>stop? f >>send-heartbeat? [
        [ in>> &dispose drop ] [ out>> &dispose drop ]
        [ f >>in f >>out drop ] tri
    ] with-destructors ;


USING: accessors destructors ecdsa.private kernel
openssl.libcrypto ;

M: ec-key dispose* [ EC_KEY_free f ] change-handle drop ;


USING: accessors destructors llvm.ffi llvm.wrappers ;

M: engine dispose* value>> LLVMDisposeExecutionEngine ;


USING: accessors combinators core-foundation.fsevents
destructors ;

M: event-stream dispose*
    {
        [ info>> remove-event-source-callback ]
        [ handle>> disable-event-stream ]
        [ handle>> FSEventStreamInvalidate ]
        [ handle>> FSEventStreamRelease ]
    } cleave ;


USING: accessors checksums.openssl.private destructors ;

M: evp-md-context dispose* handle>> evp-md-ctx-free ;


USING: accessors curl.private destructors generalizations
io.streams.c ;

M: fclose-destructor dispose* alien>> fclose 0 ndrop ;


USING: accessors destructors fftw.ffi generalizations ;

M: fftw_free-destructor dispose* alien>> fftw_free 0 ndrop ;


USING: accessors destructors generalizations
io.files.acls.macos.private ;

M: free-acl-destructor dispose* alien>> free-acl 0 ndrop ;


USING: accessors destructors generalizations libc ;

M: free-destructor dispose* alien>> free 0 ndrop ;


USING: accessors cuda.gl destructors generalizations ;

M: free-resource-destructor dispose*
    alien>> free-resource 0 ndrop ;


USING: accessors destructors generalizations ifaddrs ;

M: freeifaddrs-destructor dispose* alien>> freeifaddrs 0 ndrop ;


USING: accessors destructors generalizations glib.ffi ;

M: g_free-destructor dispose* alien>> g_free 0 ndrop ;


USING: accessors destructors generalizations gobject.ffi ;

M: g_object_unref-destructor dispose*
    alien>> g_object_unref 0 ndrop ;


USING: accessors destructors generalizations glib.ffi ;

M: g_source_unref-destructor dispose*
    alien>> g_source_unref 0 ndrop ;


USING: accessors destructors gdbm.ffi gdbm.private
generalizations ;

M: gdbm-close-destructor dispose* alien>> gdbm-close 0 ndrop ;


USING: accessors destructors gdk2.ffi generalizations ;

M: gdk_cursor_unref-destructor dispose*
    alien>> gdk_cursor_unref 0 ndrop ;


USING: accessors destructors generalizations opengl.glu ;

M: gluDeleteNurbsRenderer-destructor dispose*
    alien>> gluDeleteNurbsRenderer 0 ndrop ;


USING: accessors destructors generalizations opengl.glu ;

M: gluDeleteQuadric-destructor dispose*
    alien>> gluDeleteQuadric 0 ndrop ;


USING: accessors destructors generalizations opengl.glu ;

M: gluDeleteTess-destructor dispose*
    alien>> gluDeleteTess 0 ndrop ;


USING: accessors destructors generalizations gtk2.ffi ;

M: gtk_widget_destroy-destructor dispose*
    alien>> gtk_widget_destroy 0 ndrop ;


USING: destructors html.streams.private ;

M: html-block-stream dispose* end-sub-stream format-html-div ;


USING: destructors html.streams.private ;

M: html-span-stream dispose* end-sub-stream format-html-span ;


USING: destructors html.streams kernel ;

M: html-writer dispose* drop ;


USING: accessors destructors io.backend.unix.multiplexers.kqueue
unix ;

M: kqueue-mx dispose* fd>> close-file ;


USING: accessors core-foundation core-text destructors ;

M: line dispose* line>> CFRelease ;


USING: accessors destructors generic io.monitors.macos kernel ;

M: macos-monitor dispose*
    [ handle>> dispose ]
    [ M\ macos-monitor dispose* (call-next-method) ] bi ;


USING: accessors destructors generalizations magic.ffi ;

M: magic_close-destructor dispose* alien>> magic_close 0 ndrop ;


USING: destructors io.mmap ;

M: mapped-file dispose* close-mapped-file ;


USING: destructors mongodb.connection ;

M: mdb-connection dispose* mdb-close ;


USING: accessors destructors llvm.ffi llvm.wrappers ;

M: module dispose* value>> LLVMDisposeModule ;


USING: accessors concurrency.mailboxes destructors io.monitors
io.monitors.private kernel ;

M: monitor dispose*
    [ monitor-disposed ] dip queue>> mailbox-put ;


USING: accessors checksums.multi destructors ;

M: multi-state dispose* states>> dispose-each ;


USING: accessors destructors opengl.textures.private sequences ;

M: multi-texture dispose* grid>> [ [ dispose ] each ] each ;


USING: accessors db.mysql db.mysql.ffi destructors kernel ;

M: mysql-result-set dispose*
    [ mysql_free_result f ] change-handle drop ;


USING: accessors destructors generalizations odbc ;

M: odbc-disconnect-destructor dispose*
    alien>> odbc-disconnect 0 ndrop ;


USING: accessors destructors generalizations odbc ;

M: odbc-free-env-destructor dispose*
    alien>> odbc-free-env 0 ndrop ;


USING: accessors destructors generalizations odbc ;

M: odbc-free-statement-destructor dispose*
    alien>> odbc-free-statement 0 ndrop ;


USING: accessors assocs destructors io.sockets.secure.openssl
kernel libc openssl.libssl sequences ;

M: openssl-context dispose*
    [
        [ aliens>> [ &free drop ] each ]
        [ sessions>> values [ SSL_SESSION_free ] each ]
        [ handle>> SSL_CTX_free ] tri
    ] with-destructors ;


USING: accessors combinators destructors io.ports
io.ports.private kernel ;

M: output-port dispose*
    [
        {
            [ handle>> &dispose drop ]
            [ buffer>> &dispose drop ]
            [ port-flush ]
            [ handle>> shutdown ]
        } cleave
    ] with-destructors ;


USING: accessors destructors generalizations pango.ffi ;

M: pango_font_description_free-destructor dispose*
    alien>> pango_font_description_free 0 ndrop ;


USING: accessors destructors generalizations pango.ffi ;

M: pango_layout_iter_free-destructor dispose*
    alien>> pango_layout_iter_free 0 ndrop ;


USING: accessors destructors pcre2 pcre2.ffi ;

M: pcre2 dispose* handle>> pcre2_code_free ;


USING: accessors destructors generalizations pcre2.ffi ;

M: pcre2_code_free-destructor dispose*
    alien>> pcre2_code_free 0 ndrop ;


USING: accessors destructors generalizations pcre2.ffi ;

M: pcre2_compile_context_free-destructor dispose*
    alien>> pcre2_compile_context_free 0 ndrop ;


USING: accessors destructors generalizations pcre2.ffi ;

M: pcre2_general_context_free-destructor dispose*
    alien>> pcre2_general_context_free 0 ndrop ;


USING: accessors destructors generalizations pcre2.ffi ;

M: pcre2_jit_stack_free-destructor dispose*
    alien>> pcre2_jit_stack_free 0 ndrop ;


USING: accessors destructors generalizations pcre2.ffi ;

M: pcre2_match_context_free-destructor dispose*
    alien>> pcre2_match_context_free 0 ndrop ;


USING: accessors destructors generalizations pcre2.ffi ;

M: pcre2_match_data_free-destructor dispose*
    alien>> pcre2_match_data_free 0 ndrop ;


USING: accessors destructors generalizations pcre2.ffi ;

M: pcre2_substring_free-destructor dispose*
    alien>> pcre2_substring_free 0 ndrop ;


USING: accessors destructors generalizations pcre2.ffi ;

M: pcre2_substring_list_free-destructor dispose*
    alien>> pcre2_substring_list_free 0 ndrop ;


USING: accessors destructors io kernel pdf.streams sequences ;

M: pdf-block-stream dispose*
    [ data>> ] [ parent>> ] bi
    [ data>> push-all ] [ stream-nl ] bi ;


USING: destructors kernel pdf.streams ;

M: pdf-writer dispose* drop ;


USING: accessors bittorrent destructors kernel timers ;

M: peer dispose*
    dup timer>> stop-timer [ dispose f ] change-stream f >>local
    f >>remote drop ;


USING: accessors destructors kernel ui.pixel-formats ;

M: pixel-format dispose*
    [ (free-pixel-format) ] [ f >>handle drop ] bi ;


USING: accessors destructors io.pools ;

M: pool dispose* connections>> dispose-each ;


USING: accessors destructors io.ports ;

M: port dispose*
    [ handle>> &dispose shutdown ] with-destructors ;


USING: accessors db.postgresql db.postgresql.ffi destructors
kernel ;

M: postgresql-result-set dispose*
    [ handle>> PQclear ] [ 0 >>n 0 >>max f >>handle drop ] bi ;


USING: accessors db.postgresql db.postgresql.ffi destructors
kernel ;

M: postgresql-statement dispose*
    dup handle>> PQclear f >>handle drop ;


USING: accessors checksums.process destructors kernel ;

M: process-state dispose* process>> [ dispose ] when* ;


USING: accessors destructors llvm.ffi llvm.wrappers ;

M: provider dispose* value>> LLVMDisposeModuleProvider ;


USING: accessors concurrency.messaging destructors generic
io.monitors.recursive kernel ;

M: recursive-monitor dispose*
    [ [ +stop+ ] dip thread>> send ]
    [ M\ recursive-monitor dispose* (call-next-method) ] bi ;


USING: accessors alien.handles destructors generalizations ;

M: release-alien-handle-destructor dispose*
    alien>> release-alien-handle 0 ndrop ;


USING: accessors alien.handles destructors generalizations ;

M: release-alien-handle-ptr-destructor dispose*
    alien>> release-alien-handle-ptr 0 ndrop ;


USING: db destructors kernel ;

M: result-set dispose* drop ;


USING: accessors destructors rocksdb.ffi rocksdb.lib ;

M: rocksdb-handle dispose* ptr>> rocksdb_close ;


USING: accessors destructors rocksdb.ffi rocksdb.lib ;

M: rocksdb-options dispose* ptr>> rocksdb_options_destroy ;


USING: accessors destructors rocksdb.ffi rocksdb.lib ;

M: rocksdb-read-options dispose*
    ptr>> rocksdb_readoptions_destroy ;


USING: accessors destructors rocksdb.ffi rocksdb.lib ;

M: rocksdb-write-options dispose*
    ptr>> rocksdb_writeoptions_destroy ;


USING: accessors db.tuples destructors furnace.cache
furnace.scopes kernel ;

M: scope-saver dispose*
    [ manager>> ] [ scope>> ] bi dup changed?>>
    [ [ swap touch-state ] [ update-tuple ] bi ] [ 2drop ] if ;


USING: accessors destructors kernel opengl opengl.textures
opengl.textures.private ;

M: single-texture dispose*
    [ texture>> [ delete-texture ] when* ]
    [ display-list>> [ delete-dlist ] when* ] bi ;


USING: accessors db.sqlite destructors kernel ;

M: sqlite-result-set dispose* f >>handle drop ;


USING: accessors db.sqlite db.sqlite.ffi db.sqlite.lib
destructors kernel ;

M: sqlite-statement dispose*
    handle>>
    [ [ sqlite3_reset drop ] keep sqlite-finalize ] when* ;


USING: accessors destructors io.sockets.secure.openssl kernel
openssl.libssl ;

M: ssl-handle dispose*
    [ [ file>> &dispose drop ] [ handle>> SSL_free ] bi ]
    with-destructors ;


USING: db destructors kernel ;

M: statement dispose* drop ;


USING: accessors alien.c-types alien.data audio.engine
destructors generic kernel openal ;

M: static-audio-clip dispose*
    [ M\ static-audio-clip dispose* (call-next-method) ]
    [ [ 1 ] dip al-buffer>> uint <ref> alDeleteBuffers ] bi ;


USING: accessors destructors io.backend.unix kernel ;

M: stdin dispose*
    [
        [ control>> &dispose drop ] [ size>> &dispose drop ]
        [ data>> &dispose drop ] tri
    ] with-destructors ;


USING: accessors audio.engine destructors generic kernel openal
sequences ;

M: streaming-audio-clip dispose*
    [ M\ streaming-audio-clip dispose* (call-next-method) ]
    [ generator>> dispose ]
    [ al-buffers>> [ length ] keep alDeleteBuffers ] tri ;


USING: accessors destructors generalizations libtls.ffi ;

M: tls_config_free-destructor dispose*
    alien>> tls_config_free 0 ndrop ;


USING: accessors destructors generalizations libtls.ffi ;

M: tls_free-destructor dispose* alien>> tls_free 0 ndrop ;


USING: accessors destructors kernel tokyo.abstractdb
tokyo.alien.tcadb ;

M: tokyo-abstractdb dispose* [ tcadbdel f ] change-handle drop ;


USING: accessors destructors kernel tokyo.alien.tcrdb
tokyo.remotedb ;

M: tokyo-remotedb dispose* [ tcrdbdel f ] change-handle drop ;


USING: accessors destructors generalizations raylib ;

M: unload-audio-stream-destructor dispose*
    alien>> unload-audio-stream 0 ndrop ;


USING: accessors destructors generalizations raylib ;

M: unload-file-data-destructor dispose*
    alien>> unload-file-data 0 ndrop ;


USING: accessors destructors generalizations raylib ;

M: unload-file-text-destructor dispose*
    alien>> unload-file-text 0 ndrop ;


USING: accessors destructors generalizations raylib ;

M: unload-font-destructor dispose* alien>> unload-font 0 ndrop ;


USING: accessors destructors generalizations raylib ;

M: unload-image-colors-destructor dispose*
    alien>> unload-image-colors 0 ndrop ;


USING: accessors destructors generalizations raylib ;

M: unload-image-destructor dispose*
    alien>> unload-image 0 ndrop ;


USING: accessors destructors generalizations raylib ;

M: unload-image-palette-destructor dispose*
    alien>> unload-image-palette 0 ndrop ;


USING: accessors destructors generalizations raylib ;

M: unload-material-destructor dispose*
    alien>> unload-material 0 ndrop ;


USING: accessors destructors generalizations raylib ;

M: unload-mesh-destructor dispose* alien>> unload-mesh 0 ndrop ;


USING: accessors destructors generalizations raylib ;

M: unload-model-animation-destructor dispose*
    alien>> unload-model-animation 0 ndrop ;


USING: accessors destructors generalizations raylib ;

M: unload-model-destructor dispose*
    alien>> unload-model 0 ndrop ;


USING: accessors destructors generalizations raylib ;

M: unload-music-stream-destructor dispose*
    alien>> unload-music-stream 0 ndrop ;


USING: accessors destructors generalizations raylib ;

M: unload-render-texture-destructor dispose*
    alien>> unload-render-texture 0 ndrop ;


USING: accessors destructors generalizations raylib ;

M: unload-shader-destructor dispose*
    alien>> unload-shader 0 ndrop ;


USING: accessors destructors generalizations raylib ;

M: unload-sound-destructor dispose*
    alien>> unload-sound 0 ndrop ;


USING: accessors destructors generalizations raylib ;

M: unload-texture-destructor dispose*
    alien>> unload-texture 0 ndrop ;


USING: accessors destructors generalizations raylib ;

M: unload-wave-destructor dispose* alien>> unload-wave 0 ndrop ;


USING: accessors cuda.gl destructors generalizations ;

M: unmap-resource-destructor dispose*
    alien>> unmap-resource 0 ndrop ;


USING: accessors destructors furnace.auth furnace.auth.providers
kernel ;

M: user-saver dispose*
    user>> dup changed?>> [ users update-user ] [ drop ] if ;


USING: accessors audio.vorbis combinators destructors kernel
libc ogg.vorbis ;

M: vorbis-stream dispose*
    {
        [ temp-state>> [ free ] when* ]
        [
            comment>>
            [ [ vorbis_comment_clear ] [ free ] bi ] when*
        ]
        [ block>> [ free ] when* ]
        [ dsp-state>> [ free ] when* ]
        [ info>> [ [ vorbis_info_clear ] [ free ] bi ] when* ]
        [ stream-state>> [ free ] when* ]
        [ page>> [ free ] when* ]
        [ sync-state>> [ free ] when* ]
        [ packet>> [ free ] when* ]
        [ stream>> [ dispose ] when* ]
    } cleave ;


USING: accessors destructors generalizations yaml.ffi ;

M: yaml_document_delete-destructor dispose*
    alien>> yaml_document_delete 0 ndrop ;


USING: accessors destructors generalizations yaml.ffi ;

M: yaml_emitter_delete-destructor dispose*
    alien>> yaml_emitter_delete 0 ndrop ;


USING: accessors destructors generalizations yaml.ffi ;

M: yaml_event_delete-destructor dispose*
    alien>> yaml_event_delete 0 ndrop ;


USING: accessors destructors generalizations yaml.ffi ;

M: yaml_parser_delete-destructor dispose*
    alien>> yaml_parser_delete 0 ndrop ;


USING: accessors destructors generalizations yaml.ffi ;

M: yaml_token_delete-destructor dispose*
    alien>> yaml_token_delete 0 ndrop ;


USING: accessors destructors kernel zim ;

M: zim dispose* [ dispose f ] change-stream drop ;


USING: accessors destructors zeromq zeromq.ffi ;

M: zmq-context dispose*
    underlying>> zmq_ctx_destroy check-zmq-error ;


USING: accessors destructors zeromq zeromq.ffi ;

M: zmq-message dispose*
    underlying>> zmq_msg_close check-zmq-error ;


USING: accessors destructors zeromq zeromq.ffi ;

M: zmq-socket dispose* underlying>> zmq_close check-zmq-error ;