다음의 예제를 생각해 봅시다:

fn main() {
    let mut v: Vec<&str> = Vec::new();
    let s: String = "Short-lived".into();
    v.push(&s);
    drop(s);
} // <- `v` 는 여기서 해제됩니다

정석적으로 impl<T> Drop for Vec<T> {를 정의하면, 위의 코드는 부정됩니다.

확실히 이런 경우에서는, 우리는 Vec<&'s str>, 즉 str의 's만큼 사는 레퍼런스들의 벡터를 가지고 있습니다. 하지만 let s: String에서는, 이것이 Vec보다 먼저 해제되고, impl<'s> Drop for Vec<&'s str> {의 정의가 사용됩니다.

이것이 의미하는 것은 만약 이런 Drop 구현이 사용된다면, 파기된, 혹은 달랑거리는 수명 's로 작업을 할 것이라는 점입니다. 하지만 이것은 함수 시그니처에 있는 모든 러스트 레퍼런스는 기본적으로 달랑거리지 않고 역참조해도 문제가 없다는 러스트 규칙에 반대됩니다.

따라서 러스트는 보수적으로 이 코드를 부정할 수밖에 없습니다.

그런데 실제 Vec의 경우에서, Drop 구현은 &'s str에 대해 신경쓰지 않는데, 이는 &'s str이 따로 Drop 구현이 없기 때문입니다: Vec의 Drop 구현은 그저 버퍼를 해제하고 싶을 뿐이죠.

즉, Vec의 경우를 특별하게 구분해서, 또는 Vec의 특수한 성질을 이용해서 위의 코드가 컴파일되면 좋겠네요: Vec이 가지고 있는 &'s str들을 해제될 때 사용하지 않도록 약속할 수도 있겠어요.

이 약속은 #[may_dangle]로 표현될 수 있는 unsafe한 약속입니다:

unsafe impl<#[may_dangle] 's> Drop for Vec<&'s str> { /* … */ }

아니면 좀더 일반적으로 표현하자면:

unsafe impl<#[may_dangle] T> Drop for Vec<T> { /* … */ }

이것이 러스트의 해제 검사기가 해제되는 값의 타입 매개변수가 달랑거리지 않도록 하는, 보수적인 추측에서 탈출하도록 하는 unsafe한 방법입니다.

표준 라이브러리와 같이 이렇게 했다면, 우리는 T가 자체의 Drop 구현이 있는 경우를 조심해야 합니다. 이 경우에는, &'s str를 struct PrintOnDrop<'s>(&'s str);로 바꾸는 것을 상상해 봅시다. 이 구조체는 자체의 Drop 구현에서 내부의 &'s str를 역참조하여 화면에 출력할 것입니다.

확실히 버퍼를 해제하기 전에 Drop for Vec<T> {는, 내부의 각 T들이 Drop 구현이 있을 때, 각 T들을 해제시켜야 합니다. PrintOnDrop<'s>의 경우에 Drop for Vec<PrintOnDrop<'s>>는 버퍼를 해제하기 전에 PrintOnDrop<'s>의 원소들을 해제시켜야 합니다.

따라서 우리가 's가 #[may_dangle]하다고 말할 때, 이것은 심하게 모호하게 말했던 것입니다. 우리는 대신 이렇게 말해야 할 것입니다: "'s는 Drop 구현에 구속받지 않는 한에서 달랑거릴 수도 있습니다". 혹은 더 일반적으로 이렇게요: "T는 Drop 구현에 구속받지 않는 한에서 달랑거릴 수도 있습니다". 이런 "예외의 예외"는 우리가 T를 소유할 때마다 발생하는 흔한 현상입니다. 이래서 러스트의 #[may_dangle]은 이런 예외 상황에 대해 알고, 따라서 구조체의 필드들에 제네릭 매개변수가 소유되는 때에 비활성화될 것입니다.

따라서 표준 라이브러리는 이렇게 결론을 내립니다:

#![allow(unused)]
fn main() {
#[cfg(any())]
// 우리는 `Vec`을 해제할 때 `T`를 사용하지 않도록 약속합니다…
unsafe impl<#[may_dangle] T> Drop for Vec<T> {
    fn drop(&mut self) {
        unsafe {
            if mem::needs_drop::<T>() {
                /* … 이 경우는 제외하고요, 어떤 경우냐면 … */
                ptr::drop_in_place::<[T]>(/* … */);
            }
            // …
            dealloc(/* … */)
            // …
        }
    }
}

struct Vec<T> {
    // … `Vec`이 `T`의 원소들을 소유하고,
    // 따라서 해제될 때 `T`의 원소들을 해제시킬 때 말이죠!
    _owns_T: core::marker::PhantomData<T>,

    ptr: *const T, // 변성을 위한 `*const`입니다 (하지만 이것이 *그 자체로* `T`의 소유권을 나타내는 것은 아닙니다)
    len: usize,
    cap: usize,
}
}