forked from gko/scala-vim-snippets
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
- Loading branch information
0 parents
commit c1ae2cb
Showing
3 changed files
with
344 additions
and
0 deletions.
There are no files selected for viewing
Binary file not shown.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,4 @@ | ||
You might want to install snipmate plugin for vim in order to use this one. | ||
All snippets are well documented. | ||
|
||
If you have any questions mail me to gor.konstantin[at]gmail.com |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,340 @@ | ||
################################################################ | ||
# © Copyright 2011 Konstantin Gorodinskiy. All Rights Reserved.# | ||
# Do What The Fuck You Want To Public License, Version 2. # | ||
# See http://sam.zoy.org/wtfpl/COPYING for more details. # | ||
################################################################ | ||
# Scala lang | ||
|
||
#comment | ||
snippet /* | ||
/* | ||
* ${1:comment} | ||
*/ | ||
#scaladoc | ||
snippet /** | ||
/** | ||
* ${1:description} | ||
*/ | ||
#if | ||
snippet if | ||
if(${1:obj}) { | ||
${2:/* code */} | ||
} | ||
#if not | ||
snippet ifn | ||
if(!${1:obj}) { | ||
${2:/* code */} | ||
} | ||
#if-else | ||
snippet ifel | ||
if(${1:obj}) { | ||
${2:/* code */} | ||
} else { | ||
${3:/* code */} | ||
} | ||
#if-else-if | ||
snippet ifelif | ||
if(${1:obj}) { | ||
${2:/* code */} | ||
} else if(${3:obj}) { | ||
${4:/* code */} | ||
} | ||
#while loop | ||
snippet while | ||
while (${1:obj}) { | ||
${2:/* code */} | ||
} | ||
#for loop(classic) | ||
snippet for | ||
for (${1:item} <- ${2:obj}) { | ||
${3:/* code */} | ||
} | ||
#for loop(indexed) | ||
snippet fori | ||
for (${1:i} <- ${2:0} to ${3:obj}.length) { | ||
${4:/* code */} | ||
} | ||
#exceptions | ||
snippet try | ||
try { | ||
${1:/* code */} | ||
} catch { | ||
case e: FileNotFoundException => ${2:/* code */} | ||
case e: IOException => ${3:/* code */} | ||
} finally { | ||
${4:/* code */} | ||
} | ||
#match | ||
snippet match | ||
${1: obj} match { | ||
case ${2:e} => ${3:/* code */} | ||
case _ => ${4:/* code */} | ||
} | ||
#case | ||
snippet case | ||
case ${1:value} => ${2:/* code */} | ||
############################ | ||
# functions | ||
# | ||
#arg | ||
snippet arg | ||
${1:a}: ${2:T}${3:, arg} | ||
#args | ||
snippet args | ||
${1:args}: ${2:T}* | ||
#scope(for general purpose) | ||
snippet { | ||
{ | ||
${1:/* code */} | ||
} | ||
#def | ||
snippet def | ||
def ${1:name}(${2:arg}) = ${3:{} | ||
#private def | ||
snippet prdef | ||
private def ${1:name}(${2:arg}) = ${3:{} | ||
#override def | ||
snippet ovdef | ||
override def ${1:name}(${2:arg}) = ${3:{} | ||
#first class function(see scalabook p 188) | ||
snippet fcf | ||
(${1:a}: ${2:T}) => $1 ${3:/* code */} | ||
#recursion | ||
snippet rec | ||
def ${1:name}(${2:arg}) = | ||
if($2) $2 | ||
else $1($2) | ||
#curried function | ||
snippet crdef | ||
def ${1:name}(${2:arg})(${3:arg}) = ${4:{} | ||
#main method | ||
#check validity of T | ||
snippet main | ||
def main(args: Array[String]):${1:T} = ${2:{} | ||
############################ | ||
# basic types(general purpose) | ||
# you might want to use basic types snippets | ||
|
||
#1 | ||
snippet T Double | ||
dbl | ||
#2 | ||
snippet T Int | ||
int | ||
#3 | ||
snippet T Long | ||
lng | ||
#4 | ||
snippet T Char | ||
chr | ||
#5 | ||
snippet T String | ||
str | ||
#6 | ||
snippet T Array | ||
arr | ||
#7 | ||
snippet T Buffer | ||
buf | ||
#8 | ||
snippet T List | ||
list | ||
#9 | ||
snippet T Tuple | ||
tpl | ||
#10 | ||
snippet T Set | ||
set | ||
#11 | ||
snippet T Map | ||
map | ||
#12 | ||
snippet T HashSet | ||
hset | ||
#13 | ||
snippet T HashMap | ||
hmap | ||
#14 | ||
snippet T Boolean | ||
bool | ||
#end | ||
|
||
#named snippets for types | ||
snippet bool | ||
Boolean | ||
snippet anyr | ||
AnyRef | ||
snippet dbl | ||
Double | ||
snippet int | ||
Int | ||
snippet str | ||
String | ||
snippet chr | ||
Char | ||
snippet lng | ||
Long | ||
snippet arr | ||
Array${1:[T]}${2:()} | ||
snippet buf | ||
Buffer${1:[T]}${2:()} | ||
snippet list | ||
List${1:[T]}${2:()} | ||
snippet tpl | ||
Tuple${1:2}[${2:T},${3:T}] | ||
snippet set | ||
Set${1:[T]}${2:()} | ||
snippet hset | ||
HashSet${1:[T]}${2:()} | ||
snippet mhset | ||
mutable.HashSet${1:[T]}${2:()} | ||
#for maps | ||
snippet keyval | ||
${1:key}->${2:val}${3:, keyval} | ||
snippet map | ||
Map[${1:T},${2:T}]${3:(keyval)} | ||
snippet hmap | ||
HashMap[${1:T},${2:T}]${3:(keyval)} | ||
snippet mmap | ||
mutable.Map[${1:T},${2:T}]${3:(keyval)} | ||
snippet mhmap | ||
mutable.HashMap[${1:T},${2:T}]${3:(keyval)} | ||
#TODO add TreeMap and TreeSet | ||
#asInstanceOf[] | ||
snippet as | ||
${1:name}.asInstanceOf[${2:T}] | ||
#isInstanceOf[] | ||
${1:name}.isInstanceOf[${2:T}] | ||
#end | ||
#collections methods | ||
|
||
#scope() with one arg | ||
snippet (a | ||
(${1:a} => ${2:/* code */}) | ||
#scope() with two args | ||
snippet {( | ||
{(${1:a},${2:b}) => | ||
${3:/* code */} | ||
} | ||
#filter | ||
snippet filter | ||
${1:name}.filter (a | ||
#map function | ||
snippet mapf | ||
${1:name}.map (a | ||
#flatmap | ||
snippet flatmap | ||
${1:name}.flatMap${2:[T]}(a | ||
#fold left | ||
snippet fldl | ||
${1:name}.foldLeft(${2:first}) {( | ||
#fold right | ||
snippet fldr | ||
${1:name}.foldRight(${2:first}) {( | ||
#fold left operator(if u wanna reduce readability of ur code) | ||
#use wildcard symbols | ||
snippet fldlop | ||
(${1:first}/:${2:name})(${3:/* code */}) | ||
#fold right operator | ||
snippet fldrop | ||
(${1:first}:\${2:name})(${3:/* code */}) | ||
#reduce left | ||
snippet redl | ||
${1:name}.reduceLeft[${2:T}] {( | ||
#reduce right | ||
snippet redr | ||
${1:name}.reduceRight[${2:T}] {( | ||
#zipWithIndex(safe way). | ||
#see http://daily-scala.blogspot.com/2010/05/zipwithindex.html | ||
snippet zipwi | ||
${1:name}.view.zipWithIndex | ||
#split | ||
snippet spl | ||
${1:name}.split("${2:,}") | ||
#end | ||
snippet val | ||
val ${1:name}${2:: T} = ${3:value} | ||
snippet var | ||
var ${1:name}${2:: T} = ${3:value} | ||
############################ | ||
# classes | ||
# | ||
#extends | ||
snippet extends | ||
extends ${1:what} | ||
#with | ||
snippet with | ||
with ${1:what}${2: with} | ||
#auxiliary constructor(a. this) | ||
snippet athis | ||
def this(arg) = this(arg) | ||
#abstract class | ||
snippet abstract | ||
abstract class ${1:name}${2:(arg)}${3: extends }${4: with} { | ||
${5:override def toString = "$1"} | ||
${6:/* code */} | ||
} | ||
#class | ||
snippet class | ||
class ${1:name}${2:(arg)}${3: extends }${4: with} { | ||
${5:override def toString = "$1"} | ||
${6:/* code */} | ||
} | ||
#object | ||
snippet object | ||
object ${1:name}${2:(arg)}${3: extends }${4: with} ${5:{} | ||
#trait | ||
snippet object | ||
trait ${1:name}${2: extends }${3: with} ${4:{} | ||
#class with trait Ordered(page 265) | ||
snippet ordered | ||
class ${1:name}${2:(arg)} extends Ordered[$1] ${3: with} { | ||
${4:override def toString = "$1"} | ||
def compare(that: $1) = ${5:this - that} | ||
${6:/* code */} | ||
} | ||
#case class | ||
snippet casecl | ||
case class ${1:name}${2:(arg)}${3: extends }${4: with} ${5:{} | ||
############################ | ||
# testing | ||
# | ||
#scalatest imports | ||
snippet scalatest | ||
${1:import org.scalatest.Suite} | ||
${2:import org.scalatest.FunSuite} | ||
#assert | ||
snippet assert | ||
assert(${1:a}==${2:b}) | ||
#ensuring(p 296) | ||
snippet ensuring | ||
ifel ensuring(${1:a}==${2:b}) | ||
#expect | ||
snippet expect | ||
expect(${1:what}) { | ||
#intercept | ||
snippet intercept | ||
intercept[${1:IllegalArgumentException}] { | ||
#test | ||
snippet test | ||
test("${1:description}") { | ||
#suite | ||
snippet suite | ||
class ${1:name} extends Suite { | ||
def test() { | ||
} | ||
#funsuite | ||
snippet fsuite | ||
class ${1:name} extends FunSuite { | ||
test("${2:description}") { | ||
} | ||
############################ | ||
# Lift | ||
# | ||
#lift imports | ||
snippet liftimports | ||
import _root_.net.liftweb.http._ | ||
import S._ | ||
import _root_.net.liftweb.util._ | ||
import Helpers._ | ||
import _root_.scala.xml._ |