Rust
रस्ट स्टाइल गाइड

परिचय

टिप्पणियों

cargo install clippy
cargo install rustfmt

cargo clippy
cargo fmt

श्वेत रिक्ति

रेखा लंबाई

// Lines should never exceed 100 characters. 
// Instead, just wrap on to the next line.
let bad_example = "So this sort of code should never really happen, because it's really hard to fit on the screen!";

खरोज

// You should always use 4 spaces for indentation. 
// Tabs are discouraged - if you can, set your editor to convert
// a tab into 4 spaces.
let x = vec![1, 3, 5, 6, 7, 9];
for item in x {
    if x / 2 == 3 {
        println!("{}", x);
    }
}

अनुगामी व्हॉट्सएप

फ़ाइलों या लाइनों के अंत में ट्रेलिंग व्हाट्सएप को हटा दिया जाना चाहिए।

बाइनरी ऑपरेटर्स

// For clarity, always add a space when using binary operators, e.g.
// +, -, =, *
let bad=3+4;
let good = 3 + 4;

यह भी विशेषताओं में लागू होता है, उदाहरण के लिए:

// Good:
#[deprecated = "Don't use my class - use Bar instead!"]

// Bad:
#[deprecated="This is broken"]

अर्धविराम

// There is no space between the end of a statement
// and a semicolon.

let bad = Some("don't do this!") ;
let good: Option<&str> = None;

स्ट्रक्चर फील्ड्स संरेखित करना

// Struct fields should **not** be aligned using spaces, like this:
pub struct Wrong {
    pub x  : i32,
    pub foo: i64 
}

// Instead, just leave 1 space after the colon and write the type, like this:
pub struct Right {
    pub x: i32,
    pub foo: i64
}

समारोह हस्ताक्षर

// Long function signatures should be wrapped and aligned so that
// the starting parameter of each line is aligned
fn foo(example_item: Bar, another_long_example: Baz, 
       yet_another_parameter: Quux) 
       -> ReallyLongReturnItem {
    // Be careful to indent the inside block correctly!
}

ब्रेसिज़

// The starting brace should always be on the same line as its parent.
// The ending brace should be on its own line.
fn bad()
{
    println!("This is incorrect.");
}

struct Good {
    example: i32
}

struct AlsoBad {
    example: i32 }

क्रेट्स बनाना

प्रस्तावना और पुन: निर्यात

// To reduce the amount of imports that users need, you should
// re-export important structs and traits.
pub use foo::Client;
pub use bar::Server;

कभी-कभी, क्रेट एक महत्वपूर्ण मॉडल को समाहित करने के लिए एक prelude मॉड्यूल का उपयोग करते हैं, जैसे std::io::prelude । आमतौर पर, इनका use std::io::prelude::*;

आयात

आपको अपने आयात और घोषणाओं को क्रमबद्ध करना चाहिए:

• extern crate घोषणाएँ
• आयात का use
  • अन्य टोकरे से बाहरी आयात पहले आना चाहिए
• पुन: निर्यात ( pub use )

नामकरण

structs

// Structs use UpperCamelCase.
pub struct Snafucator {
    
}

mod snafucators {
    // Try to avoid 'stuttering' by repeating 
    // the module name in the struct name.

    // Bad:
    pub struct OrderedSnafucator {
    
    }
      
    // Good:
    pub struct Ordered {
        
    }
}

लक्षण

// Traits use the same naming principles as 
// structs (UpperCamelCase).
trait Read {
    fn read_to_snafucator(&self) -> Result<(), Error>;
}

बक्से और मॉड्यूल

// Modules and crates should both use snake_case.
// Crates should try to use single words if possible.
extern crate foo;
mod bar_baz {
    mod quux {

    }
}

स्थैतिक चर और स्थिरांक

// Statics and constants use SCREAMING_SNAKE_CASE.
const NAME: &'static str = "SCREAMING_SNAKE_CASE";

enums

// Enum types and their variants **both** use UpperCamelCase.
pub enum Option<T> {
   Some(T),
   None
}

कार्य और तरीके

// Functions and methods use snake_case
fn snake_cased_function() {

}

चर बाँधना

// Regular variables also use snake_case
let foo_bar = "snafu";

जीवन काल

// Lifetimes should consist of a single lower case letter. By 
// convention, you should start at 'a, then 'b, etc.

// Good:
struct Foobar<'a> {
    x: &'a str
}

// Bad:
struct Bazquux<'stringlife> {
    my_str: &'stringlife str
}

परिवर्णी शब्द

परिवर्तनीय नाम जिनमें समरूपता शामिल है, जैसे कि TCP को स्टाइल किया जाना चाहिए:

• UpperCamelCase नामों के लिए, पहले अक्षर को कैपिटल किया जाना चाहिए (जैसे TcpClient )
• snake_case नामों के लिए, कोई कैपिटलाइज़ेशन नहीं होना चाहिए (जैसे tcp_client )
• SCREAMING_SNAKE_CASE नामों के लिए, संक्षिप्त नाम पूरी तरह से पूंजीकृत होना चाहिए (जैसे TCP_CLIENT )

प्रकार

एनोटेशन टाइप करें

// There should be one space after the colon of the type
// annotation. This rule applies in variable declarations,
// struct fields, functions and methods.

// GOOD:
let mut buffer: String = String::new();
// BAD:
let mut buffer:String = String::new();
let mut buffer : String = String::new();

संदर्भ

// The ampersand (&) of a reference should be 'touching'
// the type it refers to.

// GOOD:
let x: &str = "Hello, world.";
// BAD:
fn fooify(x: & str) {
    println!("{}", x);
}

// Mutable references should be formatted like so:
fn bar(buf: &mut String) {

}