Trait Finalize 

pub trait Finalize {
    // Provided method
    fn finalize(&self) { ... }
}

Substitute for the Drop trait for garbage collected types.

Provided Methods

fn finalize(&self)

Cleanup logic for a type.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl Finalize for ()

impl Finalize for Atomic<bool>

impl Finalize for Atomic<i8>

impl Finalize for Atomic<i16>

impl Finalize for Atomic<i32>

impl Finalize for Atomic<i64>

impl Finalize for Atomic<isize>

impl Finalize for Atomic<u8>

impl Finalize for Atomic<u16>

impl Finalize for Atomic<u32>

impl Finalize for Atomic<u64>

impl Finalize for Atomic<usize>

impl Finalize for File

impl Finalize for FileType

impl Finalize for Instant

impl Finalize for LanguageIdentifier

impl Finalize for Locale

impl Finalize for NonZero<i8>

impl Finalize for NonZero<i16>

impl Finalize for NonZero<i32>

impl Finalize for NonZero<i64>

impl Finalize for NonZero<i128>

impl Finalize for NonZero<isize>

impl Finalize for NonZero<u8>

impl Finalize for NonZero<u16>

impl Finalize for NonZero<u32>

impl Finalize for NonZero<u64>

impl Finalize for NonZero<u128>

impl Finalize for NonZero<usize>

impl Finalize for Path

impl Finalize for PathBuf

impl Finalize for Rc<str>

impl Finalize for String

impl Finalize for Sym

impl Finalize for SystemTime

impl Finalize for TcpStream

impl Finalize for TypeId

impl Finalize for UdpSocket

impl Finalize for bool

impl Finalize for char

impl Finalize for f32

impl Finalize for f64

impl Finalize for i8

impl Finalize for i16

impl Finalize for i32

impl Finalize for i64

impl Finalize for i128

impl Finalize for isize

impl Finalize for str

impl Finalize for u8

impl Finalize for u16

impl Finalize for u32

impl Finalize for u64

impl Finalize for u128

impl Finalize for usize

impl<A, B, C, D, E, F, G, H, I, J, K, L> Finalize for (A, B, C, D, E, F, G, H, I, J, K, L)

impl<A, B, C, D, E, F, G, H, I, J, K> Finalize for (A, B, C, D, E, F, G, H, I, J, K)

impl<A, B, C, D, E, F, G, H, I, J> Finalize for (A, B, C, D, E, F, G, H, I, J)

impl<A, B, C, D, E, F, G, H, I> Finalize for (A, B, C, D, E, F, G, H, I)

impl<A, B, C, D, E, F, G, H> Finalize for (A, B, C, D, E, F, G, H)

impl<A, B, C, D, E, F, G> Finalize for (A, B, C, D, E, F, G)

impl<A, B, C, D, E, F> Finalize for (A, B, C, D, E, F)

impl<A, B, C, D, E> Finalize for (A, B, C, D, E)

impl<A, B, C, D> Finalize for (A, B, C, D)

impl<A, B, C> Finalize for (A, B, C)

impl<A, B> Finalize for (A, B)

impl<A> Finalize for (A,)

impl<K, V, S> Finalize for HashMap<K, V, S>

where K: Eq + Hash + Trace, V: Trace, S: BuildHasher,

impl<K, V, S> Finalize for HashMap<K, V, S>

where K: Eq + Hash + Trace, V: Trace, S: BuildHasher,

impl<K, V> Finalize for BTreeMap<K, V>

where K: Trace, V: Trace,

impl<L, R> Finalize for Either<L, R>

where L: Trace, R: Trace,

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Finalize for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Finalize for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Finalize for fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Finalize for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Finalize for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Finalize for unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Finalize for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Finalize for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Finalize for fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Finalize for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Finalize for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Finalize for unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J> Finalize for extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J> Finalize for extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J> Finalize for fn(A, B, C, D, E, F, G, H, I, J) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J> Finalize for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J> Finalize for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J> Finalize for unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I> Finalize for extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I> Finalize for extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I> Finalize for fn(A, B, C, D, E, F, G, H, I) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I> Finalize for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I> Finalize for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I> Finalize for unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret

impl<Ret, A, B, C, D, E, F, G, H> Finalize for extern "C" fn(A, B, C, D, E, F, G, H) -> Ret

impl<Ret, A, B, C, D, E, F, G, H> Finalize for extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G, H> Finalize for fn(A, B, C, D, E, F, G, H) -> Ret

impl<Ret, A, B, C, D, E, F, G, H> Finalize for unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret

impl<Ret, A, B, C, D, E, F, G, H> Finalize for unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G, H> Finalize for unsafe fn(A, B, C, D, E, F, G, H) -> Ret

impl<Ret, A, B, C, D, E, F, G> Finalize for extern "C" fn(A, B, C, D, E, F, G) -> Ret

impl<Ret, A, B, C, D, E, F, G> Finalize for extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G> Finalize for fn(A, B, C, D, E, F, G) -> Ret

impl<Ret, A, B, C, D, E, F, G> Finalize for unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret

impl<Ret, A, B, C, D, E, F, G> Finalize for unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G> Finalize for unsafe fn(A, B, C, D, E, F, G) -> Ret

impl<Ret, A, B, C, D, E, F> Finalize for extern "C" fn(A, B, C, D, E, F) -> Ret

impl<Ret, A, B, C, D, E, F> Finalize for extern "C" fn(A, B, C, D, E, F, ...) -> Ret

impl<Ret, A, B, C, D, E, F> Finalize for fn(A, B, C, D, E, F) -> Ret

impl<Ret, A, B, C, D, E, F> Finalize for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret

impl<Ret, A, B, C, D, E, F> Finalize for unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret

impl<Ret, A, B, C, D, E, F> Finalize for unsafe fn(A, B, C, D, E, F) -> Ret

impl<Ret, A, B, C, D, E> Finalize for extern "C" fn(A, B, C, D, E) -> Ret

impl<Ret, A, B, C, D, E> Finalize for extern "C" fn(A, B, C, D, E, ...) -> Ret

impl<Ret, A, B, C, D, E> Finalize for fn(A, B, C, D, E) -> Ret

impl<Ret, A, B, C, D, E> Finalize for unsafe extern "C" fn(A, B, C, D, E) -> Ret

impl<Ret, A, B, C, D, E> Finalize for unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret

impl<Ret, A, B, C, D, E> Finalize for unsafe fn(A, B, C, D, E) -> Ret

impl<Ret, A, B, C, D> Finalize for extern "C" fn(A, B, C, D) -> Ret

impl<Ret, A, B, C, D> Finalize for extern "C" fn(A, B, C, D, ...) -> Ret

impl<Ret, A, B, C, D> Finalize for fn(A, B, C, D) -> Ret

impl<Ret, A, B, C, D> Finalize for unsafe extern "C" fn(A, B, C, D) -> Ret

impl<Ret, A, B, C, D> Finalize for unsafe extern "C" fn(A, B, C, D, ...) -> Ret

impl<Ret, A, B, C, D> Finalize for unsafe fn(A, B, C, D) -> Ret

impl<Ret, A, B, C> Finalize for extern "C" fn(A, B, C) -> Ret

impl<Ret, A, B, C> Finalize for extern "C" fn(A, B, C, ...) -> Ret

impl<Ret, A, B, C> Finalize for fn(A, B, C) -> Ret

impl<Ret, A, B, C> Finalize for unsafe extern "C" fn(A, B, C) -> Ret

impl<Ret, A, B, C> Finalize for unsafe extern "C" fn(A, B, C, ...) -> Ret

impl<Ret, A, B, C> Finalize for unsafe fn(A, B, C) -> Ret

impl<Ret, A, B> Finalize for extern "C" fn(A, B) -> Ret

impl<Ret, A, B> Finalize for extern "C" fn(A, B, ...) -> Ret

impl<Ret, A, B> Finalize for fn(A, B) -> Ret

impl<Ret, A, B> Finalize for unsafe extern "C" fn(A, B) -> Ret

impl<Ret, A, B> Finalize for unsafe extern "C" fn(A, B, ...) -> Ret

impl<Ret, A, B> Finalize for unsafe fn(A, B) -> Ret

impl<Ret, A> Finalize for extern "C" fn(A) -> Ret

impl<Ret, A> Finalize for extern "C" fn(A, ...) -> Ret

impl<Ret, A> Finalize for fn(A) -> Ret

impl<Ret, A> Finalize for unsafe extern "C" fn(A) -> Ret

impl<Ret, A> Finalize for unsafe extern "C" fn(A, ...) -> Ret

impl<Ret, A> Finalize for unsafe fn(A) -> Ret

impl<Ret> Finalize for extern "C" fn() -> Ret

impl<Ret> Finalize for fn() -> Ret

impl<Ret> Finalize for unsafe extern "C" fn() -> Ret

impl<Ret> Finalize for unsafe fn() -> Ret

impl<T, E> Finalize for Result<T, E>

where T: Trace, E: Trace,

impl<T, S> Finalize for HashSet<T, S>

where T: Eq + Hash + Trace, S: BuildHasher,

impl<T, const N: usize> Finalize for ArrayVec<T, N>

where T: Trace,

Available on crate feature arrayvec only.

impl<T, const N: usize> Finalize for [T; N]

where T: Trace,

impl<T> Finalize for &'static T

where T: ?Sized,

impl<T> Finalize for BTreeSet<T>

where T: Trace,

impl<T> Finalize for BinaryHeap<T>

where T: Ord + Trace,

impl<T> Finalize for Box<T>

where T: Trace + ?Sized,

impl<T> Finalize for Box<[T]>

where T: Trace,

impl<T> Finalize for Cell<T>

where T: Trace + Default,

impl<T> Finalize for Cow<'static, T>

where T: ToOwned + Trace + ?Sized,

impl<T> Finalize for LinkedList<T>

where T: Eq + Hash + Trace,

impl<T> Finalize for OnceCell<T>

where T: Trace,

impl<T> Finalize for Option<T>

where T: Trace,

impl<T> Finalize for PhantomData<T>

impl<T> Finalize for ThinVec<T>

where T: Trace,

Available on crate feature thin-vec only.

impl<T> Finalize for Vec<T>

where T: Trace,

impl<T> Finalize for VecDeque<T>

where T: Trace,

Implementors

impl Finalize for ActiveRunnable

impl Finalize for ArrayBuffer

impl Finalize for AsyncGenerator

impl Finalize for BoundFunction

impl Finalize for CallFrame

impl Finalize for ClassFieldDefinition

impl Finalize for CodeBlock

impl Finalize for DataView

impl Finalize for Date

impl Finalize for DescriptorKind

impl Finalize for Duration

impl Finalize for EngineError

impl Finalize for ErasedEngineError

impl Finalize for ErasedObjectData

impl Finalize for ErasedPanicError

impl Finalize for Error

impl Finalize for ErrorKind

impl Finalize for GcErased

impl Finalize for Generator

impl Finalize for ImportAttribute

impl Finalize for IndexedProperties

impl Finalize for boa_engine::builtins::temporal::Instant

impl Finalize for Intl

impl Finalize for IntrinsicObjects

impl Finalize for Intrinsics

impl Finalize for IsHTMLDDA

impl Finalize for IteratorPrototypes

impl Finalize for IteratorRecord

impl Finalize for IteratorResult

impl Finalize for JobCallback

impl Finalize for JsArray

impl Finalize for JsArrayBuffer

impl Finalize for JsAsyncGenerator

impl Finalize for JsBigInt

impl Finalize for JsBigInt64Array

impl Finalize for JsBigUint64Array

impl Finalize for JsDataView

impl Finalize for JsDate

impl Finalize for JsErasedError

impl Finalize for JsErasedNativeError

impl Finalize for JsErasedNativeErrorKind

impl Finalize for JsError

impl Finalize for JsFloat16Array

impl Finalize for JsFloat32Array

impl Finalize for JsFloat64Array

impl Finalize for JsFunction

impl Finalize for JsGenerator

impl Finalize for JsGeneratorFunction

impl Finalize for JsInt8Array

impl Finalize for JsInt16Array

impl Finalize for JsInt32Array

impl Finalize for JsMap

impl Finalize for JsMapIterator

impl Finalize for JsNativeError

impl Finalize for JsNativeErrorKind

impl Finalize for JsPromise

impl Finalize for JsProxy

impl Finalize for JsRegExp

impl Finalize for JsRevocableProxy

impl Finalize for JsSet

impl Finalize for JsSetIterator

impl Finalize for JsSharedArrayBuffer

impl Finalize for JsString

impl Finalize for JsSymbol

impl Finalize for JsTypedArray

impl Finalize for JsUint8Array

impl Finalize for JsUint8ClampedArray

impl Finalize for JsUint16Array

impl Finalize for JsUint32Array

impl Finalize for JsValue

impl Finalize for JsWeakMap

impl Finalize for JsWeakSet

impl Finalize for Module

impl Finalize for ModuleNamespace

impl Finalize for ModuleRequest

impl Finalize for NativeFunction

impl Finalize for NativeFunctionObject

impl Finalize for OrderedSet

impl Finalize for OrdinaryFunction

impl Finalize for OrdinaryObject

impl Finalize for PanicError

impl Finalize for PlainDate

impl Finalize for PlainDateTime

impl Finalize for PlainMonthDay

impl Finalize for PlainTime

impl Finalize for PlainYearMonth

impl Finalize for PrivateElement

impl Finalize for PrivateName

impl Finalize for Promise

impl Finalize for PromiseState

impl Finalize for PropertyDescriptor

impl Finalize for PropertyKey

impl Finalize for PropertyMap

impl Finalize for Proxy

impl Finalize for Realm

impl Finalize for RegExp

impl Finalize for ResolvingFunctions

impl Finalize for RootShape

impl Finalize for RuntimeLimitError

impl Finalize for Script

impl Finalize for Shape

impl Finalize for SharedArrayBuffer

impl Finalize for SharedShape

impl Finalize for StandardConstructor

impl Finalize for StandardConstructors

impl Finalize for SyntheticModule

impl Finalize for SyntheticModuleInitializer

impl Finalize for ThisMode

impl Finalize for TypedArray

impl Finalize for TypedArrayKind

impl Finalize for UriFunctions

impl Finalize for ZonedDateTime

impl<A: TryIntoJsArguments, R: TryFromJs> Finalize for TypedJsFunction<A, R>

impl<K, V> Finalize for Ephemeron<K, V>

where K: Trace + ?Sized, V: Trace,

impl<K, V> Finalize for WeakMap<K, V>

where K: Trace + 'static + ?Sized, V: Trace + 'static,

impl<T: ?Sized + Finalize> Finalize for HostDefined<T>

impl<T: ?Sized> Finalize for Object<T>

impl<T: NativeObject + ?Sized> Finalize for WeakJsObject<T>

impl<T: NativeObject> Finalize for JsObject<T>

impl<T: TryFromJs> Finalize for Convert<T>

impl<T> Finalize for Gc<T>

where T: Trace + ?Sized,

impl<T> Finalize for GcRefCell<T>

where T: Trace + ?Sized,

impl<T> Finalize for WeakGc<T>

where T: Trace + 'static + ?Sized,

impl<V> Finalize for OrderedMap<V>