Rust: पता लगाएं कि "अप्रतिबंधित प्रकार पैरामीटर" एक एफएन कॉल को स्पष्ट रूप से प्रदान किया जा सकता है

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

https://github.com/rust-lang/rust/pull/39361 पर निर्माण, हम इस पर विचार करना चाहेंगे कि उपयोगकर्ताओं को fn कॉल में स्पष्ट प्रकार पैरामीटर कब जोड़ना चाहिए। मैं इस तरह एक उदाहरण की कल्पना कर रहा हूँ:

fn foo<T>() { }

fn main() {
    foo();
}

यह सुझाव देना अच्छा होगा कि उपयोगकर्ता कुछ स्पष्ट T के लिए foo::<T> लिखें। इसके लिए थोड़ा विचार करने की आवश्यकता होगी:

स्थानीय चर की व्याख्या करने के लिए हम इसे प्राथमिकता में कब सुझाना चाहते हैं? मैं स्थानीय चर पर एनोटेशन संलग्न करना पसंद करूंगा, लेकिन हो सकता है कि स्थानीय चर का प्रकार कुछ जटिल चीज न हो, जो इसके अंदर गहराई से असंबद्ध प्रकार का उल्लेख करता है, जबकि फ़ंक्शन को एनोटेट करने से हम सीधे असंबद्ध प्रकार निर्दिष्ट कर सकते हैं .

एक उदाहरण:

fn foo<T>() -> Option<T> { }

fn main() {
    let x = foo();
}

क्या हमें x: Option<T> या foo::<T> लेबल करने का सुझाव देना चाहिए? यह मामला सीमा रेखा है, लेकिन यदि आप Option को कुछ और जटिल प्रकार से बदलते हैं तो यह शेष राशि को और झुका देता है।

हम क्या करते हैं जब fn कई प्रकार के होते हैं, और हम उन्हें आंशिक रूप से जानते हैं? जब हमारे पास कुछ जानकारी होती है, लेकिन सभी नहीं, तो क्या करना चाहिए, इससे पहले हमने समस्या को दरकिनार कर दिया। लेकिन ऐसा लगता है कि यहां यह अधिक महत्वपूर्ण हो सकता है। एक उदाहरण:

fn foo<T, U>() -> T { }

fn main() {
    let x: i32 = foo();
}

यहां हम T जानते हैं, लेकिन U नहीं। क्या हमें foo::<_, XXX> का सुझाव देना चाहिए? हम उपयोगकर्ता को यह बताने के लिए XXX कैसे वाक्यांश देते हैं कि यह वह चीज है जिसे उन्हें प्रदान करने की आवश्यकता है?

cc @cengizIO -- पीछा करने में दिलचस्प है?

cc @estebank @jonathandturner -- वाक्यांश कैसे करें, इस पर विचार?

A-diagnostics C-enhancement E-needs-mentor T-compiler WG-compiler-errors

स्रोत

nikomatsakis

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

मौजूदा उत्पादन:

error[E0282]: type annotations needed
  --> $DIR/xxx.rs:xx:xx
   |
14 |     let x: i32 = foo();
   |                  ^^^ cannot infer type for `U`
   |
   = note: type annotations or generic parameter binding required

कुछ विकल्प:

error[E0282]: type annotations needed
  --> $DIR/xxx.rs:xx:xx
   |
14 |     let x: i32 = foo();
   |                  ^^^ cannot infer type for `U`
   |
   = note: type annotations or generic parameter binding required
   = note: generic parameter `U` needs to be specified for foo::<T, U>()

error[E0282]: type annotations needed
  --> $DIR/xxx.rs:xx:xx
   |
14 |     let x: i32 = foo();
   |                  ^^^ cannot infer type for `U`
   |                  |
   |                  you can specify the generic parameter here using `foo::<_, U>()`
   |
   = note: generic parameter `U` needs to be specified for `fn foo::<T, U>() -> T`

error[E0282]: type annotations needed
  --> $DIR/xxx.rs:xx:xx
   |
14 |     let x: i32 = foo();
   |                  ^^^ cannot infer type for `U` in `fn foo<T, U>() -> T`
   |                  |
   |                  specify `U` using `foo::<_, U>()`
   |

estebank 21 फ़र॰ 2017

👍2

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

हैलो @nikomatsakis

मैं इस पर काम करूंगा।

एक बार फिर धन्यवाद!

cengizIO 21 फ़र॰ 2017

मौजूदा उत्पादन:

error[E0282]: type annotations needed
  --> $DIR/xxx.rs:xx:xx
   |
14 |     let x: i32 = foo();
   |                  ^^^ cannot infer type for `U`
   |
   = note: type annotations or generic parameter binding required

कुछ विकल्प:

error[E0282]: type annotations needed
  --> $DIR/xxx.rs:xx:xx
   |
14 |     let x: i32 = foo();
   |                  ^^^ cannot infer type for `U`
   |
   = note: type annotations or generic parameter binding required
   = note: generic parameter `U` needs to be specified for foo::<T, U>()

error[E0282]: type annotations needed
  --> $DIR/xxx.rs:xx:xx
   |
14 |     let x: i32 = foo();
   |                  ^^^ cannot infer type for `U`
   |                  |
   |                  you can specify the generic parameter here using `foo::<_, U>()`
   |
   = note: generic parameter `U` needs to be specified for `fn foo::<T, U>() -> T`

error[E0282]: type annotations needed
  --> $DIR/xxx.rs:xx:xx
   |
14 |     let x: i32 = foo();
   |                  ^^^ cannot infer type for `U` in `fn foo<T, U>() -> T`
   |                  |
   |                  specify `U` using `foo::<_, U>()`
   |

estebank 21 फ़र॰ 2017

👍2

यह नोट विशेष रूप से मेरी आँखों को चमका देता है:

   = note: type annotations or generic parameter binding required

आइए निश्चित रूप से इसे हटा दें। :)

nikomatsakis 22 फ़र॰ 2017

😄1

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

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

Rust: पता लगाएं कि "अप्रतिबंधित प्रकार पैरामीटर" एक एफएन कॉल को स्पष्ट रूप से प्रदान किया जा सकता है

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

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

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