go fmt ./...

parse/lex/lex.go

@@ -13,6 +13,7 @@ import (
 )
 
 type TokenType int
+
 const (
 	BareString TokenType = iota
 	QuotedString
@@ -58,9 +59,9 @@ var (
 
 // Lexer reads through an io.Reader and emits Tokens from it.
 type Lexer struct {
-	r *bufio.Reader
+	r      *bufio.Reader
 	outbuf *bytes.Buffer
-	ch chan *Token
+	ch     chan *Token
 }
 
 // NewLexer constructs a new Lexer struct and returns it. r is internally
@@ -75,8 +76,8 @@ func NewLexer(r io.Reader) *Lexer {
 	}
 
 	l := Lexer{
-		r:  br,
+		r:      br,
-		ch: make(chan *Token),
+		ch:     make(chan *Token),
 		outbuf: bytes.NewBuffer(make([]byte, 0, 1024)),
 	}
 
@@ -110,7 +111,7 @@ func (l *Lexer) emit(t TokenType) {
 	str := l.outbuf.String()
 	l.ch <- &Token{
 		Type: t,
-		Val: str,
+		Val:  str,
 	}
 	l.outbuf.Reset()
 }
@@ -199,7 +200,7 @@ func lexQuotedString(l *Lexer) lexerFunc {
 	l.outbuf.WriteRune(r)
 	buf := l.outbuf.Bytes()
 
-	if r == '"' && buf[len(buf) - 2] != '\\' {
+	if r == '"' && buf[len(buf)-2] != '\\' {
 		l.emit(QuotedString)
 		return lexWhitespace
 	}

parse/lex/lex_test.go

@@ -7,34 +7,34 @@ import (
 
 func TestLexer(t *T) {
 	m := map[string][]Token{
-		"": {{eof, ""}},
+		"":    {{eof, ""}},
 		" \t": {{eof, ""}},
 		"a b c": {{BareString, "a"},
-				  {BareString, "b"},
+			{BareString, "b"},
-				  {BareString, "c"},
+			{BareString, "c"},
-				  {eof, ""}},
+			{eof, ""}},
 		"\"foo\" bar": {{QuotedString, "\"foo\""},
-						{BareString, "bar"},
+			{BareString, "bar"},
-						{eof, ""}},
+			{eof, ""}},
 		"\"foo\nbar\" baz": {{QuotedString, "\"foo\nbar\""},
-							 {BareString, "baz"},
+			{BareString, "baz"},
-							 {eof, ""}},
+			{eof, ""}},
 		"( foo bar ) baz": {{Open, "("},
-						    {BareString, "foo"},
+			{BareString, "foo"},
-						    {BareString, "bar"},
+			{BareString, "bar"},
-						    {Close, ")"},
+			{Close, ")"},
-						    {BareString, "baz"},
+			{BareString, "baz"},
-						    {eof, ""}},
+			{eof, ""}},
-		"((foo-bar))":     {{Open, "("},
+		"((foo-bar))": {{Open, "("},
-							{Open, "("},
+			{Open, "("},
-							{BareString, "foo-bar"},
+			{BareString, "foo-bar"},
-							{Close, ")"},
+			{Close, ")"},
-							{Close, ")"},
+			{Close, ")"},
-						    {eof, ""}},
+			{eof, ""}},
-		"(\"foo\nbar\")":  {{Open, "("},
+		"(\"foo\nbar\")": {{Open, "("},
-							{QuotedString, "\"foo\nbar\""},
+			{QuotedString, "\"foo\nbar\""},
-							{Close, ")"},
+			{Close, ")"},
-							{eof, ""}},
+			{eof, ""}},
 	}
 
 	for input, output := range m {

parse/parse.go

@@ -5,8 +5,8 @@ package parse
 
 import (
 	"bytes"
-	"io"
 	"fmt"
+	"io"
 	"strconv"
 	"unsafe"
 
@@ -45,7 +45,7 @@ func parseBareString(tok *lex.Token) types.Elem {
 	}
 
 	if tok.Val[0] != ':' {
-		return types.GoType{":"+tok.Val}
+		return types.GoType{":" + tok.Val}
 	}
 
 	return types.GoType{tok.Val}
@@ -100,10 +100,10 @@ func (p *Parser) parseToken(tok *lex.Token) (types.Elem, error) {
 		if tok.Val == "(" {
 			return seq.NewList(series...), nil
 		} else if tok.Val == "{" {
-			if len(series) % 2 != 0 {
+			if len(series)%2 != 0 {
 				return nil, fmt.Errorf("hash must have even number of elements")
 			}
-			kvs := make([]*seq.KV, 0, len(series) / 2)
+			kvs := make([]*seq.KV, 0, len(series)/2)
 			for i := 0; i < len(series); i += 2 {
 				kv := seq.KV{series[i], series[i+1]}
 				kvs = append(kvs, &kv)
@@ -118,7 +118,6 @@ func (p *Parser) parseToken(tok *lex.Token) (types.Elem, error) {
 	}
 }
 
-
 func (p *Parser) readUntil(closer string) ([]types.Elem, error) {
 	series := make([]types.Elem, 0, 4)
 	for {

parse/parse_test.go

@@ -11,13 +11,13 @@ import (
 
 func TestParse(t *T) {
 	m := map[string]types.Elem{
-		"1": types.GoType{int(1)},
+		"1":  types.GoType{int(1)},
 		"-1": types.GoType{int(-1)},
 		"+1": types.GoType{int(1)},
 
-		"1.5": types.GoType{float32(1.5)},
+		"1.5":   types.GoType{float32(1.5)},
-		"-1.5": types.GoType{float32(-1.5)},
+		"-1.5":  types.GoType{float32(-1.5)},
-		"+1.5": types.GoType{float32(1.5)},
+		"+1.5":  types.GoType{float32(1.5)},
 		"1.5e1": types.GoType{float32(15)},
 
 		"foo": types.GoType{":foo"},