1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
# functions

snippet     fn
abbr        fn () {}
options     head
    fn ${1:#:func_name}(${2:#:args}) {
        ${0:TARGET}
    }

snippet     fn-
abbr        fn () {}
options     head
    fn ${1:#:func_name}(${2:#:args}) -> ${3:#:()} {
        ${0:TARGET}
    }

snippet     pubfn
abbr        pubfn () {}
options     head
    pub fn ${1:#:func_name}(${2:#:args}) -> ${3:#:()} {
        ${0:TARGET}
    }

snippet     test
options     head
    #[test]
    fn ${1:#:test_function_name}() {
        ${0:TARGET}
    }

snippet     pubnew
abbr        pub fn new() {}
options     head
    pub fn new(${1}) -> ${2:#:Name} {
        ${0:TARGET}
    }

# macros

snippet     macro
    ${1:#:macro_name}!(${2})${3}

snippet     bfl
abbr        bitflags!
    bitflags! {
        ${0:TARGET}
    }

snippet     pln
abbr        println!
    println!(${1:"\{\}"}, ${0:TARGET});

snippet     fm
abbr        format!
    format!("${1:\{\}}", ${0:TARGET});

# attributes

snippet     ec
abbr        extern crate
options     head
    extern crate ${0:TARGET};
    
snippet     ecl
abbr        extern crate log
options     head
    #![feature(phase)]
    #[phase(plugin, link)] extern crate log;

snippet     crate
options     head
    #![crate_name=${1:#:crate_name}]

snippet     derive
options     head
    #[derive(${1:TARGET})]${2}

# statements

snippet     mod
options     head
    mod ${1:#:mod_name} {
        ${0:TARGET}
    }

snippet     let
    let ${1:TARGET} = ${2};${3}

snippet     if
abbr        if {}
    if ${1:#:condition} {
        ${0:TARGET}
    }

snippet else
    else {
        ${0:TARGET}
    }

snippet elseif
    } else if (${1:#:condition}) {
        ${0:TARGET}
    }

snippet     ifelse
abbr        if () {} else {}
    if ${1:#:condition} {
        ${2:TARGET}
    } else {
        ${3}
    }

snippet     forin
abbr        forin  {}
    for ${1} in ${2} {
        ${0:TARGET}
    }

snippet     match
    match ${1:TARGET} {
        ${2:#:pattern} => ${3:#expr},${4}
    }

snippet     mcase
alias       case
    ${1:TARGET} => ${2:#expr},${3}

# data

snippet     struct
options     head
    struct ${1} {
        ${0:TARGET}
    }

snippet     pubstruct
abbr        pub struct
options     head
    pub struct ${1} {
        ${0:TARGET}
    }

snippet     enum
options     head
    enum ${1} {
        ${0:TARGET}
    }

snippet     opt
abbr        Option<A>
    Option<${1:()}>${2}

snippet     res
abbr        Result<A, B>
    Result<${1:#:~str}, ${2:#:()}>${3}