Rust: format_args! के स्थिर डेटा में टाइप-मिटा fmt fn पॉइंटर्स का अनुमान लगाने के लिए #[repr(C)] HList का उपयोग करें।

को निर्मित 5 सित॰ 2017 · 3टिप्पणियाँ · स्रोत: rust-lang/rust

अभी format_args! उपयोग करता है, उदाहरण के लिए ArgumentV1::new(&runtime_data, Debug::fmt) ( {:?} ), रनटाइम पर, केवल एक ( &runtime_data ) के बजाय रनटाइम पर प्रति तर्क दो पॉइंटर्स का उपयोग करना। .

allow_internal_unsafe और #44240 के साथ, हम (जैसे Debug::fmt ) fn पॉइंटर्स को (रावल्यू-प्रमोटेड) 'static डेटा में रख सकते हैं, शेष बाधा यह है कि कैसे रनटाइम डेटा के प्रकार का अनुमान लगाने के लिए।
यानी, Debug::fmt वास्तव में <_ as Debug>::fmt और _ का अनुमान अभी लगाया गया है क्योंकि ArgumentV1::new के हस्ताक्षर उन्हें एक साथ टाइप कर रहे हैं। अगर वे अलग हैं, तो हमें कुछ नया चाहिए।

मैं HList पैटर्न ( struct HCons<H, T>(H, T); struct HNil; का उपयोग करने का प्रस्ताव करता हूं - इसलिए 3 तत्वों के लिए, प्रकार A , B और C आपके पास होगा HCons<A, HCons<B, HCons<C, HNil>>> ), साथ में #[repr(C)] , जो इसे एक नियतात्मक लेआउट देगा जो एक सरणी से मेल खाता है, यानी ये दोनों:

&'static HCons<fn(&A), HCons<fn(&B), HCons<fn(&C), HNil>>>
&'static [unsafe fn(*const Opaque); 3]

एक ही प्रतिनिधित्व है, और बाद वाले को एक स्लाइस में अनसाइज़ किया जा सकता है। HList से सरणी (और फिर स्लाइस) में यह परिवर्तन एक सुरक्षित, प्रतिद्वंद्विता-प्रचारित HCons शीर्ष पर किया जा सकता है, जो fn पॉइंटर्स को स्थानांतरित करने के लिए एक आवश्यक आवश्यकता है 'static डेटा में बिल्कुल भी।

निष्कर्ष के लिए, हम बस जैसे प्रकार अप मैच के लिए उसका अनुमान लगाने के लिए कुछ फ़ंक्शन कॉल सम्मिलित कर सकते हैं B हम कर सकता है fmt::unify_fn_with_data((list.1).0, &b) है, जो होगा B में typeof b ।

पूरी तरह से सुरक्षित "बिल्डर" इंटरफ़ेस होना वास्तव में आसान हो सकता है, जो HList को HList रनटाइम संदर्भों के साथ जोड़ता है, प्रकारों को एकीकृत करता है, लेकिन मैं इसके बारे में थोड़ा चिंतित हूं सभी विशेषता प्रेषण के कारण संकलन-समय - किसी भी मामले में, प्रभाव को मापा जाना चाहिए।

A-fmt C-enhancement I-heavy T-libs

स्रोत

eddyb

सबसे उपयोगी टिप्पणी

अनुमान के लिए, हम प्रकारों से मेल खाने के लिए बस कुछ फ़ंक्शन कॉल सम्मिलित कर सकते हैं, उदाहरण के लिए B का अनुमान लगाने के लिए हम fmt::unify_fn_with_data((list.1).0, &b) , जो B को typeof b ।

मुझे यकीन नहीं है कि मैं वहां क्या सोच रहा था, यह उससे कहीं ज्यादा आसान होना चाहिए!

struct ArgMetadata<T: ?Sized> {
    // Only `unsafe` because of the later cast we do from `T` to `Opaque`.
    fmt: unsafe fn(&T, &mut Formatter<'_>) -> Result,
    // ... flags, constant string fragments, etc.
}

// TODO: maybe name this something else to emphasize repr(C)?
#[repr(C)]
struct HCons<T, Rest>(T, Rest);

// This would have to be in a "sealed module" to make it impossible to implement on more types.
trait MetadataFor<D> {
    const LEN: usize;
}
impl MetadataFor<()> for () {
    const LEN: usize = 0;
}
impl<'a, T: ?Sized, D, M> MetadataFor<HCons<&'a T, D>> for HCons<ArgMetadata<T>, M>
    where M: MetadataFor<D>
{
    const LEN: usize = M::LEN;
}

impl<'a> Arguments<'a> {
    fn new<M, D>(meta: &'a M, data: &'a D) -> Self
        where M: MetadataFor<D>
    {
        Self {
            meta: unsafe { &*(meta as *const _ as *const [ArgMetadata<Opaque>; M::LEN]) },
            data: unsafe { &*(data as *const _ as *const [&Opaque; M::LEN]) },
        }
    }
}

यानी हम दो HList s "समानांतर में" बनाते हैं, एक पूरी तरह से स्थिर मेटाडेटा के साथ, और दूसरा रनटाइम डेटा के संदर्भ के साथ, और फिर सभी प्रकार के अनुमान where से आ सकते हैं fmt::Arguments::new पर शून्य कोडजन क्रॉफ्ट के साथ क्लॉज!

संपादित करें : @ एम-ओ-से को मुझे याद दिलाना पड़ा कि मैं पहली बार स्पष्ट अनुमान चाल के साथ क्यों गया: यादृच्छिक अभिगम तर्क: निराश:
(हो सकता है कि पर्याप्त कॉन्स जेनरिक ab उपयोग के साथ हमारे पास D: IndexHList<i, Output = T> लेकिन यह बहुत प्रयास है)

eddyb 5 नव॰ 2020

❤2

सभी 3 टिप्पणियाँ

@rustbot दावा

m-ou-se 5 नव॰ 2020

अनुमान के लिए, हम प्रकारों से मेल खाने के लिए बस कुछ फ़ंक्शन कॉल सम्मिलित कर सकते हैं, उदाहरण के लिए B का अनुमान लगाने के लिए हम fmt::unify_fn_with_data((list.1).0, &b) , जो B को typeof b ।

struct ArgMetadata<T: ?Sized> {
    // Only `unsafe` because of the later cast we do from `T` to `Opaque`.
    fmt: unsafe fn(&T, &mut Formatter<'_>) -> Result,
    // ... flags, constant string fragments, etc.
}

// TODO: maybe name this something else to emphasize repr(C)?
#[repr(C)]
struct HCons<T, Rest>(T, Rest);

// This would have to be in a "sealed module" to make it impossible to implement on more types.
trait MetadataFor<D> {
    const LEN: usize;
}
impl MetadataFor<()> for () {
    const LEN: usize = 0;
}
impl<'a, T: ?Sized, D, M> MetadataFor<HCons<&'a T, D>> for HCons<ArgMetadata<T>, M>
    where M: MetadataFor<D>
{
    const LEN: usize = M::LEN;
}

impl<'a> Arguments<'a> {
    fn new<M, D>(meta: &'a M, data: &'a D) -> Self
        where M: MetadataFor<D>
    {
        Self {
            meta: unsafe { &*(meta as *const _ as *const [ArgMetadata<Opaque>; M::LEN]) },
            data: unsafe { &*(data as *const _ as *const [&Opaque; M::LEN]) },
        }
    }
}

eddyb 5 नव॰ 2020

❤2

मेरे पास fmt::Arguments का एक नया कार्यान्वयन है जो 'स्थिर मेटाडेटा' के एक नए रूप का उपयोग करके आकार में केवल दो पॉइंटर्स है जिसमें स्ट्रिंग टुकड़े और कोई स्वरूपण विकल्प (यदि कोई हो) दोनों शामिल हैं। (तो अब यह एक रजिस्टर जोड़ी में फिट बैठता है, जो वास्तव में अच्छा है।) इसके लिए दो के बजाय स्टैक प्रति तर्क पर केवल एक पॉइंटर की आवश्यकता होती है, जैसा कि @eddyb ने स्पष्ट रूप से इस मुद्दे में तीन साल पहले ही सुझाया था। ^^ (इस मुद्दे को पूरी तरह से याद किया जब तक @eddyb ने कल इसे इंगित नहीं किया। ^^')

इसके बजाय इस नए प्रकार का उत्पादन करने के लिए format_args!() को अपडेट करना अभी बाकी है, जो ऑब्जेक्ट पॉइंटर और फ़ंक्शन पॉइंटर (जो वर्तमान में ArgumentV1 ) को फंक्शन पॉइंटर के रूप में विभाजित करने की समस्या में चलेगा। अब इसके बजाय 'स्थिर मेटाडेटा' में जाना चाहिए। इस मुद्दे में सुझाव ऐसा करने का एक अच्छा तरीका लगता है। जल्द ही इसे लागू करने का प्रयास करेंगे। पूर्ण रन के लिए तत्पर हैं :)

m-ou-se 5 नव॰ 2020

❤1

क्या यह पृष्ठ उपयोगी था?

0 / 5 - 0 रेटिंग्स

Rust: format_args! के स्थिर डेटा में टाइप-मिटा fmt fn पॉइंटर्स का अनुमान लगाने के लिए #[repr(C)] HList का उपयोग करें।

सबसे उपयोगी टिप्पणी

सभी 3 टिप्पणियाँ

संबंधित मुद्दों