jen

package
v1.4.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 26, 2019 License: MIT Imports: 9 Imported by: 0

Documentation

Overview

Package jen is a code generator for Go

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func IsReservedWord added in v1.4.0 

func IsReservedWord(alias string) bool

IsReservedWord returns if this is a reserved word in go

Types

type Code 

type Code interface {
	// contains filtered or unexported methods
}

Code represents an item of code that can be rendered.

type Dict 

type Dict map[Code]Code

Dict renders as key/value pairs. Use with Values for map or composite literals.

Example 
c := Id("a").Op(":=").Map(String()).String().Values(Dict{
	Lit("a"): Lit("b"),
	Lit("c"): Lit("d"),
})
fmt.Printf("%#v", c)

Output:

a := map[string]string{
	"a": "b",
	"c": "d",
}
Example (Nil) 
c := Id("a").Op(":=").Map(String()).String().Values()
fmt.Printf("%#v", c)

Output:

a := map[string]string{}

func DictFunc 

func DictFunc(f func(Dict)) Dict

DictFunc executes a func(Dict) to generate the value. Use with Values for map or composite literals.

Example 
c := Id("a").Op(":=").Map(String()).String().Values(DictFunc(func(d Dict) {
	d[Lit("a")] = Lit("b")
	d[Lit("c")] = Lit("d")
}))
fmt.Printf("%#v", c)

Output:

a := map[string]string{
	"a": "b",
	"c": "d",
}

type File 

type File struct {
	*Group

	// If you're worried about generated package aliases conflicting with local variable names, you
	// can set a prefix here. Package foo becomes {prefix}_foo.
	PackagePrefix string
	// CanonicalPath adds a canonical import path annotation to the package clause.
	CanonicalPath string
	// contains filtered or unexported fields
}

File represents a single source file. Package imports are managed automaticaly by File.

func NewFile 

func NewFile(packageName string) *File

NewFile Creates a new file, with the specified package name.

Example 
f := NewFile("main")
f.Func().Id("main").Params().Block(
	Qual("fmt", "Println").Call(Lit("Hello, world")),
)
fmt.Printf("%#v", f)

Output:

package main

import "fmt"

func main() {
	fmt.Println("Hello, world")
}

func NewFilePath 

func NewFilePath(packagePath string) *File

NewFilePath creates a new file while specifying the package path - the package name is inferred from the path.

Example 
f := NewFilePath("a.b/c")
f.Func().Id("init").Params().Block(
	Qual("a.b/c", "Foo").Call().Comment("Local package - alias is omitted."),
	Qual("d.e/f", "Bar").Call().Comment("Import is automatically added."),
	Qual("g.h/f", "Baz").Call().Comment("Colliding package name is automatically renamed."),
)
fmt.Printf("%#v", f)

Output:

package c

import (
	f "d.e/f"
	f1 "g.h/f"
)

func init() {
	Foo()    // Local package - alias is omitted.
	f.Bar()  // Import is automatically added.
	f1.Baz() // Colliding package name is automatically renamed.
}

func NewFilePathName 

func NewFilePathName(packagePath, packageName string) *File

NewFilePathName creates a new file with the specified package path and name.

Example 
f := NewFilePathName("a.b/c", "main")
f.Func().Id("main").Params().Block(
	Qual("a.b/c", "Foo").Call(),
)
fmt.Printf("%#v", f)

Output:

package main

func main() {
	Foo()
}

func (*File) Anon 

func (f *File) Anon(paths ...string)

Anon adds an anonymous import.

Example 
f := NewFile("c")
f.Anon("a")
f.Func().Id("init").Params().Block()
fmt.Printf("%#v", f)

Output:

package c

import _ "a"

func init() {}

func (*File) CgoPreamble added in v0.17.0 

func (f *File) CgoPreamble(comment string)

CgoPreamble adds a cgo preamble comment that is rendered directly before the "C" pseudo-package import.

Example 
f := NewFile("a")
f.CgoPreamble(`#include <stdio.h>
#include <stdlib.h>

void myprint(char* s) {
	printf("%s\n", s);
}
`)
f.Func().Id("init").Params().Block(
	Id("cs").Op(":=").Qual("C", "CString").Call(Lit("Hello from stdio\n")),
	Qual("C", "myprint").Call(Id("cs")),
	Qual("C", "free").Call(Qual("unsafe", "Pointer").Parens(Id("cs"))),
)
fmt.Printf("%#v", f)

Output:

package a

import "unsafe"

/*
#include <stdio.h>
#include <stdlib.h>

void myprint(char* s) {
	printf("%s\n", s);
}
*/
import "C"

func init() {
	cs := C.CString("Hello from stdio\n")
	C.myprint(cs)
	C.free(unsafe.Pointer(cs))
}
Example (Anon) 
f := NewFile("a")
f.CgoPreamble(`#include <stdio.h>`)
f.Func().Id("init").Params().Block(
	Qual("foo.bar/a", "A"),
	Qual("foo.bar/b", "B"),
)
fmt.Printf("%#v", f)

Output:

package a

import (
	a "foo.bar/a"
	b "foo.bar/b"
)

// #include <stdio.h>
import "C"

func init() {
	a.A
	b.B
}
Example (No_preamble) 
f := NewFile("a")
f.Func().Id("init").Params().Block(
	Qual("C", "Foo").Call(),
	Qual("fmt", "Print").Call(),
)
fmt.Printf("%#v", f)

Output:

package a

import (
	"C"
	"fmt"
)

func init() {
	C.Foo()
	fmt.Print()
}
Example (No_preamble_anon) 
f := NewFile("a")
f.Anon("C")
f.Func().Id("init").Params().Block(
	Qual("fmt", "Print").Call(),
)
fmt.Printf("%#v", f)

Output:

package a

import (
	"C"
	"fmt"
)

func init() {
	fmt.Print()
}
Example (No_preamble_single) 
f := NewFile("a")
f.Func().Id("init").Params().Block(
	Qual("C", "Foo").Call(),
)
fmt.Printf("%#v", f)

Output:

package a

import "C"

func init() {
	C.Foo()
}
Example (No_preamble_single_anon) 
f := NewFile("a")
f.Anon("C")
f.Func().Id("init").Params().Block()
fmt.Printf("%#v", f)

Output:

package a

import "C"

func init() {}

func (*File) GoString 

func (f *File) GoString() string

GoString renders the File for testing. Any error will cause a panic.

func (*File) HeaderComment added in v0.15.0 

func (f *File) HeaderComment(comment string)

HeaderComment adds a comment to the top of the file, above any package comments. A blank line is rendered below the header comments, ensuring header comments are not included in the package doc.

func (*File) ImportAlias added in v0.18.0 

func (f *File) ImportAlias(path, alias string)

ImportAlias provides the alias for a package path that should be used in the import block. A period can be used to force a dot-import.

Example 
f := NewFile("main")

// package a should be aliased to "b"
f.ImportAlias("github.com/foo/a", "b")

// package c is not used in the code so will not be included
f.ImportAlias("github.com/foo/c", "c")

f.Func().Id("main").Params().Block(
	Qual("github.com/foo/a", "A").Call(),
)
fmt.Printf("%#v", f)

Output:

package main

import b "github.com/foo/a"

func main() {
	b.A()
}
Example (Conflict) 
f := NewFile("main")

// We provide a hint that package foo/a should use alias "b", but because package bar/b already
// registers the required name, foo/a is aliased using the requested alias as a base.
f.ImportName("github.com/foo/a", "b")

f.Func().Id("main").Params().Block(
	Qual("github.com/bar/b", "Bar").Call(),
	Qual("github.com/foo/a", "Foo").Call(),
)
fmt.Printf("%#v", f)

Output:

package main

import (
	b "github.com/bar/b"
	b1 "github.com/foo/a"
)

func main() {
	b.Bar()
	b1.Foo()
}

func (*File) ImportName added in v0.18.0 

func (f *File) ImportName(path, name string)

ImportName provides the package name for a path. If specified, the alias will be omitted from the import block. This is optional. If not specified, a sensible package name is used based on the path and this is added as an alias in the import block.

Example 
f := NewFile("main")

// package a should use name "a"
f.ImportName("github.com/foo/a", "a")

// package b is not used in the code so will not be included
f.ImportName("github.com/foo/b", "b")

f.Func().Id("main").Params().Block(
	Qual("github.com/foo/a", "A").Call(),
)
fmt.Printf("%#v", f)

Output:

package main

import "github.com/foo/a"

func main() {
	a.A()
}
Example (Conflict) 
f := NewFile("main")

// We provide a hint that package foo/a should use name "a", but because package bar/a already
// registers the required name, foo/a is aliased.
f.ImportName("github.com/foo/a", "a")

f.Func().Id("main").Params().Block(
	Qual("github.com/bar/a", "Bar").Call(),
	Qual("github.com/foo/a", "Foo").Call(),
)
fmt.Printf("%#v", f)

Output:

package main

import (
	a "github.com/bar/a"
	a1 "github.com/foo/a"
)

func main() {
	a.Bar()
	a1.Foo()
}

func (*File) ImportNames added in v0.18.0 

func (f *File) ImportNames(names map[string]string)

ImportNames allows multiple names to be imported as a map. Use the [gennames](gennames) command to automatically generate a go file containing a map of a selection of package names.

Example 
// package a should use name "a", package b is not used in the code so will not be included
names := map[string]string{
	"github.com/foo/a": "a",
	"github.com/foo/b": "b",
}

f := NewFile("main")
f.ImportNames(names)
f.Func().Id("main").Params().Block(
	Qual("github.com/foo/a", "A").Call(),
)
fmt.Printf("%#v", f)

Output:

package main

import "github.com/foo/a"

func main() {
	a.A()
}

func (*File) PackageComment 

func (f *File) PackageComment(comment string)

PackageComment adds a comment to the top of the file, above the package keyword.

func (*File) Render 

func (f *File) Render(w io.Writer) error

Render renders the file to the provided writer.

Example 
f := NewFile("a")
f.Func().Id("main").Params().Block()
buf := &bytes.Buffer{}
err := f.Render(buf)
if err != nil {
	fmt.Println(err.Error())
} else {
	fmt.Println(buf.String())
}

Output:

package a

func main() {}

func (*File) Save 

func (f *File) Save(filename string) error

Save renders the file and saves to the filename provided.

type Group 

type Group struct {
	// contains filtered or unexported fields
}

Group represents a list of Code items, separated by tokens with an optional open and close token.

func (*Group) Add 

func (g *Group) Add(code ...Code) *Statement

Add appends the provided items to the statement.

func (*Group) Append 

func (g *Group) Append(args ...Code) *Statement

Append renders the append built-in function.

func (*Group) AppendFunc added in v0.9.1 

func (g *Group) AppendFunc(f func(*Group)) *Statement

AppendFunc renders the append built-in function.

func (*Group) Assert 

func (g *Group) Assert(typ Code) *Statement

Assert renders a period followed by a single item enclosed by parenthesis. Use for type assertions.

func (*Group) Block 

func (g *Group) Block(statements ...Code) *Statement

Block renders a statement list enclosed by curly braces. Use for code blocks. A special case applies when used directly after Case or Default, where the braces are omitted. This allows use in switch and select statements.

func (*Group) BlockFunc 

func (g *Group) BlockFunc(f func(*Group)) *Statement

BlockFunc renders a statement list enclosed by curly braces. Use for code blocks. A special case applies when used directly after Case or Default, where the braces are omitted. This allows use in switch and select statements.

func (*Group) Bool 

func (g *Group) Bool() *Statement

Bool renders the bool identifier.

func (*Group) Break 

func (g *Group) Break() *Statement

Break renders the break keyword.

func (*Group) Byte 

func (g *Group) Byte() *Statement

Byte renders the byte identifier.

func (*Group) Call 

func (g *Group) Call(params ...Code) *Statement

Call renders a comma separated list enclosed by parenthesis. Use for function calls.

func (*Group) CallFunc 

func (g *Group) CallFunc(f func(*Group)) *Statement

CallFunc renders a comma separated list enclosed by parenthesis. Use for function calls.

func (*Group) Cap 

func (g *Group) Cap(v Code) *Statement

Cap renders the cap built-in function.

func (*Group) Case 

func (g *Group) Case(cases ...Code) *Statement

Case renders the keyword followed by a comma separated list.

func (*Group) CaseFunc 

func (g *Group) CaseFunc(f func(*Group)) *Statement

CaseFunc renders the keyword followed by a comma separated list.

func (*Group) Chan 

func (g *Group) Chan() *Statement

Chan renders the chan keyword.

func (*Group) Close 

func (g *Group) Close(c Code) *Statement

Close renders the close built-in function.

func (*Group) Comment 

func (g *Group) Comment(str string) *Statement

Comment adds a comment. If the provided string contains a newline, the comment is formatted in multiline style. If the comment string starts with "//" or "/*", the automatic formatting is disabled and the string is rendered directly.

func (*Group) Commentf 

func (g *Group) Commentf(format string, a ...interface{}) *Statement

Commentf adds a comment, using a format string and a list of parameters. If the provided string contains a newline, the comment is formatted in multiline style. If the comment string starts with "//" or "/*", the automatic formatting is disabled and the string is rendered directly.

func (*Group) Complex 

func (g *Group) Complex(r Code, i Code) *Statement

Complex renders the complex built-in function.

func (*Group) Complex128 

func (g *Group) Complex128() *Statement

Complex128 renders the complex128 identifier.

func (*Group) Complex64 

func (g *Group) Complex64() *Statement

Complex64 renders the complex64 identifier.

func (*Group) Const 

func (g *Group) Const() *Statement

Const renders the const keyword.

func (*Group) Continue 

func (g *Group) Continue() *Statement

Continue renders the continue keyword.

func (*Group) Copy 

func (g *Group) Copy(dst Code, src Code) *Statement

Copy renders the copy built-in function.

func (*Group) Custom added in v0.19.0 

func (g *Group) Custom(options Options, statements ...Code) *Statement

Custom renders a customized statement list. Pass in options to specify multi-line, and tokens for open, close, separator.

func (*Group) CustomFunc added in v0.19.0 

func (g *Group) CustomFunc(options Options, f func(*Group)) *Statement

CustomFunc renders a customized statement list. Pass in options to specify multi-line, and tokens for open, close, separator.

func (*Group) Default 

func (g *Group) Default() *Statement

Default renders the default keyword.

func (*Group) Defer 

func (g *Group) Defer() *Statement

Defer renders the defer keyword.

func (*Group) Defs 

func (g *Group) Defs(definitions ...Code) *Statement

Defs renders a statement list enclosed in parenthesis. Use for definition lists.

func (*Group) DefsFunc 

func (g *Group) DefsFunc(f func(*Group)) *Statement

DefsFunc renders a statement list enclosed in parenthesis. Use for definition lists.

func (*Group) Delete 

func (g *Group) Delete(m Code, key Code) *Statement

Delete renders the delete built-in function.

func (*Group) Do 

func (g *Group) Do(f func(*Statement)) *Statement

Do calls the provided function with the statement as a parameter. Use for embedding logic.

func (*Group) Dot added in v0.11.0 

func (g *Group) Dot(name string) *Statement

Dot renders a period followed by an identifier. Use for fields and selectors.

func (*Group) Else 

func (g *Group) Else() *Statement

Else renders the else keyword.

func (*Group) Empty 

func (g *Group) Empty() *Statement

Empty adds an empty item. Empty items render nothing but are followed by a separator in lists.

func (*Group) Err 

func (g *Group) Err() *Statement

Err renders the err identifier.

func (*Group) Error 

func (g *Group) Error() *Statement

Error renders the error identifier.

func (*Group) Fallthrough 

func (g *Group) Fallthrough() *Statement

Fallthrough renders the fallthrough keyword.

func (*Group) False 

func (g *Group) False() *Statement

False renders the false identifier.

func (*Group) Float32 

func (g *Group) Float32() *Statement

Float32 renders the float32 identifier.

func (*Group) Float64 

func (g *Group) Float64() *Statement

Float64 renders the float64 identifier.

func (*Group) For 

func (g *Group) For(conditions ...Code) *Statement

For renders the keyword followed by a semicolon separated list.

func (*Group) ForFunc 

func (g *Group) ForFunc(f func(*Group)) *Statement

ForFunc renders the keyword followed by a semicolon separated list.

func (*Group) Func 

func (g *Group) Func() *Statement

Func renders the func keyword.

func (*Group) Go 

func (g *Group) Go() *Statement

Go renders the go keyword.

func (*Group) GoString 

func (g *Group) GoString() string

GoString renders the Group for testing. Any error will cause a panic.

func (*Group) Goto 

func (g *Group) Goto() *Statement

Goto renders the goto keyword.

func (*Group) Id 

func (g *Group) Id(name string) *Statement

Id renders an identifier.

func (*Group) If 

func (g *Group) If(conditions ...Code) *Statement

If renders the keyword followed by a semicolon separated list.

func (*Group) IfFunc 

func (g *Group) IfFunc(f func(*Group)) *Statement

IfFunc renders the keyword followed by a semicolon separated list.

func (*Group) Imag 

func (g *Group) Imag(c Code) *Statement

Imag renders the imag built-in function.

func (*Group) Index 

func (g *Group) Index(items ...Code) *Statement

Index renders a colon separated list enclosed by square brackets. Use for array / slice indexes and definitions.

func (*Group) IndexFunc 

func (g *Group) IndexFunc(f func(*Group)) *Statement

IndexFunc renders a colon separated list enclosed by square brackets. Use for array / slice indexes and definitions.

func (*Group) Int 

func (g *Group) Int() *Statement

Int renders the int identifier.

func (*Group) Int16 

func (g *Group) Int16() *Statement

Int16 renders the int16 identifier.

func (*Group) Int32 

func (g *Group) Int32() *Statement

Int32 renders the int32 identifier.

func (*Group) Int64 

func (g *Group) Int64() *Statement

Int64 renders the int64 identifier.

func (*Group) Int8 

func (g *Group) Int8() *Statement

Int8 renders the int8 identifier.

func (*Group) Interface 

func (g *Group) Interface(methods ...Code) *Statement

Interface renders the keyword followed by a method list enclosed by curly braces.

func (*Group) InterfaceFunc 

func (g *Group) InterfaceFunc(f func(*Group)) *Statement

InterfaceFunc renders the keyword followed by a method list enclosed by curly braces.

func (*Group) Iota 

func (g *Group) Iota() *Statement

Iota renders the iota identifier.

func (*Group) Len 

func (g *Group) Len(v Code) *Statement

Len renders the len built-in function.

func (*Group) Line 

func (g *Group) Line() *Statement

Line inserts a blank line.

func (*Group) List 

func (g *Group) List(items ...Code) *Statement

List renders a comma separated list. Use for multiple return functions.

func (*Group) ListFunc 

func (g *Group) ListFunc(f func(*Group)) *Statement

ListFunc renders a comma separated list. Use for multiple return functions.

func (*Group) Lit 

func (g *Group) Lit(v interface{}) *Statement

Lit renders a literal. Lit supports only built-in types (bool, string, int, complex128, float64, float32, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, uintptr and complex64). Passing any other type will panic.

func (*Group) LitByte added in v0.13.0 

func (g *Group) LitByte(v byte) *Statement

LitByte renders a byte literal.

func (*Group) LitByteFunc added in v0.13.0 

func (g *Group) LitByteFunc(f func() byte) *Statement

LitByteFunc renders a byte literal. LitByteFunc generates the value to render by executing the provided function.

func (*Group) LitFunc 

func (g *Group) LitFunc(f func() interface{}) *Statement

LitFunc renders a literal. LitFunc generates the value to render by executing the provided function. LitFunc supports only built-in types (bool, string, int, complex128, float64, float32, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, uintptr and complex64). Returning any other type will panic.

func (*Group) LitRune added in v0.13.0 

func (g *Group) LitRune(v rune) *Statement

LitRune renders a rune literal.

func (*Group) LitRuneFunc added in v0.13.0 

func (g *Group) LitRuneFunc(f func() rune) *Statement

LitRuneFunc renders a rune literal. LitRuneFunc generates the value to render by executing the provided function.

func (*Group) Make 

func (g *Group) Make(args ...Code) *Statement

Make renders the make built-in function. The final parameter of the make function is optional, so it is represented by a variadic parameter list.

func (*Group) Map 

func (g *Group) Map(typ Code) *Statement

Map renders the keyword followed by a single item enclosed by square brackets. Use for map definitions.

func (*Group) New 

func (g *Group) New(typ Code) *Statement

New renders the new built-in function.

func (*Group) Nil 

func (g *Group) Nil() *Statement

Nil renders the nil identifier.

func (*Group) Null 

func (g *Group) Null() *Statement

Null adds a null item. Null items render nothing and are not followed by a separator in lists.

func (*Group) Op 

func (g *Group) Op(op string) *Statement

Op renders the provided operator / token.

func (*Group) Panic 

func (g *Group) Panic(v Code) *Statement

Panic renders the panic built-in function.

func (*Group) Params 

func (g *Group) Params(params ...Code) *Statement

Params renders a comma separated list enclosed by parenthesis. Use for function parameters and method receivers.

func (*Group) ParamsFunc 

func (g *Group) ParamsFunc(f func(*Group)) *Statement

ParamsFunc renders a comma separated list enclosed by parenthesis. Use for function parameters and method receivers.

func (*Group) Parens 

func (g *Group) Parens(item Code) *Statement

Parens renders a single item in parenthesis. Use for type conversion or to specify evaluation order.

func (*Group) Print 

func (g *Group) Print(args ...Code) *Statement

Print renders the print built-in function.

func (*Group) PrintFunc added in v0.9.1 

func (g *Group) PrintFunc(f func(*Group)) *Statement

PrintFunc renders the print built-in function.

func (*Group) Println 

func (g *Group) Println(args ...Code) *Statement

Println renders the println built-in function.

func (*Group) PrintlnFunc added in v0.9.1 

func (g *Group) PrintlnFunc(f func(*Group)) *Statement

PrintlnFunc renders the println built-in function.

func (*Group) Qual 

func (g *Group) Qual(path, name string) *Statement

Qual renders a qualified identifier. Imports are automatically added when used with a File. If the path matches the local path, the package name is omitted. If package names conflict they are automatically renamed. Note that it is not possible to reliably determine the package name given an arbitrary package path, so a sensible name is guessed from the path and added as an alias. The names of all standard library packages are known so these do not need to be aliased. If more control is needed of the aliases, see File.ImportName(#importname) or File.ImportAlias(#importalias).

func (*Group) Range 

func (g *Group) Range() *Statement

Range renders the range keyword.

func (*Group) Real 

func (g *Group) Real(c Code) *Statement

Real renders the real built-in function.

func (*Group) Recover 

func (g *Group) Recover() *Statement

Recover renders the recover built-in function.

func (*Group) Render added in v0.15.0 

func (g *Group) Render(writer io.Writer) error

Render renders the Group to the provided writer.

func (*Group) RenderWithFile added in v1.3.0 

func (g *Group) RenderWithFile(writer io.Writer, file *File) error

RenderWithFile renders the Group to the provided writer, using imports from the provided file.

func (*Group) Return 

func (g *Group) Return(results ...Code) *Statement

Return renders the keyword followed by a comma separated list.

func (*Group) ReturnFunc 

func (g *Group) ReturnFunc(f func(*Group)) *Statement

ReturnFunc renders the keyword followed by a comma separated list.

func (*Group) Rune 

func (g *Group) Rune() *Statement

Rune renders the rune identifier.

func (*Group) Select 

func (g *Group) Select() *Statement

Select renders the select keyword.

func (*Group) String 

func (g *Group) String() *Statement

String renders the string identifier.

func (*Group) Struct 

func (g *Group) Struct(fields ...Code) *Statement

Struct renders the keyword followed by a field list enclosed by curly braces.

func (*Group) StructFunc added in v0.9.3 

func (g *Group) StructFunc(f func(*Group)) *Statement

StructFunc renders the keyword followed by a field list enclosed by curly braces.

func (*Group) Switch 

func (g *Group) Switch(conditions ...Code) *Statement

Switch renders the keyword followed by a semicolon separated list.

func (*Group) SwitchFunc 

func (g *Group) SwitchFunc(f func(*Group)) *Statement

SwitchFunc renders the keyword followed by a semicolon separated list.

func (*Group) Tag 

func (g *Group) Tag(items map[string]string) *Statement

Tag renders a struct tag

func (*Group) True 

func (g *Group) True() *Statement

True renders the true identifier.

func (*Group) Type 

func (g *Group) Type() *Statement

Type renders the type keyword.

func (*Group) Uint 

func (g *Group) Uint() *Statement

Uint renders the uint identifier.

func (*Group) Uint16 

func (g *Group) Uint16() *Statement

Uint16 renders the uint16 identifier.

func (*Group) Uint32 

func (g *Group) Uint32() *Statement

Uint32 renders the uint32 identifier.

func (*Group) Uint64 

func (g *Group) Uint64() *Statement

Uint64 renders the uint64 identifier.

func (*Group) Uint8 

func (g *Group) Uint8() *Statement

Uint8 renders the uint8 identifier.

func (*Group) Uintptr 

func (g *Group) Uintptr() *Statement

Uintptr renders the uintptr identifier.

func (*Group) Values 

func (g *Group) Values(values ...Code) *Statement

Values renders a comma separated list enclosed by curly braces. Use for slice or composite literals.

func (*Group) ValuesFunc 

func (g *Group) ValuesFunc(f func(*Group)) *Statement

ValuesFunc renders a comma separated list enclosed by curly braces. Use for slice or composite literals.

func (*Group) Var 

func (g *Group) Var() *Statement

Var renders the var keyword.

type Options added in v0.19.0 

type Options struct {
	Open      string
	Close     string
	Separator string
	Multi     bool
}

Options specifies options for the Custom method

type Statement 

type Statement []Code

Statement represents a simple list of code items. When rendered the items are separated by spaces.

func Add 

func Add(code ...Code) *Statement

Add appends the provided items to the statement.

Example 
ptr := Op("*")
c := Id("a").Op("=").Add(ptr).Id("b")
fmt.Printf("%#v", c)

Output:

a = *b
Example (Var) 
a := Id("a")
i := Int()
c := Var().Add(a, i)
fmt.Printf("%#v", c)

Output:

var a int

func Append 

func Append(args ...Code) *Statement

Append renders the append built-in function.

Example 
c := Append(Id("a"), Id("b"))
fmt.Printf("%#v", c)

Output:

append(a, b)
Example (More) 
c := Id("a").Op("=").Append(Id("a"), Id("b").Op("..."))
fmt.Printf("%#v", c)

Output:

a = append(a, b...)

func AppendFunc added in v0.9.1 

func AppendFunc(f func(*Group)) *Statement

AppendFunc renders the append built-in function.

func Assert 

func Assert(typ Code) *Statement

Assert renders a period followed by a single item enclosed by parenthesis. Use for type assertions.

Example 
c := List(Id("b"), Id("ok")).Op(":=").Id("a").Assert(Bool())
fmt.Printf("%#v", c)

Output:

b, ok := a.(bool)

func Block 

func Block(statements ...Code) *Statement

Block renders a statement list enclosed by curly braces. Use for code blocks. A special case applies when used directly after Case or Default, where the braces are omitted. This allows use in switch and select statements.

Example 
c := Func().Id("foo").Params().String().Block(
	Id("a").Op("=").Id("b"),
	Id("b").Op("++"),
	Return(Id("b")),
)
fmt.Printf("%#v", c)

Output:

func foo() string {
	a = b
	b++
	return b
}
Example (Case) 
c := Select().Block(
	Case(Op("<-").Id("done")).Block(
		Return(Nil()),
	),
	Case(List(Err(), Id("open")).Op(":=").Op("<-").Id("fail")).Block(
		If(Op("!").Id("open")).Block(
			Return(Err()),
		),
	),
)
fmt.Printf("%#v", c)

Output:

select {
case <-done:
	return nil
case err, open := <-fail:
	if !open {
		return err
	}
}
Example (Complex) 
collection := func(name string, key Code, value Code) *Statement {
	if key == nil {
		// slice
		return Var().Id(name).Index().Add(value)
	} else {
		// map
		return Var().Id(name).Map(key).Add(value)
	}
}
c := Func().Id("main").Params().Block(
	collection("foo", nil, String()),
	collection("bar", String(), Int()),
)
fmt.Printf("%#v", c)

Output:

func main() {
	var foo []string
	var bar map[string]int
}
Example (If) 
c := If(Id("a").Op(">").Lit(10)).Block(
	Id("a").Op("=").Id("a").Op("/").Lit(2),
)
fmt.Printf("%#v", c)

Output:

if a > 10 {
	a = a / 2
}

func BlockFunc 

func BlockFunc(f func(*Group)) *Statement

BlockFunc renders a statement list enclosed by curly braces. Use for code blocks. A special case applies when used directly after Case or Default, where the braces are omitted. This allows use in switch and select statements.

Example 
increment := true
name := "a"
c := Func().Id("a").Params().BlockFunc(func(g *Group) {
	g.Id(name).Op("=").Lit(1)
	if increment {
		g.Id(name).Op("++")
	} else {
		g.Id(name).Op("--")
	}
})
fmt.Printf("%#v", c)

Output:

func a() {
	a = 1
	a++
}
Example (Case) 
preventExitOnError := true
c := Select().Block(
	Case(Op("<-").Id("done")).Block(
		Return(Nil()),
	),
	Case(Err().Op(":=").Op("<-").Id("fail")).BlockFunc(func(g *Group) {
		if !preventExitOnError {
			g.Return(Err())
		} else {
			g.Qual("fmt", "Println").Call(Err())
		}
	}),
)
fmt.Printf("%#v", c)

Output:

select {
case <-done:
	return nil
case err := <-fail:
	fmt.Println(err)
}

func Bool 

func Bool() *Statement

Bool renders the bool identifier.

Example 
c := Var().Id("b").Bool()
fmt.Printf("%#v", c)

Output:

var b bool

func Break 

func Break() *Statement

Break renders the break keyword.

Example 
c := For(
	Id("i").Op(":=").Lit(0),
	Id("i").Op("<").Lit(10),
	Id("i").Op("++"),
).Block(
	If(Id("i").Op(">").Lit(5)).Block(
		Break(),
	),
)
fmt.Printf("%#v", c)

Output:

for i := 0; i < 10; i++ {
	if i > 5 {
		break
	}
}

func Byte 

func Byte() *Statement

Byte renders the byte identifier.

Example 
c := Id("b").Op(":=").Id("a").Assert(Byte())
fmt.Printf("%#v", c)

Output:

b := a.(byte)

func Call 

func Call(params ...Code) *Statement

Call renders a comma separated list enclosed by parenthesis. Use for function calls.

Example 
c := Qual("fmt", "Printf").Call(
	Lit("%#v: %T\n"),
	Id("a"),
	Id("b"),
)
fmt.Printf("%#v", c)

Output:

fmt.Printf("%#v: %T\n", a, b)
Example (Fmt) 
c := Id("a").Call(Lit("b"))
fmt.Printf("%#v", c)

Output:

a("b")

func CallFunc 

func CallFunc(f func(*Group)) *Statement

CallFunc renders a comma separated list enclosed by parenthesis. Use for function calls.

Example 
f := func(name string, second string) {
	c := Id("foo").CallFunc(func(g *Group) {
		g.Id(name)
		if second != "" {
			g.Lit(second)
		}
	})
	fmt.Printf("%#v\n", c)
}
f("a", "b")
f("c", "")

Output:

foo(a, "b")
foo(c)

func Cap 

func Cap(v Code) *Statement

Cap renders the cap built-in function.

Example 
c := Id("i").Op(":=").Cap(Id("v"))
fmt.Printf("%#v", c)

Output:

i := cap(v)

func Case 

func Case(cases ...Code) *Statement

Case renders the keyword followed by a comma separated list.

Example 
c := Switch(Id("person")).Block(
	Case(Id("John"), Id("Peter")).Block(
		Return(Lit("male")),
	),
	Case(Id("Gill")).Block(
		Return(Lit("female")),
	),
)
fmt.Printf("%#v", c)

Output:

switch person {
case John, Peter:
	return "male"
case Gill:
	return "female"
}

func CaseFunc 

func CaseFunc(f func(*Group)) *Statement

CaseFunc renders the keyword followed by a comma separated list.

Example 
samIsMale := false
c := Switch(Id("person")).Block(
	CaseFunc(func(g *Group) {
		g.Id("John")
		g.Id("Peter")
		if samIsMale {
			g.Id("Sam")
		}
	}).Block(
		Return(Lit("male")),
	),
	CaseFunc(func(g *Group) {
		g.Id("Gill")
		if !samIsMale {
			g.Id("Sam")
		}
	}).Block(
		Return(Lit("female")),
	),
)
fmt.Printf("%#v", c)

Output:

switch person {
case John, Peter:
	return "male"
case Gill, Sam:
	return "female"
}

func Chan 

func Chan() *Statement

Chan renders the chan keyword.

Example 
c := Func().Id("init").Params().Block(
	Id("c").Op(":=").Make(Chan().Qual("os", "Signal"), Lit(1)),
	Qual("os/signal", "Notify").Call(Id("c"), Qual("os", "Interrupt")),
	Qual("os/signal", "Notify").Call(Id("c"), Qual("syscall", "SIGTERM")),
	Go().Func().Params().Block(
		Op("<-").Id("c"),
		Id("cancel").Call(),
	).Call(),
)
fmt.Printf("%#v", c)

Output:

func init() {
	c := make(chan os.Signal, 1)
	signal.Notify(c, os.Interrupt)
	signal.Notify(c, syscall.SIGTERM)
	go func() {
		<-c
		cancel()
	}()
}

func Close 

func Close(c Code) *Statement

Close renders the close built-in function.

Example 
c := Block(
	Id("ch").Op(":=").Make(Chan().Struct()),
	Go().Func().Params().Block(
		Op("<-").Id("ch"),
		Qual("fmt", "Println").Call(Lit("done.")),
	).Call(),
	Close(Id("ch")),
)
fmt.Printf("%#v", c)

Output:

{
	ch := make(chan struct{})
	go func() {
		<-ch
		fmt.Println("done.")
	}()
	close(ch)
}

func Comment 

func Comment(str string) *Statement

Comment adds a comment. If the provided string contains a newline, the comment is formatted in multiline style. If the comment string starts with "//" or "/*", the automatic formatting is disabled and the string is rendered directly.

Example 
f := NewFile("a")
f.Comment("Foo returns the string \"foo\"")
f.Func().Id("Foo").Params().String().Block(
	Return(Lit("foo")).Comment("return the string foo"),
)
fmt.Printf("%#v", f)

Output:

package a

// Foo returns the string "foo"
func Foo() string {
	return "foo" // return the string foo
}
Example (Formatting_disabled) 
c := Id("foo").Call(Comment("/* inline */")).Comment("//no-space")
fmt.Printf("%#v", c)

Output:

foo( /* inline */ ) //no-space
Example (Multiline) 
c := Comment("a\nb")
fmt.Printf("%#v", c)

Output:

/*
a
b
*/

func Commentf 

func Commentf(format string, a ...interface{}) *Statement

Commentf adds a comment, using a format string and a list of parameters. If the provided string contains a newline, the comment is formatted in multiline style. If the comment string starts with "//" or "/*", the automatic formatting is disabled and the string is rendered directly.

Example 
name := "foo"
val := "bar"
c := Id(name).Op(":=").Lit(val).Commentf("%s is the string \"%s\"", name, val)
fmt.Printf("%#v", c)

Output:

foo := "bar" // foo is the string "bar"

func Complex 

func Complex(r Code, i Code) *Statement

Complex renders the complex built-in function.

Example 
c := Func().Id("main").Params().Block(
	Id("c1").Op(":=").Lit(1+3.75i),
	Id("c2").Op(":=").Complex(Lit(1), Lit(3.75)),
	Qual("fmt", "Println").Call(Id("c1").Op("==").Id("c2")),
)
fmt.Printf("%#v", c)

Output:

func main() {
	c1 := (1 + 3.75i)
	c2 := complex(1, 3.75)
	fmt.Println(c1 == c2)
}

func Complex128 

func Complex128() *Statement

Complex128 renders the complex128 identifier.

Example 
c := Func().Id("main").Params().Block(
	Var().Id("c").Complex128(),
	Id("c").Op("=").Lit(1+2i),
	Qual("fmt", "Println").Call(Id("c")),
)
fmt.Printf("%#v", c)

Output:

func main() {
	var c complex128
	c = (1 + 2i)
	fmt.Println(c)
}

func Complex64 

func Complex64() *Statement

Complex64 renders the complex64 identifier.

Example 
c := Func().Id("main").Params().Block(
	Var().Id("c64").Complex64(),
	Id("c64").Op("=").Complex(Lit(5), Float32().Parens(Lit(2))),
	Qual("fmt", "Printf").Call(Lit("%T\n"), Id("c64")),
)
fmt.Printf("%#v", c)

Output:

func main() {
	var c64 complex64
	c64 = complex(5, float32(2))
	fmt.Printf("%T\n", c64)
}

func Const 

func Const() *Statement

Const renders the const keyword.

func Continue 

func Continue() *Statement

Continue renders the continue keyword.

func Copy 

func Copy(dst Code, src Code) *Statement

Copy renders the copy built-in function.

func Custom added in v0.19.0 

func Custom(options Options, statements ...Code) *Statement

Custom renders a customized statement list. Pass in options to specify multi-line, and tokens for open, close, separator.

Example 
multiLineCall := Options{
	Close:     ")",
	Multi:     true,
	Open:      "(",
	Separator: ",",
}
c := Id("foo").Custom(multiLineCall, Lit("a"), Lit("b"), Lit("c"))
fmt.Printf("%#v", c)

Output:

foo(
	"a",
	"b",
	"c",
)

func CustomFunc added in v0.19.0 

func CustomFunc(options Options, f func(*Group)) *Statement

CustomFunc renders a customized statement list. Pass in options to specify multi-line, and tokens for open, close, separator.

Example 
multiLineCall := Options{
	Close:     ")",
	Multi:     true,
	Open:      "(",
	Separator: ",",
}
c := Id("foo").CustomFunc(multiLineCall, func(g *Group) {
	g.Lit("a")
	g.Lit("b")
	g.Lit("c")
})
fmt.Printf("%#v", c)

Output:

foo(
	"a",
	"b",
	"c",
)

func Default 

func Default() *Statement

Default renders the default keyword.

func Defer 

func Defer() *Statement

Defer renders the defer keyword.

Example 
c := Defer().Id("foo").Call()
fmt.Printf("%#v", c)

Output:

defer foo()

func Defs 

func Defs(definitions ...Code) *Statement

Defs renders a statement list enclosed in parenthesis. Use for definition lists.

Example 
c := Const().Defs(
	Id("a").Op("=").Lit("a"),
	Id("b").Op("=").Lit("b"),
)
fmt.Printf("%#v", c)

Output:

const (
	a = "a"
	b = "b"
)

func DefsFunc 

func DefsFunc(f func(*Group)) *Statement

DefsFunc renders a statement list enclosed in parenthesis. Use for definition lists.

func Delete 

func Delete(m Code, key Code) *Statement

Delete renders the delete built-in function.

func Do 

func Do(f func(*Statement)) *Statement

Do calls the provided function with the statement as a parameter. Use for embedding logic.

Example 
f := func(name string, isMap bool) *Statement {
	return Id(name).Op(":=").Do(func(s *Statement) {
		if isMap {
			s.Map(String()).String()
		} else {
			s.Index().String()
		}
	}).Values()
}
fmt.Printf("%#v\n%#v", f("a", true), f("b", false))

Output:

a := map[string]string{}
b := []string{}

func Dot added in v0.11.0 

func Dot(name string) *Statement

Dot renders a period followed by an identifier. Use for fields and selectors.

Example 
c := Qual("a.b/c", "Foo").Call().Dot("Bar").Index(Lit(0)).Dot("Baz")
fmt.Printf("%#v", c)

Output:

c.Foo().Bar[0].Baz

func Else 

func Else() *Statement

Else renders the else keyword.

func Empty 

func Empty() *Statement

Empty adds an empty item. Empty items render nothing but are followed by a separator in lists.

Example 
c := Id("a").Op(":=").Id("b").Index(Lit(1), Empty())
fmt.Printf("%#v", c)

Output:

a := b[1:]

func Err 

func Err() *Statement

Err renders the err identifier.

Example 
c := If(
	Err().Op(":=").Id("foo").Call(),
	Err().Op("!=").Nil(),
).Block(
	Return(Err()),
)
fmt.Printf("%#v", c)

Output:

if err := foo(); err != nil {
	return err
}

func Error 

func Error() *Statement

Error renders the error identifier.

func Fallthrough 

func Fallthrough() *Statement

Fallthrough renders the fallthrough keyword.

func False 

func False() *Statement

False renders the false identifier.

func Float32 

func Float32() *Statement

Float32 renders the float32 identifier.

func Float64 

func Float64() *Statement

Float64 renders the float64 identifier.

func For 

func For(conditions ...Code) *Statement

For renders the keyword followed by a semicolon separated list.

Example 
c := For(
	Id("i").Op(":=").Lit(0),
	Id("i").Op("<").Lit(10),
	Id("i").Op("++"),
).Block(
	Qual("fmt", "Println").Call(Id("i")),
)
fmt.Printf("%#v", c)

Output:

for i := 0; i < 10; i++ {
	fmt.Println(i)
}

func ForFunc 

func ForFunc(f func(*Group)) *Statement

ForFunc renders the keyword followed by a semicolon separated list.

func Func 

func Func() *Statement

Func renders the func keyword.

Example (Declaration) 
c := Func().Id("a").Params().Block()
fmt.Printf("%#v", c)

Output:

func a() {}
Example (Literal) 
c := Id("a").Op(":=").Func().Params().Block()
fmt.Printf("%#v", c)

Output:

a := func() {}

func Go 

func Go() *Statement

Go renders the go keyword.

func Goto 

func Goto() *Statement

Goto renders the goto keyword.

Example 
c := Goto().Id("Outer")
fmt.Printf("%#v", c)

Output:

goto Outer

func Id 

func Id(name string) *Statement

Id renders an identifier.

Example 
c := If(Id("i").Op("==").Id("j")).Block(
	Return(Id("i")),
)
fmt.Printf("%#v", c)

Output:

if i == j {
	return i
}
Example (Local) 
c := Id("a").Op(":=").Lit(1)
fmt.Printf("%#v", c)

Output:

a := 1
Example (Remote) 
f := NewFile("main")
f.Func().Id("main").Params().Block(
	Qual("fmt", "Println").Call(
		Lit("Hello, world"),
	),
)
fmt.Printf("%#v", f)

Output:

package main

import "fmt"

func main() {
	fmt.Println("Hello, world")
}
Example (Select) 
c := Id("a").Dot("b").Dot("c").Call()
fmt.Printf("%#v", c)

Output:

a.b.c()

func If 

func If(conditions ...Code) *Statement

If renders the keyword followed by a semicolon separated list.

Example 
c := If(
	Err().Op(":=").Id("a").Call(),
	Err().Op("!=").Nil(),
).Block(
	Return(Err()),
)
fmt.Printf("%#v", c)

Output:

if err := a(); err != nil {
	return err
}

func IfFunc 

func IfFunc(f func(*Group)) *Statement

IfFunc renders the keyword followed by a semicolon separated list.

func Imag 

func Imag(c Code) *Statement

Imag renders the imag built-in function.

func Index 

func Index(items ...Code) *Statement

Index renders a colon separated list enclosed by square brackets. Use for array / slice indexes and definitions.

Example 
c := Var().Id("a").Index().String()
fmt.Printf("%#v", c)

Output:

var a []string
Example (Empty) 
c := Id("a").Op(":=").Id("b").Index(Lit(1), Empty())
fmt.Printf("%#v", c)

Output:

a := b[1:]
Example (Index) 
c := Id("a").Op(":=").Id("b").Index(Lit(0), Lit(1))
fmt.Printf("%#v", c)

Output:

a := b[0:1]

func IndexFunc 

func IndexFunc(f func(*Group)) *Statement

IndexFunc renders a colon separated list enclosed by square brackets. Use for array / slice indexes and definitions.

func Int 

func Int() *Statement

Int renders the int identifier.

func Int16 

func Int16() *Statement

Int16 renders the int16 identifier.

func Int32 

func Int32() *Statement

Int32 renders the int32 identifier.

func Int64 

func Int64() *Statement

Int64 renders the int64 identifier.

func Int8 

func Int8() *Statement

Int8 renders the int8 identifier.

func Interface 

func Interface(methods ...Code) *Statement

Interface renders the keyword followed by a method list enclosed by curly braces.

Example 
c := Type().Id("a").Interface(
	Id("b").Params().String(),
)
fmt.Printf("%#v", c)

Output:

type a interface {
	b() string
}
Example (Empty) 
c := Var().Id("a").Interface()
fmt.Printf("%#v", c)

Output:

var a interface{}

func InterfaceFunc 

func InterfaceFunc(f func(*Group)) *Statement

InterfaceFunc renders the keyword followed by a method list enclosed by curly braces.

func Iota 

func Iota() *Statement

Iota renders the iota identifier.

func Len 

func Len(v Code) *Statement

Len renders the len built-in function.

func Line 

func Line() *Statement

Line inserts a blank line.

func List 

func List(items ...Code) *Statement

List renders a comma separated list. Use for multiple return functions.

Example 
c := List(Id("a"), Err()).Op(":=").Id("b").Call()
fmt.Printf("%#v", c)

Output:

a, err := b()

func ListFunc 

func ListFunc(f func(*Group)) *Statement

ListFunc renders a comma separated list. Use for multiple return functions.

func Lit 

func Lit(v interface{}) *Statement

Lit renders a literal. Lit supports only built-in types (bool, string, int, complex128, float64, float32, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, uintptr and complex64). Passing any other type will panic.

Example 
c := Id("a").Op(":=").Lit("a")
fmt.Printf("%#v", c)

Output:

a := "a"
Example (Bool_false) 
c := Lit(false)
fmt.Printf("%#v", c)

Output:

false
Example (Bool_true) 
c := Lit(true)
fmt.Printf("%#v", c)

Output:

true
Example (Byte) 
// Lit can't tell the difference between byte and uint8. Use LitByte to
// render byte literals.
c := Lit(byte(0x1))
fmt.Printf("%#v", c)

Output:

uint8(0x1)
Example (Complex128) 
c := Lit(0 + 0i)
fmt.Printf("%#v", c)

Output:

(0 + 0i)
Example (Complex64) 
c := Lit(complex64(0 + 0i))
fmt.Printf("%#v", c)

Output:

complex64(0 + 0i)
Example (Float) 
c := Id("a").Op(":=").Lit(1.5)
fmt.Printf("%#v", c)

Output:

a := 1.5
Example (Float32) 
c := Lit(float32(1))
fmt.Printf("%#v", c)

Output:

float32(1)
Example (Float64_negative) 
c := Lit(-0.1)
fmt.Printf("%#v", c)

Output:

-0.1
Example (Float64_negative_whole) 
c := Lit(-1.0)
fmt.Printf("%#v", c)

Output:

-1.0
Example (Float64_one_point_zero) 
c := Lit(1.0)
fmt.Printf("%#v", c)

Output:

1.0
Example (Float64_zero) 
c := Lit(0.0)
fmt.Printf("%#v", c)

Output:

0.0
Example (Int) 
c := Lit(1)
fmt.Printf("%#v", c)

Output:

1
Example (Int16) 
c := Lit(int16(1))
fmt.Printf("%#v", c)

Output:

int16(1)
Example (Int32) 
c := Lit(int32(1))
fmt.Printf("%#v", c)

Output:

int32(1)
Example (Int64) 
c := Lit(int64(1))
fmt.Printf("%#v", c)

Output:

int64(1)
Example (Int8) 
c := Lit(int8(1))
fmt.Printf("%#v", c)

Output:

int8(1)
Example (Rune) 
// Lit can't tell the difference between rune and int32. Use LitRune to
// render rune literals.
c := Lit('x')
fmt.Printf("%#v", c)

Output:

int32(120)
Example (String) 
c := Lit("foo")
fmt.Printf("%#v", c)

Output:

"foo"
Example (Uint) 
c := Lit(uint(0x1))
fmt.Printf("%#v", c)

Output:

uint(0x1)
Example (Uint16) 
c := Lit(uint16(0x1))
fmt.Printf("%#v", c)

Output:

uint16(0x1)
Example (Uint32) 
c := Lit(uint32(0x1))
fmt.Printf("%#v", c)

Output:

uint32(0x1)
Example (Uint64) 
c := Lit(uint64(0x1))
fmt.Printf("%#v", c)

Output:

uint64(0x1)
Example (Uint8) 
c := Lit(uint8(0x1))
fmt.Printf("%#v", c)

Output:

uint8(0x1)
Example (Uintptr) 
c := Lit(uintptr(0x1))
fmt.Printf("%#v", c)

Output:

uintptr(0x1)

func LitByte added in v0.13.0 

func LitByte(v byte) *Statement

LitByte renders a byte literal.

Example 
c := LitByte(byte(1))
fmt.Printf("%#v", c)

Output:

byte(0x1)

func LitByteFunc added in v0.13.0 

func LitByteFunc(f func() byte) *Statement

LitByteFunc renders a byte literal. LitByteFunc generates the value to render by executing the provided function.

Example 
c := LitByteFunc(func() byte {
	return byte(2)
})
fmt.Printf("%#v", c)

Output:

byte(0x2)

func LitFunc 

func LitFunc(f func() interface{}) *Statement

LitFunc renders a literal. LitFunc generates the value to render by executing the provided function. LitFunc supports only built-in types (bool, string, int, complex128, float64, float32, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, uintptr and complex64). Returning any other type will panic.

Example 
c := Id("a").Op(":=").LitFunc(func() interface{} { return 1 + 1 })
fmt.Printf("%#v", c)

Output:

a := 2

func LitRune added in v0.13.0 

func LitRune(v rune) *Statement

LitRune renders a rune literal.

Example 
c := LitRune('x')
fmt.Printf("%#v", c)

Output:

'x'

func LitRuneFunc added in v0.13.0 

func LitRuneFunc(f func() rune) *Statement

LitRuneFunc renders a rune literal. LitRuneFunc generates the value to render by executing the provided function.

Example 
c := LitRuneFunc(func() rune {
	return '\t'
})
fmt.Printf("%#v", c)

Output:

'\t'

func Make 

func Make(args ...Code) *Statement

Make renders the make built-in function. The final parameter of the make function is optional, so it is represented by a variadic parameter list.

func Map 

func Map(typ Code) *Statement

Map renders the keyword followed by a single item enclosed by square brackets. Use for map definitions.

Example 
c := Id("a").Op(":=").Map(String()).String().Values()
fmt.Printf("%#v", c)

Output:

a := map[string]string{}

func New 

func New(typ Code) *Statement

New renders the new built-in function.

func Nil 

func Nil() *Statement

Nil renders the nil identifier.

func Null 

func Null() *Statement

Null adds a null item. Null items render nothing and are not followed by a separator in lists.

Example (And_nil) 
c := Func().Id("foo").Params(
	nil,
	Id("s").String(),
	Null(),
	Id("i").Int(),
).Block()
fmt.Printf("%#v", c)

Output:

func foo(s string, i int) {}
Example (Index) 
c := Id("a").Op(":=").Id("b").Index(Lit(1), Null())
fmt.Printf("%#v", c)

Output:

a := b[1]

func Op 

func Op(op string) *Statement

Op renders the provided operator / token.

Example 
c := Id("a").Op(":=").Id("b").Call()
fmt.Printf("%#v", c)

Output:

a := b()
Example (Complex_conditions) 
c := If(Parens(Id("a").Op("||").Id("b")).Op("&&").Id("c")).Block()
fmt.Printf("%#v", c)

Output:

if (a || b) && c {
}
Example (Star) 
c := Id("a").Op("=").Op("*").Id("b")
fmt.Printf("%#v", c)

Output:

a = *b
Example (Variadic) 
c := Id("a").Call(Id("b").Op("..."))
fmt.Printf("%#v", c)

Output:

a(b...)

func Panic 

func Panic(v Code) *Statement

Panic renders the panic built-in function.

func Params 

func Params(params ...Code) *Statement

Params renders a comma separated list enclosed by parenthesis. Use for function parameters and method receivers.

Example 
c := Func().Params(
	Id("a").Id("A"),
).Id("foo").Params(
	Id("b"),
	Id("c").String(),
).String().Block(
	Return(Id("b").Op("+").Id("c")),
)
fmt.Printf("%#v", c)

Output:

func (a A) foo(b, c string) string {
	return b + c
}

func ParamsFunc 

func ParamsFunc(f func(*Group)) *Statement

ParamsFunc renders a comma separated list enclosed by parenthesis. Use for function parameters and method receivers.

func Parens 

func Parens(item Code) *Statement

Parens renders a single item in parenthesis. Use for type conversion or to specify evaluation order.

Example 
c := Id("b").Op(":=").Index().Byte().Parens(Id("s"))
fmt.Printf("%#v", c)

Output:

b := []byte(s)
Example (Order) 
c := Id("a").Op("/").Parens(Id("b").Op("+").Id("c"))
fmt.Printf("%#v", c)

Output:

a / (b + c)

func Print 

func Print(args ...Code) *Statement

Print renders the print built-in function.

func PrintFunc added in v0.9.1 

func PrintFunc(f func(*Group)) *Statement

PrintFunc renders the print built-in function.

func Println 

func Println(args ...Code) *Statement

Println renders the println built-in function.

func PrintlnFunc added in v0.9.1 

func PrintlnFunc(f func(*Group)) *Statement

PrintlnFunc renders the println built-in function.

func Qual 

func Qual(path, name string) *Statement

Qual renders a qualified identifier. Imports are automatically added when used with a File. If the path matches the local path, the package name is omitted. If package names conflict they are automatically renamed. Note that it is not possible to reliably determine the package name given an arbitrary package path, so a sensible name is guessed from the path and added as an alias. The names of all standard library packages are known so these do not need to be aliased. If more control is needed of the aliases, see File.ImportName(#importname) or File.ImportAlias(#importalias).

Example 
c := Qual("encoding/gob", "NewEncoder").Call()
fmt.Printf("%#v", c)

Output:

gob.NewEncoder()
Example (File) 
f := NewFilePath("a.b/c")
f.Func().Id("init").Params().Block(
	Qual("a.b/c", "Foo").Call().Comment("Local package - name is omitted."),
	Qual("d.e/f", "Bar").Call().Comment("Import is automatically added."),
	Qual("g.h/f", "Baz").Call().Comment("Colliding package name is renamed."),
)
fmt.Printf("%#v", f)

Output:

package c

import (
	f "d.e/f"
	f1 "g.h/f"
)

func init() {
	Foo()    // Local package - name is omitted.
	f.Bar()  // Import is automatically added.
	f1.Baz() // Colliding package name is renamed.
}
Example (Local) 
f := NewFilePath("a.b/c")
f.Func().Id("main").Params().Block(
	Qual("a.b/c", "D").Call(),
)
fmt.Printf("%#v", f)

Output:

package c

func main() {
	D()
}

func Range 

func Range() *Statement

Range renders the range keyword.

func Real 

func Real(c Code) *Statement

Real renders the real built-in function.

func Recover 

func Recover() *Statement

Recover renders the recover built-in function.

func Return 

func Return(results ...Code) *Statement

Return renders the keyword followed by a comma separated list.

Example 
c := Return(Id("a"), Id("b"))
fmt.Printf("%#v", c)

Output:

return a, b

func ReturnFunc 

func ReturnFunc(f func(*Group)) *Statement

ReturnFunc renders the keyword followed by a comma separated list.

func Rune 

func Rune() *Statement

Rune renders the rune identifier.

func Select 

func Select() *Statement

Select renders the select keyword.

func String 

func String() *Statement

String renders the string identifier.

func Struct 

func Struct(fields ...Code) *Statement

Struct renders the keyword followed by a field list enclosed by curly braces.

Example 
c := Type().Id("foo").Struct(
	List(Id("x"), Id("y")).Int(),
	Id("u").Float32(),
)
fmt.Printf("%#v", c)

Output:

type foo struct {
	x, y int
	u    float32
}
Example (Empty) 
c := Id("c").Op(":=").Make(Chan().Struct())
fmt.Printf("%#v", c)

Output:

c := make(chan struct{})

func StructFunc added in v0.9.3 

func StructFunc(f func(*Group)) *Statement

StructFunc renders the keyword followed by a field list enclosed by curly braces.

func Switch 

func Switch(conditions ...Code) *Statement

Switch renders the keyword followed by a semicolon separated list.

Example 
c := Switch(Id("value").Dot("Kind").Call()).Block(
	Case(Qual("reflect", "Float32"), Qual("reflect", "Float64")).Block(
		Return(Lit("float")),
	),
	Case(Qual("reflect", "Bool")).Block(
		Return(Lit("bool")),
	),
	Case(Qual("reflect", "Uintptr")).Block(
		Fallthrough(),
	),
	Default().Block(
		Return(Lit("none")),
	),
)
fmt.Printf("%#v", c)

Output:

switch value.Kind() {
case reflect.Float32, reflect.Float64:
	return "float"
case reflect.Bool:
	return "bool"
case reflect.Uintptr:
	fallthrough
default:
	return "none"
}

func SwitchFunc 

func SwitchFunc(f func(*Group)) *Statement

SwitchFunc renders the keyword followed by a semicolon separated list.

func Tag 

func Tag(items map[string]string) *Statement

Tag renders a struct tag

Example 
c := Type().Id("foo").Struct(
	Id("A").String().Tag(map[string]string{"json": "a"}),
	Id("B").Int().Tag(map[string]string{"json": "b", "bar": "baz"}),
)
fmt.Printf("%#v", c)

Output:

type foo struct {
	A string `json:"a"`
	B int    `bar:"baz" json:"b"`
}

func True 

func True() *Statement

True renders the true identifier.

func Type 

func Type() *Statement

Type renders the type keyword.

func Uint 

func Uint() *Statement

Uint renders the uint identifier.

func Uint16 

func Uint16() *Statement

Uint16 renders the uint16 identifier.

func Uint32 

func Uint32() *Statement

Uint32 renders the uint32 identifier.

func Uint64 

func Uint64() *Statement

Uint64 renders the uint64 identifier.

func Uint8 

func Uint8() *Statement

Uint8 renders the uint8 identifier.

func Uintptr 

func Uintptr() *Statement

Uintptr renders the uintptr identifier.

func Values 

func Values(values ...Code) *Statement

Values renders a comma separated list enclosed by curly braces. Use for slice or composite literals.

Example 
c := Index().String().Values(Lit("a"), Lit("b"))
fmt.Printf("%#v", c)

Output:

[]string{"a", "b"}
Example (Dict_composite) 
c := Op("&").Id("Person").Values(Dict{
	Id("Age"):  Lit(1),
	Id("Name"): Lit("a"),
})
fmt.Printf("%#v", c)

Output:

&Person{
	Age:  1,
	Name: "a",
}
Example (Dict_multiple) 
c := Map(String()).String().Values(Dict{
	Lit("a"): Lit("b"),
	Lit("c"): Lit("d"),
})
fmt.Printf("%#v", c)

Output:

map[string]string{
	"a": "b",
	"c": "d",
}
Example (Dict_single) 
c := Map(String()).String().Values(Dict{
	Lit("a"): Lit("b"),
})
fmt.Printf("%#v", c)

Output:

map[string]string{"a": "b"}

func ValuesFunc 

func ValuesFunc(f func(*Group)) *Statement

ValuesFunc renders a comma separated list enclosed by curly braces. Use for slice or composite literals.

Example 
c := Id("numbers").Op(":=").Index().Int().ValuesFunc(func(g *Group) {
	for i := 0; i <= 5; i++ {
		g.Lit(i)
	}
})
fmt.Printf("%#v", c)

Output:

numbers := []int{0, 1, 2, 3, 4, 5}

func Var 

func Var() *Statement

Var renders the var keyword.

func (*Statement) Add 

func (s *Statement) Add(code ...Code) *Statement

Add appends the provided items to the statement.

func (*Statement) Append 

func (s *Statement) Append(args ...Code) *Statement

Append renders the append built-in function.

func (*Statement) AppendFunc added in v0.9.1 

func (s *Statement) AppendFunc(f func(*Group)) *Statement

AppendFunc renders the append built-in function.

func (*Statement) Assert 

func (s *Statement) Assert(typ Code) *Statement

Assert renders a period followed by a single item enclosed by parenthesis. Use for type assertions.

func (*Statement) Block 

func (s *Statement) Block(statements ...Code) *Statement

Block renders a statement list enclosed by curly braces. Use for code blocks. A special case applies when used directly after Case or Default, where the braces are omitted. This allows use in switch and select statements.

func (*Statement) BlockFunc 

func (s *Statement) BlockFunc(f func(*Group)) *Statement

BlockFunc renders a statement list enclosed by curly braces. Use for code blocks. A special case applies when used directly after Case or Default, where the braces are omitted. This allows use in switch and select statements.

func (*Statement) Bool 

func (s *Statement) Bool() *Statement

Bool renders the bool identifier.

func (*Statement) Break 

func (s *Statement) Break() *Statement

Break renders the break keyword.

func (*Statement) Byte 

func (s *Statement) Byte() *Statement

Byte renders the byte identifier.

func (*Statement) Call 

func (s *Statement) Call(params ...Code) *Statement

Call renders a comma separated list enclosed by parenthesis. Use for function calls.

func (*Statement) CallFunc 

func (s *Statement) CallFunc(f func(*Group)) *Statement

CallFunc renders a comma separated list enclosed by parenthesis. Use for function calls.

func (*Statement) Cap 

func (s *Statement) Cap(v Code) *Statement

Cap renders the cap built-in function.

func (*Statement) Case 

func (s *Statement) Case(cases ...Code) *Statement

Case renders the keyword followed by a comma separated list.

func (*Statement) CaseFunc 

func (s *Statement) CaseFunc(f func(*Group)) *Statement

CaseFunc renders the keyword followed by a comma separated list.

func (*Statement) Chan 

func (s *Statement) Chan() *Statement

Chan renders the chan keyword.

func (*Statement) Clone 

func (s *Statement) Clone() *Statement

Clone makes a copy of the Statement, so further tokens can be appended without affecting the original.

Example (Broken) 
a := Id("a")
c := Block(
	a.Call(),
	a.Call(),
)
fmt.Printf("%#v", c)

Output:

{
	a()()
	a()()
}
Example (Fixed) 
a := Id("a")
c := Block(
	a.Clone().Call(),
	a.Clone().Call(),
)
fmt.Printf("%#v", c)

Output:

{
	a()
	a()
}

func (*Statement) Close 

func (s *Statement) Close(c Code) *Statement

Close renders the close built-in function.

func (*Statement) Comment 

func (s *Statement) Comment(str string) *Statement

Comment adds a comment. If the provided string contains a newline, the comment is formatted in multiline style. If the comment string starts with "//" or "/*", the automatic formatting is disabled and the string is rendered directly.

func (*Statement) Commentf 

func (s *Statement) Commentf(format string, a ...interface{}) *Statement

Commentf adds a comment, using a format string and a list of parameters. If the provided string contains a newline, the comment is formatted in multiline style. If the comment string starts with "//" or "/*", the automatic formatting is disabled and the string is rendered directly.

func (*Statement) Complex 

func (s *Statement) Complex(r Code, i Code) *Statement

Complex renders the complex built-in function.

func (*Statement) Complex128 

func (s *Statement) Complex128() *Statement

Complex128 renders the complex128 identifier.

func (*Statement) Complex64 

func (s *Statement) Complex64() *Statement

Complex64 renders the complex64 identifier.

func (*Statement) Const 

func (s *Statement) Const() *Statement

Const renders the const keyword.

func (*Statement) Continue 

func (s *Statement) Continue() *Statement

Continue renders the continue keyword.

func (*Statement) Copy 

func (s *Statement) Copy(dst Code, src Code) *Statement

Copy renders the copy built-in function.

func (*Statement) Custom added in v0.19.0 

func (s *Statement) Custom(options Options, statements ...Code) *Statement

Custom renders a customized statement list. Pass in options to specify multi-line, and tokens for open, close, separator.

func (*Statement) CustomFunc added in v0.19.0 

func (s *Statement) CustomFunc(options Options, f func(*Group)) *Statement

CustomFunc renders a customized statement list. Pass in options to specify multi-line, and tokens for open, close, separator.

func (*Statement) Default 

func (s *Statement) Default() *Statement

Default renders the default keyword.

func (*Statement) Defer 

func (s *Statement) Defer() *Statement

Defer renders the defer keyword.

func (*Statement) Defs 

func (s *Statement) Defs(definitions ...Code) *Statement

Defs renders a statement list enclosed in parenthesis. Use for definition lists.

func (*Statement) DefsFunc 

func (s *Statement) DefsFunc(f func(*Group)) *Statement

DefsFunc renders a statement list enclosed in parenthesis. Use for definition lists.

func (*Statement) Delete 

func (s *Statement) Delete(m Code, key Code) *Statement

Delete renders the delete built-in function.

func (*Statement) Do 

func (s *Statement) Do(f func(*Statement)) *Statement

Do calls the provided function with the statement as a parameter. Use for embedding logic.

func (*Statement) Dot added in v0.11.0 

func (s *Statement) Dot(name string) *Statement

Dot renders a period followed by an identifier. Use for fields and selectors.

func (*Statement) Else 

func (s *Statement) Else() *Statement

Else renders the else keyword.

func (*Statement) Empty 

func (s *Statement) Empty() *Statement

Empty adds an empty item. Empty items render nothing but are followed by a separator in lists.

func (*Statement) Err 

func (s *Statement) Err() *Statement

Err renders the err identifier.

func (*Statement) Error 

func (s *Statement) Error() *Statement

Error renders the error identifier.

func (*Statement) Fallthrough 

func (s *Statement) Fallthrough() *Statement

Fallthrough renders the fallthrough keyword.

func (*Statement) False 

func (s *Statement) False() *Statement

False renders the false identifier.

func (*Statement) Float32 

func (s *Statement) Float32() *Statement

Float32 renders the float32 identifier.

func (*Statement) Float64 

func (s *Statement) Float64() *Statement

Float64 renders the float64 identifier.

func (*Statement) For 

func (s *Statement) For(conditions ...Code) *Statement

For renders the keyword followed by a semicolon separated list.

func (*Statement) ForFunc 

func (s *Statement) ForFunc(f func(*Group)) *Statement

ForFunc renders the keyword followed by a semicolon separated list.

func (*Statement) Func 

func (s *Statement) Func() *Statement

Func renders the func keyword.

func (*Statement) Go 

func (s *Statement) Go() *Statement

Go renders the go keyword.

func (*Statement) GoString 

func (s *Statement) GoString() string

GoString renders the Statement for testing. Any error will cause a panic.

func (*Statement) Goto 

func (s *Statement) Goto() *Statement

Goto renders the goto keyword.

func (*Statement) Id 

func (s *Statement) Id(name string) *Statement

Id renders an identifier.

func (*Statement) If 

func (s *Statement) If(conditions ...Code) *Statement

If renders the keyword followed by a semicolon separated list.

func (*Statement) IfFunc 

func (s *Statement) IfFunc(f func(*Group)) *Statement

IfFunc renders the keyword followed by a semicolon separated list.

func (*Statement) Imag 

func (s *Statement) Imag(c Code) *Statement

Imag renders the imag built-in function.

func (*Statement) Index 

func (s *Statement) Index(items ...Code) *Statement

Index renders a colon separated list enclosed by square brackets. Use for array / slice indexes and definitions.

func (*Statement) IndexFunc 

func (s *Statement) IndexFunc(f func(*Group)) *Statement

IndexFunc renders a colon separated list enclosed by square brackets. Use for array / slice indexes and definitions.

func (*Statement) Int 

func (s *Statement) Int() *Statement

Int renders the int identifier.

func (*Statement) Int16 

func (s *Statement) Int16() *Statement

Int16 renders the int16 identifier.

func (*Statement) Int32 

func (s *Statement) Int32() *Statement

Int32 renders the int32 identifier.

func (*Statement) Int64 

func (s *Statement) Int64() *Statement

Int64 renders the int64 identifier.

func (*Statement) Int8 

func (s *Statement) Int8() *Statement

Int8 renders the int8 identifier.

func (*Statement) Interface 

func (s *Statement) Interface(methods ...Code) *Statement

Interface renders the keyword followed by a method list enclosed by curly braces.

func (*Statement) InterfaceFunc 

func (s *Statement) InterfaceFunc(f func(*Group)) *Statement

InterfaceFunc renders the keyword followed by a method list enclosed by curly braces.

func (*Statement) Iota 

func (s *Statement) Iota() *Statement

Iota renders the iota identifier.

func (*Statement) Len 

func (s *Statement) Len(v Code) *Statement

Len renders the len built-in function.

func (*Statement) Line 

func (s *Statement) Line() *Statement

Line inserts a blank line.

func (*Statement) List 

func (s *Statement) List(items ...Code) *Statement

List renders a comma separated list. Use for multiple return functions.

func (*Statement) ListFunc 

func (s *Statement) ListFunc(f func(*Group)) *Statement

ListFunc renders a comma separated list. Use for multiple return functions.

func (*Statement) Lit 

func (s *Statement) Lit(v interface{}) *Statement

Lit renders a literal. Lit supports only built-in types (bool, string, int, complex128, float64, float32, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, uintptr and complex64). Passing any other type will panic.

func (*Statement) LitByte added in v0.13.0 

func (s *Statement) LitByte(v byte) *Statement

LitByte renders a byte literal.

func (*Statement) LitByteFunc added in v0.13.0 

func (s *Statement) LitByteFunc(f func() byte) *Statement

LitByteFunc renders a byte literal. LitByteFunc generates the value to render by executing the provided function.

func (*Statement) LitFunc 

func (s *Statement) LitFunc(f func() interface{}) *Statement

LitFunc renders a literal. LitFunc generates the value to render by executing the provided function. LitFunc supports only built-in types (bool, string, int, complex128, float64, float32, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, uintptr and complex64). Returning any other type will panic.

func (*Statement) LitRune added in v0.13.0 

func (s *Statement) LitRune(v rune) *Statement

LitRune renders a rune literal.

func (*Statement) LitRuneFunc added in v0.13.0 

func (s *Statement) LitRuneFunc(f func() rune) *Statement

LitRuneFunc renders a rune literal. LitRuneFunc generates the value to render by executing the provided function.

func (*Statement) Make 

func (s *Statement) Make(args ...Code) *Statement

Make renders the make built-in function. The final parameter of the make function is optional, so it is represented by a variadic parameter list.

func (*Statement) Map 

func (s *Statement) Map(typ Code) *Statement

Map renders the keyword followed by a single item enclosed by square brackets. Use for map definitions.

func (*Statement) New 

func (s *Statement) New(typ Code) *Statement

New renders the new built-in function.

func (*Statement) Nil 

func (s *Statement) Nil() *Statement

Nil renders the nil identifier.

func (*Statement) Null 

func (s *Statement) Null() *Statement

Null adds a null item. Null items render nothing and are not followed by a separator in lists.

func (*Statement) Op 

func (s *Statement) Op(op string) *Statement

Op renders the provided operator / token.

func (*Statement) Panic 

func (s *Statement) Panic(v Code) *Statement

Panic renders the panic built-in function.

func (*Statement) Params 

func (s *Statement) Params(params ...Code) *Statement

Params renders a comma separated list enclosed by parenthesis. Use for function parameters and method receivers.

func (*Statement) ParamsFunc 

func (s *Statement) ParamsFunc(f func(*Group)) *Statement

ParamsFunc renders a comma separated list enclosed by parenthesis. Use for function parameters and method receivers.

func (*Statement) Parens 

func (s *Statement) Parens(item Code) *Statement

Parens renders a single item in parenthesis. Use for type conversion or to specify evaluation order.

func (*Statement) Print 

func (s *Statement) Print(args ...Code) *Statement

Print renders the print built-in function.

func (*Statement) PrintFunc added in v0.9.1 

func (s *Statement) PrintFunc(f func(*Group)) *Statement

PrintFunc renders the print built-in function.

func (*Statement) Println 

func (s *Statement) Println(args ...Code) *Statement

Println renders the println built-in function.

func (*Statement) PrintlnFunc added in v0.9.1 

func (s *Statement) PrintlnFunc(f func(*Group)) *Statement

PrintlnFunc renders the println built-in function.

func (*Statement) Qual 

func (s *Statement) Qual(path, name string) *Statement

Qual renders a qualified identifier. Imports are automatically added when used with a File. If the path matches the local path, the package name is omitted. If package names conflict they are automatically renamed. Note that it is not possible to reliably determine the package name given an arbitrary package path, so a sensible name is guessed from the path and added as an alias. The names of all standard library packages are known so these do not need to be aliased. If more control is needed of the aliases, see File.ImportName(#importname) or File.ImportAlias(#importalias).

func (*Statement) Range 

func (s *Statement) Range() *Statement

Range renders the range keyword.

func (*Statement) Real 

func (s *Statement) Real(c Code) *Statement

Real renders the real built-in function.

func (*Statement) Recover 

func (s *Statement) Recover() *Statement

Recover renders the recover built-in function.

func (*Statement) Render added in v0.15.0 

func (s *Statement) Render(writer io.Writer) error

Render renders the Statement to the provided writer.

func (*Statement) RenderWithFile added in v1.3.0 

func (s *Statement) RenderWithFile(writer io.Writer, file *File) error

RenderWithFile renders the Statement to the provided writer, using imports from the provided file.

func (*Statement) Return 

func (s *Statement) Return(results ...Code) *Statement

Return renders the keyword followed by a comma separated list.

func (*Statement) ReturnFunc 

func (s *Statement) ReturnFunc(f func(*Group)) *Statement

ReturnFunc renders the keyword followed by a comma separated list.

func (*Statement) Rune 

func (s *Statement) Rune() *Statement

Rune renders the rune identifier.

func (*Statement) Select 

func (s *Statement) Select() *Statement

Select renders the select keyword.

func (*Statement) String 

func (s *Statement) String() *Statement

String renders the string identifier.

func (*Statement) Struct 

func (s *Statement) Struct(fields ...Code) *Statement

Struct renders the keyword followed by a field list enclosed by curly braces.

func (*Statement) StructFunc added in v0.9.3 

func (s *Statement) StructFunc(f func(*Group)) *Statement

StructFunc renders the keyword followed by a field list enclosed by curly braces.

func (*Statement) Switch 

func (s *Statement) Switch(conditions ...Code) *Statement

Switch renders the keyword followed by a semicolon separated list.

func (*Statement) SwitchFunc 

func (s *Statement) SwitchFunc(f func(*Group)) *Statement

SwitchFunc renders the keyword followed by a semicolon separated list.

func (*Statement) Tag 

func (s *Statement) Tag(items map[string]string) *Statement

Tag renders a struct tag

func (*Statement) True 

func (s *Statement) True() *Statement

True renders the true identifier.

func (*Statement) Type 

func (s *Statement) Type() *Statement

Type renders the type keyword.

func (*Statement) Uint 

func (s *Statement) Uint() *Statement

Uint renders the uint identifier.

func (*Statement) Uint16 

func (s *Statement) Uint16() *Statement

Uint16 renders the uint16 identifier.

func (*Statement) Uint32 

func (s *Statement) Uint32() *Statement

Uint32 renders the uint32 identifier.

func (*Statement) Uint64 

func (s *Statement) Uint64() *Statement

Uint64 renders the uint64 identifier.

func (*Statement) Uint8 

func (s *Statement) Uint8() *Statement

Uint8 renders the uint8 identifier.

func (*Statement) Uintptr 

func (s *Statement) Uintptr() *Statement

Uintptr renders the uintptr identifier.

func (*Statement) Values 

func (s *Statement) Values(values ...Code) *Statement

Values renders a comma separated list enclosed by curly braces. Use for slice or composite literals.

func (*Statement) ValuesFunc 

func (s *Statement) ValuesFunc(f func(*Group)) *Statement

ValuesFunc renders a comma separated list enclosed by curly braces. Use for slice or composite literals.

func (*Statement) Var 

func (s *Statement) Var() *Statement

Var renders the var keyword.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.