jen

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",
}

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 "fmt"

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

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.
}

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()
}

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

Output:

a = *b

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

Output:

var a int

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

Output:

append(a, b)

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

Output:

a = append(a, b...)

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

Output:

b, ok := a.(bool)

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
}

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
	}
}

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
}

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
}

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++
}

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)
}

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

Output:

var b bool

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
	}
}

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

Output:

b := a.(byte)

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)

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

Output:

a("b")

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)

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

Output:

i := cap(v)

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"
}

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"
}

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()
	}()
}

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)
}

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
}

c := Id("foo").Call(Comment("/* inline */")).Comment("//no-space")
fmt.Printf("%#v", c)

Output:

foo( /* inline */ ) //no-space

c := Comment("a\nb")
fmt.Printf("%#v", c)

Output:

/*
a
b
*/

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"

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)
}

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)
}

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)
}

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

Output:

defer foo()

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

Output:

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

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{}

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

Output:

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

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

Output:

a := b[1:]

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
}

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)
}

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

Output:

func a() {}

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

Output:

a := func() {}

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

Output:

goto Outer

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

Output:

if i == j {
	return i
}

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

Output:

a := 1

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 "fmt"

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

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

Output:

a.b.c()

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
}

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

Output:

var a []string

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

Output:

a := b[1:]

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

Output:

a := b[0:1]

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

Output:

type a interface {
	b() string
}

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

Output:

var a interface{}

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

Output:

a, err := b()

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

Output:

a := "a"

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

Output:

false

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

Output:

true

// 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)

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

Output:

(0 + 0i)

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

Output:

complex64(0 + 0i)

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

Output:

a := 1.5

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

Output:

float32(1)

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

Output:

-0.1

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

Output:

-1.0

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

Output:

1.0

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

Output:

0.0

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

Output:

1

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

Output:

int16(1)

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

Output:

int32(1)

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

Output:

int64(1)

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

Output:

int8(1)

// 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)

c := Lit("foo")
fmt.Printf("%#v", c)

Output:

"foo"

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

Output:

uint(0x1)

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

Output:

uint16(0x1)

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

Output:

uint32(0x1)

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

Output:

uint64(0x1)

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

Output:

uint8(0x1)

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

Output:

uintptr(0x1)

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

Output:

byte(0x1)

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

Output:

byte(0x2)

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

Output:

a := 2

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

Output:

'x'

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

Output:

'\t'

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

Output:

a := map[string]string{}

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) {}

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

Output:

a := b[1]

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

Output:

a := b()

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

Output:

a = *b

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

Output:

a(b...)

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
}

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

Output:

b := []byte(s)

c := Id("a").Op("/").Parens(Id("b").Op("+").Id("c"))
fmt.Printf("%#v", c)

Output:

a / (b + c)

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

Output:

gob.NewEncoder()

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.
}

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()
}

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

Output:

return a, b

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
}

c := Id("c").Op(":=").Make(Chan().Struct())
fmt.Printf("%#v", c)

Output:

c := make(chan struct{})

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"
}

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"`
}

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

Output:

[]string{"a", "b"}

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

Output:

&Person{
	Age:  1,
	Name: "a",
}

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",
}

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

Output:

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

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}