func Op(op string) *Statement {
	return newStatement().Op(op)
}
Op renders the provided operator / token.
package jen
import (
	"fmt"
	"io"
	"strconv"
	"strings"
)
type tokenType string
const (
	packageToken     tokenType = "package"
	identifierToken  tokenType = "identifier"
	qualifiedToken   tokenType = "qualified"
	keywordToken     tokenType = "keyword"
	operatorToken    tokenType = "operator"
	delimiterToken   tokenType = "delimiter"
	literalToken     tokenType = "literal"
	literalRuneToken tokenType = "literal_rune"
	literalByteToken tokenType = "literal_byte"
	nullToken        tokenType = "null"
	layoutToken      tokenType = "layout"
)
type token struct {
	typ     tokenType
	content interface{}
}
func (t token) isNull(f *File) bool {
	if t.typ == packageToken {
		return f.isDotImport(t.content.(string)) || f.isLocal(t.content.(string))
	}
	return t.typ == nullToken
}
func (t token) render(f *File, w io.Writer, s *Statement) error {
	switch t.typ {
	case literalToken:
		var out string
		switch t.content.(type) {
		case bool, string, int, complex128:
			out = fmt.Sprintf("%#v", t.content)
		case float64:
			out = fmt.Sprintf("%#v", t.content)
			if !strings.Contains(out, ".") && !strings.Contains(out, "e") {
				out += ".0"
			}
		case float32, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, uintptr:
			out = fmt.Sprintf("%T(%#v)", t.content, t.content)
		case complex64:
			out = fmt.Sprintf("%T%#v", t.content, t.content)
		default:
			panic(fmt.Sprintf("unsupported type for literal: %T", t.content))
		}
		if _, err := w.Write([]byte(out)); err != nil {
			return err
		}
	case literalRuneToken:
		if _, err := w.Write([]byte(strconv.QuoteRune(t.content.(rune)))); err != nil {
			return err
		}
	case literalByteToken:
		if _, err := w.Write([]byte(fmt.Sprintf("byte(%#v)", t.content))); err != nil {
			return err
		}
	case keywordToken, operatorToken, layoutToken, delimiterToken:
		if _, err := w.Write([]byte(fmt.Sprintf("%s", t.content))); err != nil {
			return err
		}
		if t.content.(string) == "default" {
			if _, err := w.Write([]byte(":")); err != nil {
				return err
			}
		}
	case packageToken:
		path := t.content.(string)
		alias := f.register(path)
		if _, err := w.Write([]byte(alias)); err != nil {
			return err
		}
	case identifierToken:
		if _, err := w.Write([]byte(t.content.(string))); err != nil {
			return err
		}
	case nullToken:  
	}
	return nil
}
func Null() *Statement {
	return newStatement().Null()
}
func (g *Group) Null() *Statement {
	s := Null()
	g.items = append(g.items, s)
	return s
}
func (s *Statement) Null() *Statement {
	t := token{
		typ: nullToken,
	}
	*s = append(*s, t)
	return s
}
func Empty() *Statement {
	return newStatement().Empty()
}
func (g *Group) Empty() *Statement {
	s := Empty()
	g.items = append(g.items, s)
	return s
}
func (s *Statement) Empty() *Statement {
	t := token{
		typ:     operatorToken,
		content: "",
	}
	*s = append(*s, t)
	return s
}