# shorthand variable declaration
snippet v
	${1} := ${2}
# variable initialization
snippet vr
	var ${1:t} ${0:string}
# variable declaration
snippet var
	var ${1} ${2} = ${3}
# variables declaration
snippet vars
	var (
		${1} ${2} = ${3}
	)
# append
snippet ap
	append(${1:slice}, ${0:value})
# bool
snippet bl
	bool
# byte
snippet bt
	byte
# break
snippet br
	break
# channel
snippet ch
	chan ${0:int}
# case
snippet cs
	case ${1:value}:
		${0:${VISUAL}}
# const
snippet c
	const ${1:NAME} = ${0:0}
# constants with iota
snippet co
	const (
		${1:NAME1} = iota
		${0:NAME2}
	)
# continue
snippet cn
	continue
# defer
snippet df
	defer ${0:func}()
# defer recover
snippet dfr
	defer func() {
		if err := recover(); err != nil {
			${0:${VISUAL}}
		}
	}()
# int
snippet i
	int
# import
snippet im
	import (
		"${1:package}"
	)
# interface
snippet in
	interface{}
# full interface snippet
snippet inf
	interface ${1:name} {
		${2:/* methods */}
	}
# if condition
snippet if
	if ${1:/* condition */} {
		${2:${VISUAL}}
	}
snippet ife
	if ${1:/* condition */} {
		${2:${VISUAL}}
	} else {
		${0}
	}
# else snippet
snippet el
	else {
		${0:${VISUAL}}
	}
# error snippet
snippet ir
	if err != nil {
		return err
	}
	${0}
# false
snippet f
	false
# fallthrough
snippet ft
	fallthrough
# float
snippet fl
	float32
# float32
snippet f3
	float32
# float64
snippet f6
	float64
# for int loop
snippet for
	for ${1}{
		${0:${VISUAL}}
	}
# for int loop
snippet fori
	for ${2:i} := 0; $2 < ${1:count}; $2${3:++} {
		${0:${VISUAL}}
	}
# for range loop
snippet forr
	for ${1:e} := range ${2:collection} {
		${0:${VISUAL}}
	}
# function simple
snippet fun
	func ${1:funcName}(${2}) ${3:error} {
		${4}
	}
	${0}
# function on receiver
snippet fum
	func (${1:receiver} ${2:type}) ${3:funcName}(${4}) ${5:error} {
		${6}
	}
	${0}
# http handler function on reciever
snippet fumh
	func (${1:receiver} ${2:type}) ${3:funcName}(${4:w} http.ResponseWriter, ${5:r} *http.Request) {
		${0:${VISUAL}}
	}
# log printf
snippet lf
	log.Printf("%${1:s}", ${2:var})
# log printf
snippet lp
	log.Println("${1}")
# make
snippet mk
	make(${1:[]string}, ${0:0})
# map
snippet mp
	map[${1:string}]${0:int}
# main()
snippet main
	func main() {
		${1}
	}
	${0}
# new
snippet nw
	new(${0:type})
# package
snippet pa
	package ${1:main}
# panic
snippet pn
	panic("${0:msg}")
# print
snippet pr
	fmt.Printf("%${1:s}\n", ${2:var})
# println
snippet pl
	fmt.Println("${1:s}")
# range
snippet rn
	range ${0}
# return
snippet rt
	return ${0}
# result
snippet rs
	result
# select
snippet sl
	select {
	case ${1:v1} := <-${2:chan1}
		${3}
	default:
		${0}
	}
# string
snippet sr
	string
# struct
snippet st
	struct ${1:name} {
		${2:/* data */}
	}
	${0}
# switch
snippet sw
	switch ${1:var} {
	case ${2:value1}:
		${3}
	case ${4:value2}:
		${5}
	default:
		${0}
	}
snippet sp
	fmt.Sprintf("%${1:s}", ${2:var})
# true
snippet t
	true
# goroutine named function
snippet g
	go ${1:funcName}(${0})
# goroutine anonymous function
snippet ga
	go func(${1} ${2:type}) {
		${3:/* code */}
	}(${0})
snippet test test function
	func Test${1:name}(t *testing.T) {
		${0:${VISUAL}}
	}
snippet bench benchmark function
	func Benchmark${1:name}(b *testing.B) {
		for i := 0; i < b.N; i++ {
			${2}
		}
	}
	${0}
# composite literals
snippet cl
	type ${1:name} struct {
		${2:attrName} ${3:attrType}
	}
# if key in a map
snippet om
	if ${1:value}, ok := ${2:map}[${3:key}]; ok == true {
		${4:/* code */}
	}

# Grouped globals with anonymous struct
snippet gg
	var ${1:var} = struct{
		${2:name} ${3:type}
	}{
		$2: ${4:value},
	}

# Marshalable json alias
snippet ja
	type ${1:parentType}Alias $1

	func (p *$1) MarshalJSON() ([]byte, error) {
		return json.Marshal(&struct{ *$1Alias }{(*$1Alias)(p)})
	}
