func (c *CommandContext) String(argumentName string) string {
	if c.Arguments == nil {
		return ""
	}
	r, ok := c.Arguments[argumentName]
	if !ok {
		return ""
	}
	v, _ := r.Result.(string)
	return v
}
String returns the parsed string argument from the command context.
It returns the zero-value if not found.
package brigodier
import (
	"errors"
	"fmt"
	"math"
	"strings"
)
var (
	String ArgumentType = QuotablePhase
	StringWord ArgumentType = SingleWord
	StringPhrase ArgumentType = GreedyPhrase
	Bool ArgumentType = &BoolArgumentType{}
	Int32 ArgumentType = &Int32ArgumentType{
		Min: MinInt32,
		Max: MaxInt32,
	}
	Int64 ArgumentType = &Int64ArgumentType{
		Min: MinInt64,
		Max: MaxInt64,
	}
	Int = Int32
	Float32 ArgumentType = &Float32ArgumentType{
		Min: MinFloat32,
		Max: MaxFloat32,
	}
	Float64 ArgumentType = &Float64ArgumentType{
		Min: MinFloat64,
		Max: MaxFloat64,
	}
)
const (
	MinInt32   = math.MinInt32
	MaxInt32   = math.MaxInt32
	MinInt64   = math.MinInt32
	MaxInt64   = math.MaxInt64
	MinFloat32 = -math.MaxFloat32
	MaxFloat32 = math.MaxFloat32
	MinFloat64 = -math.MaxFloat64
	MaxFloat64 = math.MaxFloat64
)
type ArgumentType interface {
	Parse(rd *StringReader) (interface{}, error)
	String() string  
}
type ArgumentTypeFuncs struct {
	Name    string                                       
	ParseFn func(rd *StringReader) (interface{}, error)  
	SuggestionsFn func(ctx *CommandContext, builder *SuggestionsBuilder) *Suggestions
}
func (t *ArgumentTypeFuncs) Parse(rd *StringReader) (interface{}, error) { return t.ParseFn(rd) }
func (t *ArgumentTypeFuncs) String() string                              { return t.Name }
func (c *CommandContext) Int(argumentName string) int {
	return int(c.Int32(argumentName))
}
func (c *CommandContext) Int32(argumentName string) int32 {
	if c.Arguments == nil {
		return 0
	}
	r, ok := c.Arguments[argumentName]
	if !ok {
		return 0
	}
	v, _ := r.Result.(int32)
	return v
}
func (c *CommandContext) Int64(argumentName string) int64 {
	if c.Arguments == nil {
		return 0
	}
	r, ok := c.Arguments[argumentName]
	if !ok {
		return 0
	}
	v, _ := r.Result.(int64)
	return v
}
func (c *CommandContext) Bool(argumentName string) bool {
	if c.Arguments == nil {
		return false
	}
	r, ok := c.Arguments[argumentName]
	if !ok {
		return false
	}
	v, _ := r.Result.(bool)
	return v
}
func (c *CommandContext) Float32(argumentName string) float32 {
	if c.Arguments == nil {
		return 0
	}
	r, ok := c.Arguments[argumentName]
	if !ok {
		return 0
	}
	v, _ := r.Result.(float32)
	return v
}
func (c *CommandContext) Float64(argumentName string) float64 {
	if c.Arguments == nil {
		return 0
	}
	r, ok := c.Arguments[argumentName]
	if !ok {
		return 0
	}
	v, _ := r.Result.(float64)
	return v
}