Useful snippets for Rust in VSCode.

rust.json

{
    // Place your snippets for rust here. Each snippet is defined under a snippet name and has a prefix, body and 
    // description. The prefix is what is used to trigger the snippet and the body will be expanded and inserted. Possible variables are:
    // $1, $2 for tab stops, $0 for the final cursor position, and ${1:label}, ${2:another} for placeholders. Placeholders with the 
    // same ids are connected.
    // Example:
    // "Print to console": {
    // 	"prefix": "log",
    // 	"body": [
    // 		"console.log('$1');",
    // 		"$2"
    // 	],
    // 	"description": "Log output to console"
    // }

    "let variable declaration with type inference": {
        "prefix": "let",
        "body": "let $1 = $2;$0"
    },

    "let variable declaration with explicit type annotation": {
        "prefix": "lett",
        "body": "let $1: $2 = $3;$0"
    },

    "let mut variable declaration with type inference": {
        "prefix": "letm",
        "body": "let mut $1 = $2;$0"
    },

    "let mut variable declaration with explicit type annotation": {
        "prefix": "lettm",
        "body": "let mut $1: $2 = $3;$0"
    },

    "Struct definition": {
        "prefix": "st",
        "body": [
            "struct $1 {",
            "    $2",
            "}$0"
        ]
    },

    "Struct with new constructor": {
        "prefix": "stn",
        "body": [
            "${1:pub }struct $2 {",
            "    $3",
            "}",
            "",
            "impl $1 {",
            "    pub fn new($4) -> Self {",
            "        $1 {",
            "            $5",
            "        }",
            "    }",
            "}$0"
        ]
    },

    "Public function": {
        "prefix": "pfn",
        "body": "${1:pub }fn $2($3)${4: -> $5} {$6}$0"
    },

    "Function definition": {
        "prefix": "fn",
        "body": "fn $1($2)${3: -> $4} {$5}$0"
    },

    "if / else": {
        "prefix": "ife",
        "body": [
            "if $1 {",
            "    $2",
            "} else {",
            "    $3",
            "}$4"
        ]
    },

    "Unwrap Option with if let": {
        "prefix": "iflet",
        "body": [
            "if let Some($1) = $2 {",
            "    $3",
            "}$4"
        ]
    },

    "Struct/Trait implementaion": {
        "prefix": "impl",
        "body": [
            "impl ${1:Type/Trait} ${2:for ${3:Type}} {",
            "    $4",
            "}$0"
        ]
    },

    "Struct implementaion": {
        "prefix": "impls",
        "body": [
            "impl ${1:Type} {",
            "    $2",
            "}$0"
        ]
    },

    "Trait implementaion": {
        "prefix": "implt",
        "body": [
            "impl ${1:Trait} for ${2:Type} {",
            "    $3",
            "}$0"
        ]
    },

    "static item declaration": {
        "prefix": "stat",
        "body": "static $1: $2 = $3;$0"
    },

    "Test module": {
        "prefix": "testmod",
        "body": [
            "#[cfg(test)]",
            "mod tests {",
            "    use super::*$1;",
            "",
            "    ${0:test}",
            "}"
        ]
    },

    "Unit test function": {
        "prefix": "test",
        "body": [
            "#[test]",
            "fn ${1:it_works}($2)$3 {",
            "    $0",
            "}"
        ]
    },

    "Insert for loop": {
        "prefix": "for",
        "body": [
            "for $1 in $2 {",
            "    $3",
            "}$0"
        ]
    },

    "#[derive(..)]": {
        "prefix": "der",
        "body": "#[derive(${1:Debug})]$0"
    },

    "assert!": {
        "prefix": "as",
        "body": "assert!(${1:predicate});$0"
    },

    "assert_eq!": {
        "prefix": "ase",
        "body": "assert_eq!(${1:expected}, ${2:actual});$0"
    },

    "AsRef trait implementation": {
        "prefix": "asref",
        "body": [
            "impl AsRef<${1:Ref}> for ${2:Type} {",
            "    fn as_ref(&self) -> &$1 {",
            "        &self.${3:field}",
            "    }",
            "}"
        ]
    },

    "AsMut trait implementation": {
        "prefix": "asmut",
        "body": [
            "impl AsMut<${1:Ref}> for ${2:Type} {",
            "    fn as_mut(&mut self) -> &mut $1 {",
            "        &mut self.${3:field}",
            "    }",
            "}"
        ]
    },

    "match pattern": {
        "prefix": "mat",
        "body": [
            "match $1 {",
            "    $2 => $3,$0",
            "}"
        ]
    },

    "Case clause of pattern match": {
        "prefix": "case",
        "body": "$1 => $2,$0"
    },

    "dbg! debugging macro": {
        "prefix": "d",
        "body": "dbg!($1)$0"
    },

    "dbg! debugging macro statement": {
        "prefix": "d;",
        "body": "dbg!(&$1)$0"
    },

    "enum definition": {
        "prefix": "enum",
        "body": [
            "enum ${1:Name} {",
            "    $2,",
            "}"
        ]
    },

    "pub enum definition": {
        "prefix": "penum",
        "body": [
            "${1:pub }enum ${2:Name} {",
            "    $3,",
            "}"
        ]
    },

    "else if": {
        "prefix": "eli",
        "body": [
            "else if $1 {",
            "    $2",
            "}$3"
        ]
    },

    "else": {
        "prefix": "else",
        "body": [
            "else {",
            "    $1",
            "}$2"
        ]
    },

    "extern crate": {
        "prefix": "ec",
        "body": "extern crate ${1:name};$2"
    },

    "Insert print!": {
        "prefix": "pri",
        "body": "print!(\"$1\"${2:, $3});$4"
    },

    "Insert println!": {
        "prefix": "pln",
        "body": "println!(\"$1\"${2:, $3});$4"
    },

    "print! with format param": {
        "prefix": "pri,",
        "body": "print!(\"{$1}\", $2);$3"
    },

    "println! with format param": {
        "prefix": "pln,",
        "body": "println!(\"{$1}\", $2);$3"
    },

    "Insert eprint!": {
        "prefix": "epri",
        "body": "eprint!(\"$1\"${2:, $3});$4"
    },

    "Insert eprintln!": {
        "prefix": "epln",
        "body": "eprintln!(\"$1\"${2:, $3});$4"
    },

    "eprint! with format param": {
        "prefix": "epri,",
        "body": "eprint!(\"{$1}\", $2);$3"
    },

    "eprintln! with format param": {
        "prefix": "epln,",
        "body": "eprintln!(\"{$1}\", $2);$3"
    },

    "allow lint attribute": {
        "prefix": "allow",
        "body": "#[allow(${1:unused_variables)]$2"
    },

    "Main function": {
        "prefix": "main",
        "body": [
            "${1:pub }fn main() {",
            "    $2",
            "}"
        ]
    },

    "feature attribute": {
        "prefix": "feat",
        "body": "#![feature(${1:plugin})]$2"
    },

    "#[..]": {
        "prefix": "attr",
        "body": "#[${1:inline}]$2"
    },

    "Declare (Sender, Receiver) pair of asynchronous channel()": {
        "prefix": "chan",
        "body": "let (${1:tx}, ${2:rx}): (Sender<${3:i32}>, Receiver<${4:i32}>) = $5;$6"
    },

    "Define crate meta attributes": {
        "prefix": "crate",
        "body": [
            "// Crate name",
            "#![crate_name = \"${1:crate_name}\"]",
            "// Additional metadata attributes",
            "#![desc = \"${2:Descrption.}\"]",
            "#![license = \"${3:BSD}\"]",
            "#![comment = \"${4:Comment.}\"]",
            "// Specify the output type",
            "#![crate_type = \"${5:lib}\"]",
            "$6"
        ]
    },

    "Trait definition": {
        "prefix": "trait",
        "body": [
            "trait ${1:Name} {",
            "    $2",
            "}"
        ]
    },

    "spawn a thread": {
        "prefix": "spawn",
        "body": [
            "thread::spawn(move |$1| {",
            "    $2",
            "});"
        ]
    },

    "spawn a scoped thread": {
        "prefix": "scoped",
        "body": [
            "thread::scoped(move |$1| {",
            "    $2",
            "});"
        ]
    },

    "macro_rules!": {
        "prefix": "macro",
        "body": [
            "macro_rules! ${1:name} {",
            "    (${2:matcher}) => (",
            "        $3",
            "    ),$4",
            "}"
        ]
    },

    "Box::new()": {
        "prefix": "box",
        "body": "Box::new($1)"
    },

    "Rc::new()": {
        "prefix": "rc",
        "body": "Rc::new($1)"
    },

    "Bench function": {
        "prefix": "bench",
        "body": [
            "#[bench]",
            "fn ${1:bench_function_name}(b: &mut test::Bencher) {",
            "    b.iter(|$2| {",
            "        $3",
            "    })",
            "}"
        ]
    },

    "#[cfg(...)]": {
        "prefix": "cfg",
        "body": "#[cfg($1)]"
    },

    "cfg attribute": {
        "prefix": "cfg",
        "body": "#[cfg(target_os = \"${1:linux}\")]"
    },

    "Drop trait implementation (destructor)": {
        "prefix": "drop",
        "body": [
            "impl Drop for ${1:Name} {",
            "    fn drop(&mut self) {",
            "        $2",
            "    }",
            "}"
        ]
    },

    "Module definition": {
        "prefix": "mod",
        "body": [
            "mod ${1:Main} {",
            "    $2",
            "}"
        ]
    },

    "Struct field definition": {
        "prefix": "fd",
        "body": "${1:name}: ${2:Type},"
    },

    "Constructor function": {
        "prefix": "new",
        "body": [
            "${1:pub }fn new($2) -> ${3:Self} {",
            "    $3 {",
            "        $4",
            "    }",
            "}"
        ]
    },

    "Result": {
        "prefix": "res",
        "body": "Result<${1:T}, ${2:E}>"
    },

    "Insert format macro": {
        "prefix": "fmt",
        "body": "format!(\"{$1}\", $2);"
    },

    "FIXME comment": {
        "prefix": "fixme",
        "body": "// FIXME: $1"
    },

    "TODO comment": {
        "prefix": "todo",
        "body": "// TODO: $1"
    },

    "#[ignore]": {
        "prefix": "ig",
        "body": "#[${1:ignore}]"
    },

    "while loop": {
        "prefix": "wh",
        "body": [
            "while ${1:condition} {",
            "    $2",
            "}"
        ]
    },

    ".iter()": {
        "prefix": ".it",
        "body": ".iter()"
    },

    "unimplemented!()": {
        "prefix": "unim",
        "body": "unimplemented!()"
    },

    "loop": {
        "prefix": "loop",
        "body": [
            "loop {",
            "    $1",
            "}"
        ]
    },

    "Option<T>": {
        "prefix": "opt",
        "body": "Option<${1:T}>"
    },

    "Insert panic! macro": {
        "prefix": "pan",
        "body": "panic!(\"{$1}\");"
    },

    "static string declaration": {
        "prefix": "ss",
        "body": "static $1: &'static str = \"$2\";"
    },

    "Type alias": {
        "prefix": "ty",
        "body": "type ${1:NewName} = $2;"
    },

    "Insert todo! macro": {
        "prefix": "td",
        "body": "todo!();"
    }
}