Rust Lang

1 users here now

Rules [Developing]

Observe our code of conduct

• Strive to treat others with respect, patience, kindness, and empathy.
• We observe the Rust Project Code of Conduct.
• Submissions must be on-topic
• Posts must reference Rust or relate to things using Rust. For content that does not, use a text post to explain its relevance.
• Post titles should include useful context.
• For Rust questions, use the stickied Q&A thread. [TBD]
• Arts-and-crafts posts are permitted on weekends.
• No meta posts; message the mods instead.

Constructive criticism only

• Criticism is encouraged, though it must be constructive, useful and actionable.
• If criticizing a project on GitHub, you may not link directly to the project’s issue tracker. Please create a read-only mirror and link that instead.
• Keep things in perspective
• A programming language is rarely worth getting worked up over.
• No zealotry or fanaticism.
• Be charitable in intent. Err on the side of giving others the benefit of the doubt.

No endless relitigation

• Avoid re-treading topics that have been long-settled or utterly exhausted.
• Avoid bikeshedding.
• This is not an official Rust forum, and cannot fulfill feature requests. Use the official venues for that.

No low-effort content

• Showing off your new projects is fine

No memes or image macros

• Please find other communities to post memes

No NSFW Content

• There are many other NSFW communities, let’s keep this related to the language

MODERATORS

use std::{
    any::{Any, TypeId},
    marker::PhantomData,
};

#[derive(Clone, Debug)]
pub struct AnySlice<'a> {
    tid: TypeId,
    len: usize,
    ptr: *const (),
    marker: PhantomData<&'a ()>,
}

impl<'a> AnySlice<'a> {
    pub fn from_slice(s: &'a [T]) -> Self {
        Self {
            len: s.len(),
            ptr: s.as_ptr() as *const (),
            tid: TypeId::of::(),
            marker: PhantomData,
        }
    }

    pub fn as_slice(&self) -> Option<&'a [T]> {
        if TypeId::of::() != self.tid {
            return None;
        }
        Some(unsafe { std::slice::from_raw_parts(self.ptr as *const T, self.len) })
    }

    pub fn is(&self) -> bool {
        TypeId::of::() == self.tid
    }
}

// ^ impl AnySliceMut
    pub unsafe fn as_slice_mut(&mut self) -> Option<&'a mut [T]> {
        if TypeId::of::() != self.tid {
            return None;
        }
        Some(unsafe { std::slice::from_raw_parts_mut(self.ptr as *mut T, self.len) })
    }