func (s *String) CanContain(objType ObjectType) bool {
	return objType == ObjectTypeString
}
CanContain whether or not the string can contain the objType
package language
import (
	"bytes"
	"fmt"
	"sort"
	"strconv"
	"strings"
	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/service/dynamodb"
)
var (
	NULL = &Null{}
	TRUE = &Boolean{Value: true}
	FALSE = &Boolean{Value: false}
)
type ObjectType string
const (
	ObjectTypeBinary ObjectType = "B"
	ObjectTypeBinarySet ObjectType = "BS"
	ObjectTypeBoolean ObjectType = "BOOL"
	ObjectTypeList ObjectType = "L"
	ObjectTypeMap ObjectType = "M"
	ObjectTypeNull ObjectType = "NULL"
	ObjectTypeNumber ObjectType = "N"
	ObjectTypeNumberSet ObjectType = "NS"
	ObjectTypeStringSet ObjectType = "SS"
	ObjectTypeString ObjectType = "S"
	ObjectTypeError ObjectType = "ERR"
	ObjectTypeFunction ObjectType = "FN"
)
var dynamodbTypes = map[ObjectType]bool{
	ObjectTypeBinary:    true,
	ObjectTypeBinarySet: true,
	ObjectTypeBoolean:   true,
	ObjectTypeList:      true,
	ObjectTypeMap:       true,
	ObjectTypeNull:      true,
	ObjectTypeNumber:    true,
	ObjectTypeNumberSet: true,
	ObjectTypeStringSet: true,
	ObjectTypeString:    true,
}
var comparableTypes = map[ObjectType]bool{
	ObjectTypeNumber: true,
	ObjectTypeString: true,
	ObjectTypeBinary: true,
}
var setTypes = map[ObjectType]bool{
	ObjectTypeBinarySet: true,
	ObjectTypeStringSet: true,
	ObjectTypeNumberSet: true,
}
type Object interface {
	Type() ObjectType
	Inspect() string
	ToDynamoDB() *dynamodb.AttributeValue
}
type ContainerObject interface {
	Object
	Contains(obj Object) bool
	CanContain(objType ObjectType) bool
}
type Number struct {
	Value float64
}
func (i *Number) Inspect() string {
	return numToString(i.Value)
}
func (i *Number) Type() ObjectType {
	return ObjectTypeNumber
}
func (i *Number) ToDynamoDB() *dynamodb.AttributeValue {
	str := numToString(i.Value)
	return &dynamodb.AttributeValue{N: &str}
}
func numToString(v float64) string {
	return strconv.FormatFloat(v, 'f', -1, 64)
}
type Boolean struct {
	Value bool
}
func (b *Boolean) Inspect() string {
	return fmt.Sprintf("%t", b.Value)
}
func (b *Boolean) Type() ObjectType {
	return ObjectTypeBoolean
}
func (b *Boolean) ToDynamoDB() *dynamodb.AttributeValue {
	return &dynamodb.AttributeValue{BOOL: aws.Bool(b.Value)}
}
func nativeBoolToBooleanObject(input bool) *Boolean {
	if input {
		return TRUE
	}
	return FALSE
}
type Binary struct {
	Value []byte
}
func (b *Binary) Inspect() string {
	return fmt.Sprintf("%v", b.Value)
}
func (b *Binary) Type() ObjectType {
	return ObjectTypeBinary
}
func (b *Binary) ToDynamoDB() *dynamodb.AttributeValue {
	return &dynamodb.AttributeValue{B: b.Value}
}
func (b *Binary) Contains(obj Object) bool {
	bin, ok := obj.(*Binary)
	if !ok {
		return false
	}
	return bytes.Contains(b.Value, bin.Value)
}
func (b *Binary) CanContain(objType ObjectType) bool {
	return objType == ObjectTypeBinary
}
type Null struct{}
func (n *Null) Type() ObjectType { return ObjectTypeNull }
func (n *Null) Inspect() string {
	return "null"
}
func (n *Null) ToDynamoDB() *dynamodb.AttributeValue {
	return &dynamodb.AttributeValue{NULL: aws.Bool(true)}
}
type Error struct {
	Message string
}
func (e *Error) Type() ObjectType { return ObjectTypeError }
func (e *Error) Inspect() string { return "ERROR: " + e.Message }
func (e *Error) ToDynamoDB() *dynamodb.AttributeValue {
	return nil
}
type String struct {
	Value string
}
func (s *String) Inspect() string {
	return s.Value
}
func (s *String) Type() ObjectType {
	return ObjectTypeString
}
func (s *String) Contains(obj Object) bool {
	str, ok := obj.(*String)
	if !ok {
		return false
	}
	return strings.Contains(s.Value, str.Value)
}
func (s *String) ToDynamoDB() *dynamodb.AttributeValue {
	return &dynamodb.AttributeValue{S: aws.String(s.Value)}
}