diff --git a/README.md b/README.md
index 978fe78..417ffd9 100644
--- a/README.md
+++ b/README.md
@@ -75,8 +75,8 @@
 package main
 
 import (
-        "fmt"
-        docopt "github.com/kbatten/docopt.go"
+    "fmt"
+    docopt "github.com/kbatten/docopt.go"
 )
 
 func main() {
diff --git a/docopt.go b/docopt.go
index 2932a38..2a32110 100644
--- a/docopt.go
+++ b/docopt.go
@@ -1,10 +1,12 @@
-/*
-Based of off docopt.py: https://github.com/docopt/docopt
+// Licensed under terms of MIT license (see LICENSE-MIT)
+// Copyright (c) 2013 Keith Batten, kbatten@gmail.com
 
-Licensed under terms of MIT license (see LICENSE-MIT)
-Copyright (c) 2013 Keith Batten, kbatten@gmail.com
-*/
-
+// Package docopt creates beautiful command-line interfaces based on the
+// command help message
+//
+// Port of docopt for python
+// https://github.com/docopt/docopt
+// http://docopt.org
 package docopt
 
 import (
@@ -16,8 +18,87 @@
 	"unicode"
 )
 
+// Parse `argv` based on command-line interface described in `doc`.
+//
+// docopt creates your command-line interface based on its
+// description that you pass as `doc`. Such description can contain
+// --options, <positional-argument>, commands, which could be
+// [optional], (required), (mutually | exclusive) or repeated...
+//
+// Parameters:
+//  doc : string
+//   Description of your command-line interface.
+//
+//  argv : list of string or nil
+//   Argument vector to be parsed. os.Args[1:] is used if nil.
+//
+//  help : bool (default: true)
+//   Set to false to disable automatic help on -h or --help options.
+//
+//  version : string
+//   If set to something besides an empty string, the string will be printed
+//   if --version is in argv
+//
+//  optionsFirst : bool (default: false)
+//   Set to true to require options precede positional arguments,
+//   i.e. to forbid options and positional arguments intermix.
+//
+// Returns:
+//  args : map[string]interface{}
+//   A map, where keys are names of command-line elements
+//   such as e.g. "--verbose" and "<path>", and values are the
+//   parsed values of those elements.
+//
+//  err : error, *docopt.LanguageError, *docopt.UserError
+//
+//  os.Exit on user error or help
+//
+// Example:
+//  package main
+//
+//  import (
+//      "fmt"
+//      docopt "github.com/kbatten/docopt.go"
+//  )
+//
+//  func main() {
+//      doc := `
+//  Usage:
+//    my_program tcp <host> <port> [--timeout=<seconds>]
+//    my_program serial <port> [--baud=<n>] [--timeout=<seconds>]
+//    my_program (-h | --help | --version)
+//
+//  Options:
+//    -h, --help Show this screen and exit.
+//    --baud=<n> Baudrate [default: 9600]
+//  `
+//      argv := []string{"tcp", "127.0.0.1", "80", "--timeout", "30"}
+//      fmt.Println(docopt.Parse(doc, argv, true, "", false))
+//  }
+//
+// Example output:
+//  {"--baud": "9600",
+//   "--help": false,
+//   "--timeout": "30",
+//   "--version": false,
+//   "<host>": "127.0.0.1",
+//   "<port>": "8"',
+//   "serial": false,
+//   "tcp": true}
+func Parse(doc string, argv []string, help bool, version string, optionsFirst bool) (map[string]interface{}, error) {
+	args, output, err := parse(doc, argv, help, version, optionsFirst)
+	if _, ok := err.(*UserError); ok {
+		fmt.Println(output)
+		os.Exit(1)
+	} else if len(output) > 0 && err == nil {
+		fmt.Println(output)
+		os.Exit(0)
+	}
+	return args, err
+}
+
 // parse and return a map of args, output and all errors
-func Parse(doc string, argv []string, help bool, version string, optionsFirst bool) (args map[string]interface{}, output string, err error) {
+func parse(doc string, argv []string, help bool, version string, optionsFirst bool) (args map[string]interface{}, output string, err error) {
 	if argv == nil && len(os.Args) > 1 {
 		argv = os.Args[1:]
 	}
@@ -41,19 +122,19 @@
 		return
 	}
 
-	patternArgv, err := parseArgv(newTokenList(argv, ERROR_USER), &options, optionsFirst)
+	patternArgv, err := parseArgv(newTokenList(argv, errorUser), &options, optionsFirst)
 	if err != nil {
 		output = handleError(err, usage)
 		return
 	}
-	patFlat, err := pat.flat(PATTERN_OPTION)
+	patFlat, err := pat.flat(patternOption)
 	if err != nil {
 		output = handleError(err, usage)
 		return
 	}
 	patternOptions := patFlat.unique()
 
-	patFlat, err = pat.flat(PATTERN_OPTIONSSHORTCUT)
+	patFlat, err = pat.flat(patternOptionSSHORTCUT)
 	if err != nil {
 		output = handleError(err, usage)
 		return
@@ -74,7 +155,7 @@
 	}
 	matched, left, collected := pat.match(&patternArgv, nil)
 	if matched && len(*left) == 0 {
-		patFlat, err = pat.flat(PATTERN_DEFAULT)
+		patFlat, err = pat.flat(patternDefault)
 		if err != nil {
 			output = handleError(err, usage)
 			return
@@ -88,43 +169,6 @@
 	return
 }
 
-// parse just doc and return a map of args
-// handle all printing and non-fatal errors
-// panic on fatal errors
-// exit on user error or help
-func ParseEasy(doc string) map[string]interface{} {
-	return ParseLoud(doc, nil, true, "", false)
-}
-
-// parse and return a map of args and fatal errors
-// handle printing of help
-// exit on user error or help
-func ParseQuiet(doc string, argv []string, help bool, version string, optionsFirst bool) (map[string]interface{}, error) {
-	args, output, err := Parse(doc, argv, help, version, optionsFirst)
-	if _, ok := err.(*UserError); ok {
-		fmt.Println(output)
-		os.Exit(1)
-	} else if len(output) > 0 && err == nil {
-		fmt.Println(output)
-		os.Exit(0)
-	}
-	return args, err
-}
-
-// parse and return a map of args
-// handle all printing and non-fatal errors
-// panic on fatal errors
-// exit on user error or help
-func ParseLoud(doc string, argv []string, help bool, version string, optionsFirst bool) map[string]interface{} {
-	args, err := ParseQuiet(doc, argv, help, version, optionsFirst)
-	if _, ok := err.(*LanguageError); ok {
-		panic(fmt.Sprintf("(language) %s", err))
-	} else if err != nil {
-		panic(fmt.Sprintf("(internal) %s", err))
-	}
-	return args
-}
-
 func handleError(err error, usage string) string {
 	if _, ok := err.(*UserError); ok {
 		return strings.TrimSpace(fmt.Sprintf("%s\n%s", err, usage))
@@ -353,7 +397,7 @@
 			similar = append(similar, o)
 		}
 	}
-	if tokens.err == ERROR_USER && len(similar) == 0 { // if no exact match
+	if tokens.err == errorUser && len(similar) == 0 { // if no exact match
 		similar = patternList{}
 		for _, o := range *options {
 			if strings.HasPrefix(o.long, long) {
@@ -374,7 +418,7 @@
 		}
 		opt = newOption("", long, argcount, false)
 		*options = append(*options, opt)
-		if tokens.err == ERROR_USER {
+		if tokens.err == errorUser {
 			var val interface{}
 			if argcount > 0 {
 				val = value
@@ -400,7 +444,7 @@
 				}
 			}
 		}
-		if tokens.err == ERROR_USER {
+		if tokens.err == errorUser {
 			if value != nil {
 				opt.value = value
 			} else {
@@ -435,7 +479,7 @@
 		} else if len(similar) < 1 {
 			opt = newOption(short, "", 0, false)
 			*options = append(*options, opt)
-			if tokens.err == ERROR_USER {
+			if tokens.err == errorUser {
 				opt = newOption(short, "", 0, true)
 			}
 		} else { // why copying is necessary here?
@@ -452,7 +496,7 @@
 					left = ""
 				}
 			}
-			if tokens.err == ERROR_USER {
+			if tokens.err == errorUser {
 				if value != nil {
 					opt.value = value
 				} else {
@@ -467,16 +511,16 @@
 
 func newTokenList(source []string, err errorType) *tokenList {
 	errorFunc := newError
-	if err == ERROR_USER {
+	if err == errorUser {
 		errorFunc = newUserError
-	} else if err == ERROR_LANGUAGE {
+	} else if err == errorLanguage {
 		errorFunc = newLanguageError
 	}
 	return &tokenList{source, errorFunc, err}
 }
 
 func tokenListFromString(source string) *tokenList {
-	return newTokenList(strings.Fields(source), ERROR_USER)
+	return newTokenList(strings.Fields(source), errorUser)
 }
 
 func tokenListFromPattern(source string) *tokenList {
@@ -495,7 +539,7 @@
 			result = append(result, match[i][1])
 		}
 	}
-	return newTokenList(result, ERROR_LANGUAGE)
+	return newTokenList(result, errorLanguage)
 }
 
 func formalUsage(section string) string {
@@ -536,16 +580,16 @@
 type errorType int
 
 const (
-	ERROR_USER errorType = iota
-	ERROR_LANGUAGE
+	errorUser errorType = iota
+	errorLanguage
 )
 
 func (self errorType) String() string {
 	switch self {
-	case ERROR_USER:
-		return "userError"
-	case ERROR_LANGUAGE:
-		return "languageError"
+	case errorUser:
+		return "errorUser"
+	case errorLanguage:
+		return "errorLanguage"
 	}
 	return ""
 }
@@ -651,54 +695,54 @@
 
 const (
 	// leaf
-	PATTERN_ARGUMENT patternType = 1 << iota
-	PATTERN_COMMAND
-	PATTERN_OPTION
+	patternArgument patternType = 1 << iota
+	patternCommand
+	patternOption
 
 	// branch
-	PATTERN_REQUIRED
-	PATTERN_OPTIONAL
-	PATTERN_OPTIONSSHORTCUT // Marker/placeholder for [options] shortcut.
-	PATTERN_ONEORMORE
-	PATTERN_EITHER
+	patternRequired
+	patternOptionAL
+	patternOptionSSHORTCUT // Marker/placeholder for [options] shortcut.
+	patternOneOrMore
+	patternEither
 
-	PATTERN_LEAF = PATTERN_ARGUMENT +
-		PATTERN_COMMAND +
-		PATTERN_OPTION
-	PATTERN_BRANCH = PATTERN_REQUIRED +
-		PATTERN_OPTIONAL +
-		PATTERN_OPTIONSSHORTCUT +
-		PATTERN_ONEORMORE +
-		PATTERN_EITHER
-	PATTERN_ALL     = PATTERN_LEAF + PATTERN_BRANCH
-	PATTERN_DEFAULT = 0
+	patternLeaf = patternArgument +
+		patternCommand +
+		patternOption
+	patternBranch = patternRequired +
+		patternOptionAL +
+		patternOptionSSHORTCUT +
+		patternOneOrMore +
+		patternEither
+	patternAll     = patternLeaf + patternBranch
+	patternDefault = 0
 )
 
 func (self patternType) String() string {
 	switch self {
-	case PATTERN_ARGUMENT:
+	case patternArgument:
 		return "argument"
-	case PATTERN_COMMAND:
+	case patternCommand:
 		return "command"
-	case PATTERN_OPTION:
+	case patternOption:
 		return "option"
-	case PATTERN_REQUIRED:
+	case patternRequired:
 		return "required"
-	case PATTERN_OPTIONAL:
+	case patternOptionAL:
 		return "optional"
-	case PATTERN_OPTIONSSHORTCUT:
+	case patternOptionSSHORTCUT:
 		return "optionsshortcut"
-	case PATTERN_ONEORMORE:
+	case patternOneOrMore:
 		return "oneormore"
-	case PATTERN_EITHER:
+	case patternEither:
 		return "either"
-	case PATTERN_LEAF:
+	case patternLeaf:
 		return "leaf"
-	case PATTERN_BRANCH:
+	case patternBranch:
 		return "branch"
-	case PATTERN_ALL:
+	case patternAll:
 		return "all"
-	case PATTERN_DEFAULT:
+	case patternDefault:
 		return "default"
 	}
 	return ""
@@ -728,24 +772,24 @@
 }
 
 func newRequired(pl ...*pattern) *pattern {
-	return newBranchPattern(PATTERN_REQUIRED, pl...)
+	return newBranchPattern(patternRequired, pl...)
 }
 
 func newEither(pl ...*pattern) *pattern {
-	return newBranchPattern(PATTERN_EITHER, pl...)
+	return newBranchPattern(patternEither, pl...)
 }
 
 func newOneOrMore(pl ...*pattern) *pattern {
-	return newBranchPattern(PATTERN_ONEORMORE, pl...)
+	return newBranchPattern(patternOneOrMore, pl...)
 }
 
 func newOptional(pl ...*pattern) *pattern {
-	return newBranchPattern(PATTERN_OPTIONAL, pl...)
+	return newBranchPattern(patternOptionAL, pl...)
 }
 
 func newOptionsShortcut() *pattern {
 	var p pattern
-	p.t = PATTERN_OPTIONSSHORTCUT
+	p.t = patternOptionSSHORTCUT
 	return &p
 }
 
@@ -760,13 +804,13 @@
 
 func newArgument(name string, value interface{}) *pattern {
 	// default: value=nil
-	return newLeafPattern(PATTERN_ARGUMENT, name, value)
+	return newLeafPattern(patternArgument, name, value)
 }
 
 func newCommand(name string, value interface{}) *pattern {
 	// default: value=false
 	var p pattern
-	p.t = PATTERN_COMMAND
+	p.t = patternCommand
 	p.name = name
 	p.value = value
 	return &p
@@ -775,7 +819,7 @@
 func newOption(short, long string, argcount int, value interface{}) *pattern {
 	// default: "", "", 0, false
 	var p pattern
-	p.t = PATTERN_OPTION
+	p.t = patternOption
 	p.short = short
 	p.long = long
 	if long != "" {
@@ -793,9 +837,9 @@
 }
 
 func (self *pattern) flat(types patternType) (patternList, error) {
-	if self.t&PATTERN_LEAF != 0 {
-		if types == PATTERN_DEFAULT {
-			types = PATTERN_ALL
+	if self.t&patternLeaf != 0 {
+		if types == patternDefault {
+			types = patternAll
 		}
 		if self.t&types != 0 {
 			return patternList{self}, nil
@@ -803,7 +847,7 @@
 		return patternList{}, nil
 	}
 
-	if self.t&PATTERN_BRANCH != 0 {
+	if self.t&patternBranch != 0 {
 		if self.t&types != 0 {
 			return patternList{self}, nil
 		}
@@ -831,18 +875,18 @@
 
 func (self *pattern) fixIdentities(uniq patternList) error {
 	// Make pattern-tree tips point to same object if they are equal.
-	if self.t&PATTERN_BRANCH == 0 {
+	if self.t&patternBranch == 0 {
 		return nil
 	}
 	if uniq == nil {
-		selfFlat, err := self.flat(PATTERN_DEFAULT)
+		selfFlat, err := self.flat(patternDefault)
 		if err != nil {
 			return err
 		}
 		uniq = selfFlat.unique()
 	}
 	for i, child := range self.children {
-		if child.t&PATTERN_BRANCH == 0 {
+		if child.t&patternBranch == 0 {
 			ind, err := uniq.index(child)
 			if err != nil {
 				return err
@@ -873,7 +917,7 @@
 			}
 		}
 		for _, e := range casMultiple {
-			if e.t == PATTERN_ARGUMENT || e.t == PATTERN_OPTION && e.argcount > 0 {
+			if e.t == patternArgument || e.t == patternOption && e.argcount > 0 {
 				switch e.value.(type) {
 				case string:
 					e.value = strings.Fields(e.value.(string))
@@ -882,7 +926,7 @@
 					e.value = []string{}
 				}
 			}
-			if e.t == PATTERN_COMMAND || e.t == PATTERN_OPTION && e.argcount == 0 {
+			if e.t == patternCommand || e.t == patternOption && e.argcount == 0 {
 				e.value = 0
 			}
 		}
@@ -893,7 +937,7 @@
 	if collected == nil {
 		collected = &patternList{}
 	}
-	if self.t&PATTERN_REQUIRED != 0 {
+	if self.t&patternRequired != 0 {
 		l := left
 		c := collected
 		for _, p := range self.children {
@@ -904,12 +948,12 @@
 			}
 		}
 		return true, l, c
-	} else if self.t&PATTERN_OPTIONAL != 0 || self.t&PATTERN_OPTIONSSHORTCUT != 0 {
+	} else if self.t&patternOptionAL != 0 || self.t&patternOptionSSHORTCUT != 0 {
 		for _, p := range self.children {
 			_, left, collected = p.match(left, collected)
 		}
 		return true, left, collected
-	} else if self.t&PATTERN_ONEORMORE != 0 {
+	} else if self.t&patternOneOrMore != 0 {
 		if len(self.children) != 1 {
 			panic("OneOrMore.match(): assert len(self.children) == 1")
 		}
@@ -933,7 +977,7 @@
 			return true, l, c
 		}
 		return false, left, collected
-	} else if self.t&PATTERN_EITHER != 0 {
+	} else if self.t&patternEither != 0 {
 		type outcomeStruct struct {
 			matched   bool
 			left      *patternList
@@ -959,7 +1003,7 @@
 			return outcomes[minIndex].matched, outcomes[minIndex].left, outcomes[minIndex].collected
 		}
 		return false, left, collected
-	} else if self.t&PATTERN_LEAF != 0 {
+	} else if self.t&patternLeaf != 0 {
 		pos, match := self.singleMatch(left)
 		var increment interface{}
 		if match == nil {
@@ -1013,16 +1057,16 @@
 }
 
 func (self *pattern) singleMatch(left *patternList) (int, *pattern) {
-	if self.t&PATTERN_ARGUMENT != 0 {
+	if self.t&patternArgument != 0 {
 		for n, p := range *left {
-			if p.t&PATTERN_ARGUMENT != 0 {
+			if p.t&patternArgument != 0 {
 				return n, newArgument(self.name, p.value)
 			}
 		}
 		return -1, nil
-	} else if self.t&PATTERN_COMMAND != 0 {
+	} else if self.t&patternCommand != 0 {
 		for n, p := range *left {
-			if p.t&PATTERN_ARGUMENT != 0 {
+			if p.t&patternArgument != 0 {
 				if p.value == self.name {
 					return n, newCommand(self.name, true)
 				} else {
@@ -1031,7 +1075,7 @@
 			}
 		}
 		return -1, nil
-	} else if self.t&PATTERN_OPTION != 0 {
+	} else if self.t&patternOption != 0 {
 		for n, p := range *left {
 			if self.name == p.name {
 				return n, p
@@ -1044,11 +1088,11 @@
 }
 
 func (self *pattern) String() string {
-	if self.t&PATTERN_OPTION != 0 {
+	if self.t&patternOption != 0 {
 		return fmt.Sprintf("%s(%s, %s, %d, %+v)", self.t, self.short, self.long, self.argcount, self.value)
-	} else if self.t&PATTERN_LEAF != 0 {
+	} else if self.t&patternLeaf != 0 {
 		return fmt.Sprintf("%s(%s, %+v)", self.t, self.name, self.value)
-	} else if self.t&PATTERN_BRANCH != 0 {
+	} else if self.t&patternBranch != 0 {
 		result := ""
 		for i, child := range self.children {
 			if i > 0 {
@@ -1071,11 +1115,11 @@
 	*/
 	result := []patternList{}
 	groups := []patternList{patternList{self}}
-	parents := PATTERN_REQUIRED +
-		PATTERN_OPTIONAL +
-		PATTERN_OPTIONSSHORTCUT +
-		PATTERN_EITHER +
-		PATTERN_ONEORMORE
+	parents := patternRequired +
+		patternOptionAL +
+		patternOptionSSHORTCUT +
+		patternEither +
+		patternOneOrMore
 	for len(groups) > 0 {
 		children := groups[0]
 		groups = groups[1:]
@@ -1088,14 +1132,14 @@
 		}
 		if child != nil {
 			children.remove(child)
-			if child.t&PATTERN_EITHER != 0 {
+			if child.t&patternEither != 0 {
 				for _, c := range child.children {
 					r := patternList{}
 					r = append(r, c)
 					r = append(r, children...)
 					groups = append(groups, r)
 				}
-			} else if child.t&PATTERN_ONEORMORE != 0 {
+			} else if child.t&patternOneOrMore != 0 {
 				r := patternList{}
 				r = append(r, child.children.double()...)
 				r = append(r, children...)
@@ -1206,13 +1250,13 @@
 // returns true if all cased characters in the string are uppercase
 // and there are there is at least one cased charcter
 func isStringUppercase(s string) bool {
-    if strings.ToUpper(s) != s {
-        return false
-    }
-    for _, c := range []rune(s) {
-        if unicode.IsUpper(c) {
-            return true
-        }
-    }
-    return false
+	if strings.ToUpper(s) != s {
+		return false
+	}
+	for _, c := range []rune(s) {
+		if unicode.IsUpper(c) {
+			return true
+		}
+	}
+	return false
 }
diff --git a/docopt_test.go b/docopt_test.go
index 848ee02..4cdc6ac 100644
--- a/docopt_test.go
+++ b/docopt_test.go
@@ -28,7 +28,7 @@
 	p, err := newRequired(
 		newOneOrMore(newArgument("N", nil)),
 		newOption("-a", "", 0, false),
-		newArgument("M", nil)).flat(PATTERN_DEFAULT)
+		newArgument("M", nil)).flat(patternDefault)
 	if reflect.DeepEqual(p, q) != true {
 		t.Error(err)
 	}
@@ -36,7 +36,7 @@
 	q = patternList{newOptionsShortcut()}
 	p, err = newRequired(
 		newOptional(newOptionsShortcut()),
-		newOptional(newOption("-a", "", 0, false))).flat(PATTERN_OPTIONSSHORTCUT)
+		newOptional(newOption("-a", "", 0, false))).flat(patternOptionSSHORTCUT)
 	if reflect.DeepEqual(p, q) != true {
 		t.Error(err)
 	}
@@ -119,25 +119,25 @@
 }
 
 func TestCommands(t *testing.T) {
-	if v, _, err := Parse("Usage: prog add", []string{"add"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"add": true}) != true {
+	if v, _, err := parse("Usage: prog add", []string{"add"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"add": true}) != true {
 		t.Error(err)
 	}
-	if v, _, err := Parse("Usage: prog [add]", []string{}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"add": false}) != true {
+	if v, _, err := parse("Usage: prog [add]", []string{}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"add": false}) != true {
 		t.Error(err)
 	}
-	if v, _, err := Parse("Usage: prog [add]", []string{"add"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"add": true}) != true {
+	if v, _, err := parse("Usage: prog [add]", []string{"add"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"add": true}) != true {
 		t.Error(err)
 	}
-	if v, _, err := Parse("Usage: prog (add|rm)", []string{"add"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"add": true, "rm": false}) != true {
+	if v, _, err := parse("Usage: prog (add|rm)", []string{"add"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"add": true, "rm": false}) != true {
 		t.Error(err)
 	}
-	if v, _, err := Parse("Usage: prog (add|rm)", []string{"rm"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"add": false, "rm": true}) != true {
+	if v, _, err := parse("Usage: prog (add|rm)", []string{"rm"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"add": false, "rm": true}) != true {
 		t.Error(err)
 	}
-	if v, _, err := Parse("Usage: prog a b", []string{"a", "b"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"a": true, "b": true}) != true {
+	if v, _, err := parse("Usage: prog a b", []string{"a", "b"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"a": true, "b": true}) != true {
 		t.Error(err)
 	}
-	_, _, err := Parse("Usage: prog a b", []string{"b", "a"}, true, "", false)
+	_, _, err := parse("Usage: prog a b", []string{"b", "a"}, true, "", false)
 	if _, ok := err.(*UserError); !ok {
 		t.Error(err)
 	}
@@ -1060,29 +1060,29 @@
 }
 
 func TestLongOptionsErrorHandling(t *testing.T) {
-	_, _, err := Parse("Usage: prog", []string{"--non-existent"}, true, "", false)
+	_, _, err := parse("Usage: prog", []string{"--non-existent"}, true, "", false)
 	if _, ok := err.(*UserError); !ok {
 		t.Error(fmt.Sprintf("(%s) %s", reflect.TypeOf(err), err))
 	}
-	_, _, err = Parse("Usage: prog [--version --verbose]\nOptions: --version\n --verbose",
+	_, _, err = parse("Usage: prog [--version --verbose]\nOptions: --version\n --verbose",
 		[]string{"--ver"}, true, "", false)
 	if _, ok := err.(*UserError); !ok {
 		t.Error(err)
 	}
-	_, _, err = Parse("Usage: prog --long\nOptions: --long ARG", []string{}, true, "", false)
+	_, _, err = parse("Usage: prog --long\nOptions: --long ARG", []string{}, true, "", false)
 	if _, ok := err.(*LanguageError); !ok {
 		t.Error(err)
 	}
-	_, _, err = Parse("Usage: prog --long ARG\nOptions: --long ARG",
+	_, _, err = parse("Usage: prog --long ARG\nOptions: --long ARG",
 		[]string{"--long"}, true, "", false)
 	if _, ok := err.(*UserError); !ok {
 		t.Error(fmt.Sprintf("(%s) %s", reflect.TypeOf(err), err))
 	}
-	_, _, err = Parse("Usage: prog --long=ARG\nOptions: --long", []string{}, true, "", false)
+	_, _, err = parse("Usage: prog --long=ARG\nOptions: --long", []string{}, true, "", false)
 	if _, ok := err.(*LanguageError); !ok {
 		t.Error(err)
 	}
-	_, _, err = Parse("Usage: prog --long\nOptions: --long",
+	_, _, err = parse("Usage: prog --long\nOptions: --long",
 		[]string{}, true, "--long=ARG", false)
 	if _, ok := err.(*UserError); !ok {
 		t.Error(err)
@@ -1090,43 +1090,43 @@
 }
 
 func TestShortOptionsErrorHandling(t *testing.T) {
-	_, _, err := Parse("Usage: prog -x\nOptions: -x  this\n -x  that", []string{}, true, "", false)
+	_, _, err := parse("Usage: prog -x\nOptions: -x  this\n -x  that", []string{}, true, "", false)
 	if _, ok := err.(*LanguageError); !ok {
 		t.Error(fmt.Sprintf("(%s) %s", reflect.TypeOf(err), err))
 	}
-	_, _, err = Parse("Usage: prog", []string{"-x"}, true, "", false)
+	_, _, err = parse("Usage: prog", []string{"-x"}, true, "", false)
 	if _, ok := err.(*UserError); !ok {
 		t.Error(err)
 	}
-	_, _, err = Parse("Usage: prog -o\nOptions: -o ARG", []string{}, true, "", false)
+	_, _, err = parse("Usage: prog -o\nOptions: -o ARG", []string{}, true, "", false)
 	if _, ok := err.(*LanguageError); !ok {
 		t.Error(err)
 	}
-	_, _, err = Parse("Usage: prog -o ARG\nOptions: -o ARG", []string{"-o"}, true, "", false)
+	_, _, err = parse("Usage: prog -o ARG\nOptions: -o ARG", []string{"-o"}, true, "", false)
 	if _, ok := err.(*UserError); !ok {
 		t.Error(err)
 	}
 }
 
 func TestMatchingParen(t *testing.T) {
-	_, _, err := Parse("Usage: prog [a [b]", []string{}, true, "", false)
+	_, _, err := parse("Usage: prog [a [b]", []string{}, true, "", false)
 	if _, ok := err.(*LanguageError); !ok {
 		t.Error(err)
 	}
-	_, _, err = Parse("Usage: prog [a [b] ] c )", []string{}, true, "", false)
+	_, _, err = parse("Usage: prog [a [b] ] c )", []string{}, true, "", false)
 	if _, ok := err.(*LanguageError); !ok {
 		t.Error(err)
 	}
 }
 
 func TestAllowDoubleDash(t *testing.T) {
-	if v, _, err := Parse("usage: prog [-o] [--] <arg>\noptions: -o", []string{"--", "-o"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-o": false, "<arg>": "-o", "--": true}) != true {
+	if v, _, err := parse("usage: prog [-o] [--] <arg>\noptions: -o", []string{"--", "-o"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-o": false, "<arg>": "-o", "--": true}) != true {
 		t.Error(err)
 	}
-	if v, _, err := Parse("usage: prog [-o] [--] <arg>\noptions: -o", []string{"-o", "1"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-o": true, "<arg>": "1", "--": false}) != true {
+	if v, _, err := parse("usage: prog [-o] [--] <arg>\noptions: -o", []string{"-o", "1"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-o": true, "<arg>": "1", "--": false}) != true {
 		t.Error(err)
 	}
-	_, _, err := Parse("usage: prog [-o] <arg>\noptions:-o", []string{"-o"}, true, "", false)
+	_, _, err := parse("usage: prog [-o] <arg>\noptions:-o", []string{"-o"}, true, "", false)
 	if _, ok := err.(*UserError); !ok { //"--" is not allowed; FIXME?
 		t.Error(err)
 	}
@@ -1136,10 +1136,10 @@
 	doc := `Usage: prog [-v] A
 
                 Options: -v  Be verbose.`
-	if v, _, err := Parse(doc, []string{"arg"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-v": false, "A": "arg"}) != true {
+	if v, _, err := parse(doc, []string{"arg"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-v": false, "A": "arg"}) != true {
 		t.Error(err)
 	}
-	if v, _, err := Parse(doc, []string{"-v", "arg"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-v": true, "A": "arg"}) != true {
+	if v, _, err := parse(doc, []string{"-v", "arg"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-v": true, "A": "arg"}) != true {
 		t.Error(err)
 	}
 
@@ -1154,44 +1154,44 @@
       --help
 
     `
-	if v, _, err := Parse(doc, []string{"-v", "file.py"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-v": true, "-q": false, "-r": false, "--help": false, "FILE": "file.py", "INPUT": nil, "OUTPUT": nil}) != true {
+	if v, _, err := parse(doc, []string{"-v", "file.py"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-v": true, "-q": false, "-r": false, "--help": false, "FILE": "file.py", "INPUT": nil, "OUTPUT": nil}) != true {
 		t.Error(err)
 	}
-	if v, _, err := Parse(doc, []string{"-v"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-v": true, "-q": false, "-r": false, "--help": false, "FILE": nil, "INPUT": nil, "OUTPUT": nil}) != true {
+	if v, _, err := parse(doc, []string{"-v"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-v": true, "-q": false, "-r": false, "--help": false, "FILE": nil, "INPUT": nil, "OUTPUT": nil}) != true {
 		t.Error(err)
 	}
 
-	_, _, err := Parse(doc, []string{"-v", "input.py", "output.py"}, true, "", false) // does not match
+	_, _, err := parse(doc, []string{"-v", "input.py", "output.py"}, true, "", false) // does not match
 	if _, ok := err.(*UserError); !ok {
 		t.Error(err)
 	}
-	_, _, err = Parse(doc, []string{"--fake"}, true, "", false)
+	_, _, err = parse(doc, []string{"--fake"}, true, "", false)
 	if _, ok := err.(*UserError); !ok {
 		t.Error(err)
 	}
-	_, output, err := Parse(doc, []string{"--hel"}, true, "", false)
+	_, output, err := parse(doc, []string{"--hel"}, true, "", false)
 	if err != nil || len(output) == 0 {
 		t.Error(err)
 	}
 }
 
 func TestLanguageErrors(t *testing.T) {
-	_, _, err := Parse("no usage with colon here", []string{}, true, "", false)
+	_, _, err := parse("no usage with colon here", []string{}, true, "", false)
 	if _, ok := err.(*LanguageError); !ok {
 		t.Error(err)
 	}
-	_, _, err = Parse("usage: here \n\n and again usage: here", []string{}, true, "", false)
+	_, _, err = parse("usage: here \n\n and again usage: here", []string{}, true, "", false)
 	if _, ok := err.(*LanguageError); !ok {
 		t.Error(err)
 	}
 }
 
 func TestIssue40(t *testing.T) {
-	_, output, err := Parse("usage: prog --help-commands | --help", []string{"--help"}, true, "", false)
+	_, output, err := parse("usage: prog --help-commands | --help", []string{"--help"}, true, "", false)
 	if err != nil || len(output) == 0 {
 		t.Error(err)
 	}
-	if v, _, err := Parse("usage: prog --aabb | --aa", []string{"--aa"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"--aabb": false, "--aa": true}) != true {
+	if v, _, err := parse("usage: prog --aabb | --aa", []string{"--aa"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"--aabb": false, "--aa": true}) != true {
 		t.Error(err)
 	}
 }
@@ -1201,51 +1201,51 @@
 }
 
 func TestCountMultipleFlags(t *testing.T) {
-	if v, _, err := Parse("usage: prog [-v]", []string{"-v"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-v": true}) != true {
+	if v, _, err := parse("usage: prog [-v]", []string{"-v"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-v": true}) != true {
 		t.Error(err)
 	}
-	if v, _, err := Parse("usage: prog [-vv]", nil, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-v": 0}) != true {
+	if v, _, err := parse("usage: prog [-vv]", nil, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-v": 0}) != true {
 		t.Error(err)
 	}
-	if v, _, err := Parse("usage: prog [-vv]", []string{"-v"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-v": 1}) != true {
+	if v, _, err := parse("usage: prog [-vv]", []string{"-v"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-v": 1}) != true {
 		t.Error(err)
 	}
-	if v, _, err := Parse("usage: prog [-vv]", []string{"-vv"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-v": 2}) != true {
+	if v, _, err := parse("usage: prog [-vv]", []string{"-vv"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-v": 2}) != true {
 		t.Error(err)
 	}
-	_, _, err := Parse("usage: prog [-vv]", []string{"-vvv"}, true, "", false)
+	_, _, err := parse("usage: prog [-vv]", []string{"-vvv"}, true, "", false)
 	if _, ok := err.(*UserError); !ok {
 		t.Error(err)
 	}
-	if v, _, err := Parse("usage: prog [-v | -vv | -vvv]", []string{"-vvv"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-v": 3}) != true {
+	if v, _, err := parse("usage: prog [-v | -vv | -vvv]", []string{"-vvv"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-v": 3}) != true {
 		t.Error(err)
 	}
-	if v, _, err := Parse("usage: prog [-v...]", []string{"-vvvvvv"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-v": 6}) != true {
+	if v, _, err := parse("usage: prog [-v...]", []string{"-vvvvvv"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-v": 6}) != true {
 		t.Error(err)
 	}
-	if v, _, err := Parse("usage: prog [--ver --ver]", []string{"--ver", "--ver"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"--ver": 2}) != true {
+	if v, _, err := parse("usage: prog [--ver --ver]", []string{"--ver", "--ver"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"--ver": 2}) != true {
 		t.Error(err)
 	}
 }
 
 func TestAnyOptionsParameter(t *testing.T) {
-	_, _, err := Parse("usage: prog [options]",
+	_, _, err := parse("usage: prog [options]",
 		[]string{"-foo", "--bar", "--spam=eggs"}, true, "", false)
 	if _, ok := err.(*UserError); !ok {
 		t.Error()
 	}
 
-	_, _, err = Parse("usage: prog [options]",
+	_, _, err = parse("usage: prog [options]",
 		[]string{"--foo", "--bar", "--bar"}, true, "", false)
 	if _, ok := err.(*UserError); !ok {
 		t.Error()
 	}
-	_, _, err = Parse("usage: prog [options]",
+	_, _, err = parse("usage: prog [options]",
 		[]string{"--bar", "--bar", "--bar", "-ffff"}, true, "", false)
 	if _, ok := err.(*UserError); !ok {
 		t.Error()
 	}
-	_, _, err = Parse("usage: prog [options]",
+	_, _, err = parse("usage: prog [options]",
 		[]string{"--long=arg", "--long=another"}, true, "", false)
 	if _, ok := err.(*UserError); !ok {
 		t.Error()
@@ -1253,45 +1253,45 @@
 }
 
 func TestDefaultValueForPositionalArguments(t *testing.T) {
-	if v, _, err := Parse("usage: prog [<p>]\n\n<p>  [default: x]", []string{}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"<p>": nil}) != true {
+	if v, _, err := parse("usage: prog [<p>]\n\n<p>  [default: x]", []string{}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"<p>": nil}) != true {
 		t.Error(err)
 	}
 
-	if v, _, err := Parse("usage: prog [<p>]...\n\n<p>  [default: x y]", []string{}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"<p>": []string{}}) != true {
+	if v, _, err := parse("usage: prog [<p>]...\n\n<p>  [default: x y]", []string{}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"<p>": []string{}}) != true {
 		t.Error(err)
 	}
 
-	if v, _, err := Parse("usage: prog [<p>]...\n\n<p>  [default: x y]", []string{"this"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"<p>": []string{"this"}}) != true {
+	if v, _, err := parse("usage: prog [<p>]...\n\n<p>  [default: x y]", []string{"this"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"<p>": []string{"this"}}) != true {
 		t.Error(err)
 	}
 }
 
 func TestIssue59(t *testing.T) {
-	if v, _, err := Parse("usage: prog --long=<a>", []string{"--long="}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"--long": ""}) != true {
+	if v, _, err := parse("usage: prog --long=<a>", []string{"--long="}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"--long": ""}) != true {
 		t.Error(err)
 	}
 
-	if v, _, err := Parse("usage: prog -l <a>\noptions: -l <a>", []string{"-l", ""}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-l": ""}) != true {
+	if v, _, err := parse("usage: prog -l <a>\noptions: -l <a>", []string{"-l", ""}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"-l": ""}) != true {
 		t.Error(err)
 	}
 }
 
 func TestOptionsFirst(t *testing.T) {
-	if v, _, err := Parse("usage: prog [--opt] [<args>...]", []string{"--opt", "this", "that"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"--opt": true, "<args>": []string{"this", "that"}}) != true {
+	if v, _, err := parse("usage: prog [--opt] [<args>...]", []string{"--opt", "this", "that"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"--opt": true, "<args>": []string{"this", "that"}}) != true {
 		t.Error(err)
 	}
 
-	if v, _, err := Parse("usage: prog [--opt] [<args>...]", []string{"this", "that", "--opt"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"--opt": true, "<args>": []string{"this", "that"}}) != true {
+	if v, _, err := parse("usage: prog [--opt] [<args>...]", []string{"this", "that", "--opt"}, true, "", false); reflect.DeepEqual(v, map[string]interface{}{"--opt": true, "<args>": []string{"this", "that"}}) != true {
 		t.Error(err)
 	}
 
-	if v, _, err := Parse("usage: prog [--opt] [<args>...]", []string{"this", "that", "--opt"}, true, "", true); reflect.DeepEqual(v, map[string]interface{}{"--opt": false, "<args>": []string{"this", "that", "--opt"}}) != true {
+	if v, _, err := parse("usage: prog [--opt] [<args>...]", []string{"this", "that", "--opt"}, true, "", true); reflect.DeepEqual(v, map[string]interface{}{"--opt": false, "<args>": []string{"this", "that", "--opt"}}) != true {
 		t.Error(err)
 	}
 }
 
 func TestIssue68OptionsShortcutDoesNotIncludeOptionsInUsagePattern(t *testing.T) {
-	args, _, err := Parse("usage: prog [-ab] [options]\noptions: -x\n -y", []string{"-ax"}, true, "", false)
+	args, _, err := parse("usage: prog [-ab] [options]\noptions: -x\n -y", []string{"-ax"}, true, "", false)
 
 	if args["-a"] != true {
 		t.Error(err)
@@ -1309,14 +1309,14 @@
 
 func TestIssue65EvaluateArgvWhenCalledNotWhenImported(t *testing.T) {
 	os.Args = strings.Fields("prog -a")
-	v, _, err := Parse("usage: prog [-ab]", nil, true, "", false)
+	v, _, err := parse("usage: prog [-ab]", nil, true, "", false)
 	w := map[string]interface{}{"-a": true, "-b": false}
 	if reflect.DeepEqual(v, w) != true {
 		t.Error(err)
 	}
 
 	os.Args = strings.Fields("prog -b")
-	v, _, err = Parse("usage: prog [-ab]", nil, true, "", false)
+	v, _, err = parse("usage: prog [-ab]", nil, true, "", false)
 	w = map[string]interface{}{"-a": false, "-b": true}
 	if reflect.DeepEqual(v, w) != true {
 		t.Error(err)
@@ -1324,13 +1324,13 @@
 }
 
 func TestIssue71DoubleDashIsNotAValidOptionArgument(t *testing.T) {
-	_, _, err := Parse("usage: prog [--log=LEVEL] [--] <args>...",
+	_, _, err := parse("usage: prog [--log=LEVEL] [--] <args>...",
 		[]string{"--log", "--", "1", "2"}, true, "", false)
 	if _, ok := err.(*UserError); !ok {
 		t.Error()
 	}
 
-	_, _, err = Parse(`usage: prog [-l LEVEL] [--] <args>...
+	_, _, err = parse(`usage: prog [-l LEVEL] [--] <args>...
                   options: -l LEVEL`, []string{"-l", "--", "1", "2"}, true, "", false)
 	if _, ok := err.(*UserError); !ok {
 		t.Error()
@@ -1411,7 +1411,7 @@
 			t.Fatal(err)
 			break
 		}
-		result, _, err := Parse(c.doc, c.argv, true, "", false)
+		result, _, err := parse(c.doc, c.argv, true, "", false)
 		if _, ok := err.(*UserError); c.userError && !ok {
 			// expected a user-error
 			t.Error("testcase:", c.id, "result:", result)
@@ -1425,32 +1425,31 @@
 }
 
 func TestFileTestcasesGo(t *testing.T) {
-    filename := "test_golang.docopt"
-    file, err := os.Open(filename)
-    if err != nil {
-        t.Fatal(err)
-    }
-    defer file.Close()
+	filename := "test_golang.docopt"
+	file, err := os.Open(filename)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer file.Close()
 
-    for c := range parseTest(file) {
-        if c.err != nil {
-            t.Fatal(err)
-            break
-        }
-        result, _, err := Parse(c.doc, c.argv, true, "", false)
-        if _, ok := err.(*UserError); c.userError && !ok {
-            // expected a user-error
-            t.Error("testcase:", c.id, "result:", result)
-        } else if _, ok := err.(*UserError); !c.userError && ok {
-            // unexpected user-error
-            t.Error("testcase:", c.id, "error:", err, "result:", result)
-        } else if reflect.DeepEqual(c.expect, result) != true {
-            t.Error("testcase:", c.id, "result:", result)
-        }
-    }
+	for c := range parseTest(file) {
+		if c.err != nil {
+			t.Fatal(err)
+			break
+		}
+		result, _, err := parse(c.doc, c.argv, true, "", false)
+		if _, ok := err.(*UserError); c.userError && !ok {
+			// expected a user-error
+			t.Error("testcase:", c.id, "result:", result)
+		} else if _, ok := err.(*UserError); !c.userError && ok {
+			// unexpected user-error
+			t.Error("testcase:", c.id, "error:", err, "result:", result)
+		} else if reflect.DeepEqual(c.expect, result) != true {
+			t.Error("testcase:", c.id, "result:", result)
+		}
+	}
 }
 
-
 type testcase struct {
 	id        int
 	doc       string
diff --git a/examples/naval_fate.go b/examples/naval_fate.go
index 4756d57..d3d0d36 100644
--- a/examples/naval_fate.go
+++ b/examples/naval_fate.go
@@ -1,12 +1,12 @@
 package main
 
 import (
-        "fmt"
-        docopt "github.com/kbatten/docopt.go"
+	"fmt"
+	docopt "github.com/kbatten/docopt.go"
 )
 
 func main() {
-usage := `Naval Fate.
+	usage := `Naval Fate.
 
 Usage:
   naval_fate.py ship new <name>...
@@ -23,6 +23,6 @@
   --moored      Moored (anchored) mine.
   --drifting    Drifting mine.`
 
-    arguments := docopt.ParseLoud(usage, nil, true, "Naval Fate 2.0", false)
-    fmt.Println(arguments)
+	arguments, _ := docopt.Parse(usage, nil, true, "Naval Fate 2.0", false)
+	fmt.Println(arguments)
 }