Fixes #22: Fixes style issues

lexer.go

diff --git a/lexer.go b/lexer.go
index b6d28b4..b057da5 100644
--- a/lexer.go
+++ b/lexer.go
@@ -45,7 +45,7 @@
 	tokenEOL
 )
 
-var tokenTypeNames []string = []string{
+var tokenTypeNames = []string{
 	"EOF",
 	"Comment",
 	"Key",
@@ -142,10 +142,10 @@
 	for i := l.start; i < l.pos; {
 		r, width := utf8.DecodeRuneInString(l.input[i:])
 		if r == '\n' {
-			l.line += 1
+			l.line++
 			l.col = 1
 		} else {
-			l.col += 1
+			l.col++
 		}
 		i += width
 	}
@@ -262,10 +262,10 @@
 		case '=':
 			return l.errorf("cannot have multiple equals for the same key")
 		case '[':
-			l.depth += 1
+			l.depth++
 			return lexLeftBracket
 		case ']':
-			l.depth -= 1
+			l.depth--
 			return lexRightBracket
 		case '#':
 			return lexComment
@@ -275,12 +275,11 @@
 			return lexComma
 		case '\n':
 			l.ignore()
-			l.pos += 1
+			l.pos++
 			if l.depth == 0 {
 				return lexVoid
-			} else {
-				return lexRvalue
 			}
+			return lexRvalue
 		}
 
 		if l.follow("true") {
@@ -373,70 +372,70 @@
 
 func lexLeftBracket(l *lexer) stateFn {
 	l.ignore()
-	l.pos += 1
+	l.pos++
 	l.emit(tokenLeftBracket)
 	return lexRvalue
 }
 
 func lexString(l *lexer) stateFn {
-	l.pos += 1
+	l.pos++
 	l.ignore()
-	growing_string := ""
+	growingString := ""
 
 	for {
 		if l.peek() == '"' {
-			l.emitWithValue(tokenString, growing_string)
-			l.pos += 1
+			l.emitWithValue(tokenString, growingString)
+			l.pos++
 			l.ignore()
 			return lexRvalue
 		}
 
 		if l.follow("\\\"") {
-			l.pos += 1
-			growing_string += "\""
+			l.pos++
+			growingString += "\""
 		} else if l.follow("\\n") {
-			l.pos += 1
-			growing_string += "\n"
+			l.pos++
+			growingString += "\n"
 		} else if l.follow("\\b") {
-			l.pos += 1
-			growing_string += "\b"
+			l.pos++
+			growingString += "\b"
 		} else if l.follow("\\f") {
-			l.pos += 1
-			growing_string += "\f"
+			l.pos++
+			growingString += "\f"
 		} else if l.follow("\\/") {
-			l.pos += 1
-			growing_string += "/"
+			l.pos++
+			growingString += "/"
 		} else if l.follow("\\t") {
-			l.pos += 1
-			growing_string += "\t"
+			l.pos++
+			growingString += "\t"
 		} else if l.follow("\\r") {
-			l.pos += 1
-			growing_string += "\r"
+			l.pos++
+			growingString += "\r"
 		} else if l.follow("\\\\") {
-			l.pos += 1
-			growing_string += "\\"
+			l.pos++
+			growingString += "\\"
 		} else if l.follow("\\u") {
 			l.pos += 2
 			code := ""
 			for i := 0; i < 4; i++ {
 				c := l.peek()
-				l.pos += 1
+				l.pos++
 				if !isHexDigit(c) {
 					return l.errorf("unfinished unicode escape")
 				}
 				code = code + string(c)
 			}
-			l.pos -= 1
+			l.pos--
 			intcode, err := strconv.ParseInt(code, 16, 32)
 			if err != nil {
 				return l.errorf("invalid unicode escape: \\u" + code)
 			}
-			growing_string += string(rune(intcode))
+			growingString += string(rune(intcode))
 		} else if l.follow("\\") {
-			l.pos += 1
+			l.pos++
 			return l.errorf("invalid escape sequence: \\" + string(l.peek()))
 		} else {
-			growing_string += string(l.peek())
+			growingString += string(l.peek())
 		}
 
 		if l.next() == eof {
@@ -449,18 +448,17 @@
 
 func lexKeyGroup(l *lexer) stateFn {
 	l.ignore()
-	l.pos += 1
+	l.pos++
 
 	if l.peek() == '[' {
 		// token '[[' signifies an array of anonymous key groups
-		l.pos += 1
+		l.pos++
 		l.emit(tokenDoubleLeftBracket)
 		return lexInsideKeyGroupArray
-	} else {
-		// vanilla key group
-		l.emit(tokenLeftBracket)
-		return lexInsideKeyGroup
 	}
+	// vanilla key group
+	l.emit(tokenLeftBracket)
+	return lexInsideKeyGroup
 }
 
 func lexInsideKeyGroupArray(l *lexer) stateFn {
@@ -470,11 +468,11 @@
 				l.emit(tokenKeyGroupArray)
 			}
 			l.ignore()
-			l.pos += 1
+			l.pos++
 			if l.peek() != ']' {
 				break // error
 			}
-			l.pos += 1
+			l.pos++
 			l.emit(tokenDoubleRightBracket)
 			return lexVoid
 		} else if l.peek() == '[' {
@@ -495,7 +493,7 @@
 				l.emit(tokenKeyGroup)
 			}
 			l.ignore()
-			l.pos += 1
+			l.pos++
 			l.emit(tokenRightBracket)
 			return lexVoid
 		} else if l.peek() == '[' {
@@ -511,7 +509,7 @@
 
 func lexRightBracket(l *lexer) stateFn {
 	l.ignore()
-	l.pos += 1
+	l.pos++
 	l.emit(tokenRightBracket)
 	return lexRvalue
 }
@@ -521,33 +519,33 @@
 	if !l.accept("+") {
 		l.accept("-")
 	}
-	point_seen := false
-	digit_seen := false
+	pointSeen := false
+	digitSeen := false
 	for {
 		next := l.next()
 		if next == '.' {
-			if point_seen {
+			if pointSeen {
 				return l.errorf("cannot have two dots in one float")
 			}
 			if !isDigit(l.peek()) {
 				return l.errorf("float cannot end with a dot")
 			}
-			point_seen = true
+			pointSeen = true
 		} else if isDigit(next) {
-			digit_seen = true
+			digitSeen = true
 		} else {
 			l.backup()
 			break
 		}
-		if point_seen && !digit_seen {
+		if pointSeen && !digitSeen {
 			return l.errorf("cannot start float with a dot")
 		}
 	}
 
-	if !digit_seen {
+	if !digitSeen {
 		return l.errorf("no digit in that number")
 	}
-	if point_seen {
+	if pointSeen {
 		l.emit(tokenFloat)
 	} else {
 		l.emit(tokenInteger)

parser.go

diff --git a/parser.go b/parser.go
index 9945d39..c9f42a3 100644
--- a/parser.go
+++ b/parser.go
@@ -94,7 +94,7 @@
 }
 
 func parseGroupArray(p *parser) parserStateFn {
-	start_token := p.getToken() // discard the [[
+	startToken := p.getToken() // discard the [[
 	key := p.getToken()
 	if key.typ != tokenKeyGroupArray {
 		p.raiseError(key, "unexpected token %s, was expecting a key group array", key)
@@ -103,21 +103,21 @@
 	// get or create group array element at the indicated part in the path
 	keys := strings.Split(key.val, ".")
 	p.tree.createSubTree(keys[:len(keys)-1]) // create parent entries
-	dest_tree := p.tree.GetPath(keys)
+	destTree := p.tree.GetPath(keys)
 	var array []*TomlTree
-	if dest_tree == nil {
+	if destTree == nil {
 		array = make([]*TomlTree, 0)
-	} else if dest_tree.([]*TomlTree) != nil {
-		array = dest_tree.([]*TomlTree)
+	} else if destTree.([]*TomlTree) != nil {
+		array = destTree.([]*TomlTree)
 	} else {
 		p.raiseError(key, "key %s is already assigned and not of type group array", key)
 	}
 	p.currentGroup = keys
 
 	// add a new tree to the end of the group array
-	new_tree := newTomlTree()
-	new_tree.position = start_token.Position
-	array = append(array, new_tree)
+	newTree := newTomlTree()
+	newTree.position = startToken.Position
+	array = append(array, newTree)
 	p.tree.SetPath(p.currentGroup, array)
 
 	// remove all keys that were children of this group array
@@ -144,7 +144,7 @@
 }
 
 func parseGroup(p *parser) parserStateFn {
-	start_token := p.getToken() // discard the [
+	startToken := p.getToken() // discard the [
 	key := p.getToken()
 	if key.typ != tokenKeyGroup {
 		p.raiseError(key, "unexpected token %s, was expecting a key group", key)
@@ -162,8 +162,8 @@
 	}
 	p.assume(tokenRightBracket)
 	p.currentGroup = keys
-	target_tree := p.tree.GetPath(p.currentGroup).(*TomlTree)
-	target_tree.position = start_token.Position
+	targetTree := p.tree.GetPath(p.currentGroup).(*TomlTree)
+	targetTree.position = startToken.Position
 	return parseStart(p)
 }
 
@@ -171,33 +171,33 @@
 	key := p.getToken()
 	p.assume(tokenEqual)
 	value := parseRvalue(p)
-	var group_key []string
+	var groupKey []string
 	if len(p.currentGroup) > 0 {
-		group_key = p.currentGroup
+		groupKey = p.currentGroup
 	} else {
-		group_key = []string{}
+		groupKey = []string{}
 	}
 
 	// find the group to assign, looking out for arrays of groups
-	var target_node *TomlTree
-	switch node := p.tree.GetPath(group_key).(type) {
+	var targetNode *TomlTree
+	switch node := p.tree.GetPath(groupKey).(type) {
 	case []*TomlTree:
-		target_node = node[len(node)-1]
+		targetNode = node[len(node)-1]
 	case *TomlTree:
-		target_node = node
+		targetNode = node
 	default:
 		p.raiseError(key, "Unknown group type for path: %s",
-			strings.Join(group_key, "."))
+			strings.Join(groupKey, "."))
 	}
 
 	// assign value to the found group
-	local_key := []string{key.val}
-	final_key := append(group_key, key.val)
-	if target_node.GetPath(local_key) != nil {
+	localKey := []string{key.val}
+	finalKey := append(groupKey, key.val)
+	if targetNode.GetPath(localKey) != nil {
 		p.raiseError(key, "The following key was defined twice: %s",
-			strings.Join(final_key, "."))
+			strings.Join(finalKey, "."))
 	}
-	target_node.values[key.val] = &tomlValue{value, key.Position}
+	targetNode.values[key.val] = &tomlValue{value, key.Position}
 	return parseStart(p)
 }
 
@@ -244,7 +244,7 @@
 }
 
 func parseArray(p *parser) []interface{} {
-	array := make([]interface{}, 0)
+	var array []interface{}
 	arrayType := reflect.TypeOf(nil)
 	for {
 		follow := p.peek()

position.go

diff --git a/position.go b/position.go
index 266bfcb..fd42a0d 100644
--- a/position.go
+++ b/position.go
@@ -6,7 +6,7 @@
 	"fmt"
 )
 
-// position within a TOML document
+// Position within a TOML document
 type Position struct {
 	Line int // line within the document
 	Col  int // column within the line
@@ -18,6 +18,8 @@
 	return fmt.Sprintf("(%d, %d)", p.Line, p.Col)
 }
 
+// Invalid returns wheter or not the position is valid (i.e. with negative or
+// null values)
 func (p *Position) Invalid() bool {
 	return p.Line <= 0 || p.Col <= 0
 }

toml.go

diff --git a/toml.go b/toml.go
index aa2ab6b..7cd74b0 100644
--- a/toml.go
+++ b/toml.go
@@ -1,4 +1,4 @@
-// TOML markup language parser.
+// Package toml is a TOML markup language parser.
 //
 // This version supports the specification as described in
 // https://github.com/toml-lang/toml/blob/master/versions/toml-v0.2.0.md
@@ -19,8 +19,7 @@
 	position Position
 }
 
-// Definition of a TomlTree.
-// This is the result of the parsing of a TOML file.
+// TomlTree is the result of the parsing of a TOML file.
 type TomlTree struct {
 	values   map[string]interface{}
 	position Position
@@ -41,7 +40,7 @@
 	return t.HasPath(strings.Split(key, "."))
 }
 
-// Returns true if the given path of keys exists, false otherwise.
+// HasPath returns true if the given path of keys exists, false otherwise.
 func (t *TomlTree) HasPath(keys []string) bool {
 	return t.GetPath(keys) != nil
 }
@@ -49,8 +48,8 @@
 // Keys returns the keys of the toplevel tree.
 // Warning: this is a costly operation.
 func (t *TomlTree) Keys() []string {
-	keys := make([]string, 0)
-	for k, _ := range t.values {
+	var keys []string
+	for k := range t.values {
 		keys = append(keys, k)
 	}
 	return keys
@@ -67,15 +66,15 @@
 	return t.GetPath(strings.Split(key, "."))
 }
 
-// Returns the element in the tree indicated by 'keys'.
+// GetPath returns the element in the tree indicated by 'keys'.
 // If keys is of length zero, the current tree is returned.
 func (t *TomlTree) GetPath(keys []string) interface{} {
 	if len(keys) == 0 {
 		return t
 	}
 	subtree := t
-	for _, intermediate_key := range keys[:len(keys)-1] {
-		value, exists := subtree.values[intermediate_key]
+	for _, intermediateKey := range keys[:len(keys)-1] {
+		value, exists := subtree.values[intermediateKey]
 		if !exists {
 			return nil
 		}
@@ -101,6 +100,7 @@
 	}
 }
 
+// GetPosition returns the position of the given key.
 func (t *TomlTree) GetPosition(key string) Position {
 	if key == "" {
 		return Position{0, 0}
@@ -108,15 +108,15 @@
 	return t.GetPositionPath(strings.Split(key, "."))
 }
 
-// Returns the element in the tree indicated by 'keys'.
+// GetPositionPath returns the element in the tree indicated by 'keys'.
 // If keys is of length zero, the current tree is returned.
 func (t *TomlTree) GetPositionPath(keys []string) Position {
 	if len(keys) == 0 {
 		return t.position
 	}
 	subtree := t
-	for _, intermediate_key := range keys[:len(keys)-1] {
-		value, exists := subtree.values[intermediate_key]
+	for _, intermediateKey := range keys[:len(keys)-1] {
+		value, exists := subtree.values[intermediateKey]
 		if !exists {
 			return Position{0, 0}
 		}
@@ -150,7 +150,7 @@
 	}
 }
 
-// Same as Get but with a default value
+// GetDefault works like Get but with a default value
 func (t *TomlTree) GetDefault(key string, def interface{}) interface{} {
 	val := t.Get(key)
 	if val == nil {
@@ -166,16 +166,16 @@
 	t.SetPath(strings.Split(key, "."), value)
 }
 
-// Set an element in the tree.
+// SetPath sets an element in the tree.
 // Keys is an array of path elements (e.g. {"a","b","c"}).
 // Creates all necessary intermediates trees, if needed.
 func (t *TomlTree) SetPath(keys []string, value interface{}) {
 	subtree := t
-	for _, intermediate_key := range keys[:len(keys)-1] {
-		nextTree, exists := subtree.values[intermediate_key]
+	for _, intermediateKey := range keys[:len(keys)-1] {
+		nextTree, exists := subtree.values[intermediateKey]
 		if !exists {
 			nextTree = newTomlTree()
-			subtree.values[intermediate_key] = &nextTree // add new element here
+			subtree.values[intermediateKey] = &nextTree // add new element here
 		}
 		switch node := nextTree.(type) {
 		case *TomlTree:
@@ -184,7 +184,7 @@
 			// go to most recent element
 			if len(node) == 0 {
 				// create element if it does not exist
-				subtree.values[intermediate_key] = append(node, newTomlTree())
+				subtree.values[intermediateKey] = append(node, newTomlTree())
 			}
 			subtree = node[len(node)-1]
 		}
@@ -201,14 +201,14 @@
 // Returns nil on success, error object on failure
 func (t *TomlTree) createSubTree(keys []string) error {
 	subtree := t
-	for _, intermediate_key := range keys {
-		if intermediate_key == "" {
+	for _, intermediateKey := range keys {
+		if intermediateKey == "" {
 			return fmt.Errorf("empty intermediate table")
 		}
-		nextTree, exists := subtree.values[intermediate_key]
+		nextTree, exists := subtree.values[intermediateKey]
 		if !exists {
 			nextTree = newTomlTree()
-			subtree.values[intermediate_key] = nextTree
+			subtree.values[intermediateKey] = nextTree
 		}
 
 		switch node := nextTree.(type) {
@@ -218,7 +218,7 @@
 			subtree = node
 		default:
 			return fmt.Errorf("unknown type for path %s (%s)",
-				strings.Join(keys, "."), intermediate_key)
+				strings.Join(keys, "."), intermediateKey)
 		}
 	}
 	return nil
@@ -228,7 +228,7 @@
 func encodeTomlString(value string) string {
 	result := ""
 	for _, rr := range value {
-		int_rr := uint16(rr)
+		intRr := uint16(rr)
 		switch rr {
 		case '\b':
 			result += "\\b"
@@ -245,8 +245,8 @@
 		case '\\':
 			result += "\\\\"
 		default:
-			if int_rr < 0x001F {
-				result += fmt.Sprintf("\\u%0.4X", int_rr)
+			if intRr < 0x001F {
+				result += fmt.Sprintf("\\u%0.4X", intRr)
 			} else {
 				result += string(rr)
 			}
@@ -269,9 +269,8 @@
 	case bool:
 		if value {
 			return "true"
-		} else {
-			return "false"
 		}
+		return "false"
 	case time.Time:
 		return tab + value.Format(time.RFC3339)
 	case []interface{}:
@@ -291,24 +290,24 @@
 	result := ""
 	for k, v := range t.values {
 		// figure out the keyspace
-		combined_key := k
+		combinedKey := k
 		if keyspace != "" {
-			combined_key = keyspace + "." + combined_key
+			combinedKey = keyspace + "." + combinedKey
 		}
 		// output based on type
 		switch node := v.(type) {
 		case []*TomlTree:
 			for _, item := range node {
 				if len(item.Keys()) > 0 {
-					result += fmt.Sprintf("\n%s[[%s]]\n", indent, combined_key)
+					result += fmt.Sprintf("\n%s[[%s]]\n", indent, combinedKey)
 				}
-				result += item.toToml(indent+"  ", combined_key)
+				result += item.toToml(indent+"  ", combinedKey)
 			}
 		case *TomlTree:
 			if len(node.Keys()) > 0 {
-				result += fmt.Sprintf("\n%s[%s]\n", indent, combined_key)
+				result += fmt.Sprintf("\n%s[%s]\n", indent, combinedKey)
 			}
-			result += node.toToml(indent+"  ", combined_key)
+			result += node.toToml(indent+"  ", combinedKey)
 		case *tomlValue:
 			result += fmt.Sprintf("%s%s = %s\n", indent, k, toTomlValue(node.value, 0))
 		default:
@@ -318,13 +317,13 @@
 	return result
 }
 
-// Generates a human-readable representation of the current tree.
+// ToString generates a human-readable representation of the current tree.
 // Output spans multiple lines, and is suitable for ingest by a TOML parser
 func (t *TomlTree) ToString() string {
 	return t.toToml("", "")
 }
 
-// Create a TomlTree from a string.
+// Load creates a TomlTree from a string.
 func Load(content string) (tree *TomlTree, err error) {
 	defer func() {
 		if r := recover(); r != nil {
@@ -339,7 +338,7 @@
 	return
 }
 
-// Create a TomlTree from a file.
+// LoadFile creates a TomlTree from a file.
 func LoadFile(path string) (tree *TomlTree, err error) {
 	buff, ferr := ioutil.ReadFile(path)
 	if ferr != nil {