codegen

filename := "examples/hello/hello.go"
f := NewFile("main", filename)

f.WriteSnippet(
	DeclVar(Var(Slice(String), "lines")),

	Func().Named("main").Do(
		DeclVar(
			Assign(Var(nil, "ch")).By(Call("make", String, Valuer(10))),
		),

		Call("close", Ident("ch")).AsDefer(),

		Call("PipeReadAndPrint", Ident("ch")).AsRoutine(),

		Call("PipePrintAndWrite", Ident("ch"), Ident("lines")),
	),

	Func(Var(ChanRO(String), "ch"), Var(Ellipsis(String), "v")).
		Named("PipePrintAndWrite").
		Do(
			ForRange(Ident("v"), Ident("i"), Ident("_")).Do(
				Call(f.Use("fmt", "Println"), AccessWith(Ident("v"), Ident("i"))),
				Exprer("? <- ?", Ident("ch"), AccessWith(Ident("v"), Ident("i"))),
			),
		),

	Func(Var(ChanRO(String), "ch")).Named("PipeReadAndPrint").Do(
		For(nil, nil, nil).Do(
			Select(
				CaseClause(Define(Ident("s"), Ident("ok")).By(Arrow(Ident("ch")))).Do(
					If(Ident("ok")).Do(
						Call(f.Use("fmt", "Println"), Ident("s")),
					).Else(
						If(Exprer("!ok")).Do(
							Return(),
						),
					),
				),
			),
		),
	),
)

fmt.Println(string(f.Formatted()))

Output:

// This is a generated source file. DO NOT EDIT
// Source: main/hello.go

package main

import "fmt"

var lines []string

func main() {
	var ch = make(string, 10)
	defer close(ch)
	go PipeReadAndPrint(ch)
	PipePrintAndWrite(ch, lines)
}

func PipePrintAndWrite(ch <-chan string, v ...string) {
	for i := range v {
		fmt.Println(v[i])
		ch <- v[i]
	}
}

func PipeReadAndPrint(ch <-chan string) {
	for {
		select {
		case s, ok := <-ch:
			if ok {
				fmt.Println(s)
			} else if !ok {
				return
			}
		}
	}
}

var t = Type("Name")

fmt.Println(string(t.Bytes()))
fmt.Println(string(Chan(t).Bytes()))
fmt.Println(string(Chan(Star(t)).Bytes()))
fmt.Println(string(Array(t, 10).Bytes()))
fmt.Println(string(Array(Star(t), 10).Bytes()))
fmt.Println(string(Slice(t).Bytes()))
fmt.Println(string(Map(Bool, Star(t)).Bytes()))

Output:

Name
chan Name
chan *Name
[10]Name
[10]*Name
[]Name
map[bool]*Name

output(Access(Ident("array"), 10))
output(AccessWith(Ident("array"), Exprer("?-?", Call("len", Ident("array")), Valuer(1))))
output(AccessWith(Ident("array"), Exprer("len(array)-1")))

Output:

array[10]
array[len(array)-1]
array[len(array)-1]

fmt.Println(Stringify(Addr(Ident("i"))))

Output:

&i

fmt.Println(Stringify(Arrow(Ident("ch"))))
fmt.Println(Stringify(Define(Ident("val")).By(Arrow(Ident("ch")))))

Output:

<-ch
val := <-ch

fmt.Println(Stringify(
	Define(
		Ident("a"),
		Ident("b"),
	).By(
		Ident("c"),
		Call("Fn", Valuer(1)),
	)),
)

fmt.Println(Stringify(
	Define(
		Ident("a"),
		Ident("b"),
	).By(
		Ident("c"),
		Call("Fn", Valuer("abc")),
	)),
)

fmt.Println(Stringify(
	DeclVar(
		Var(Int, "a"),
		Assign(Var(String, "a", "b")).By(Call("Fn", Valuer(1))),
	),
))

fmt.Println(Stringify(
	DeclConst(
		Assign(Var(Int, "a")).By(Iota),
		Assign(Ident("b")),
		Assign(Ident("c")),
	),
))

fmt.Println(Stringify(
	DeclType(
		Var(Type("time.Time"), "aliasTime").AsAlias(),
	),
))

Output:

a, b := c, Fn(1)
a, b := c, Fn("abc")
var (
a int
a, b string = Fn(1)
)
const (
a int = iota
b
c
)
type aliasTime = time.Time

fmt.Println(Stringify(Call("NewBuffer", Nil)))

Output:

NewBuffer(nil)

fmt.Println(Stringify(Ref(Ident("bytes"), CallWith(Ident("NewBuffer"), Nil))))

Output:

bytes.NewBuffer(nil)

fmt.Println(Stringify(DeclVar(
	Assign(Ident("a")).By(Casting(Float64, Valuer(0.1))),
	Assign(Ident("b")).By(Casting(Float32, Ident("a"))),
)))

Output:

var (
a = float64(0.1)
b = float32(a)
)

clauses = append(clauses,
	CaseClause(Valuer(1), Valuer(2)),
	CaseClause(Arrow(Ref(Ident("time"), Call("After")))),
	CaseClause().Do(Return(Ident("a"), Call("Fn", Valuer(1)))),
)

for _, c := range clauses {
	fmt.Println(Stringify(c))
}

Output:

case 1, 2:
case <-time.After():
default:
return a, Fn(1)

fmt.Println(Stringify(DeclVar(
	Var(Int, "a").WithOneLineComment("this is a int var"),
)))

Output:

var a int // this is a int var

fmt.Println(string(Dec(Ident("i")).Bytes()))

Output:

i--

var v = Var(String, "a")

fmt.Println(string(v.Bytes()))
fmt.Println(string(v.WithComments("A is a string").Bytes()))

v = v.WithTag(`json:"a"`)
fmt.Println(string(v.Bytes()))

v = v.WithoutTag()
fmt.Println(string(v.Bytes()))

v = Var(String, "AliasStringType").AsAlias().
	WithComments("AliasStringType is a Alias of string")
fmt.Println(string(v.Bytes()))

Output:

a string
// A is a string
a string
a string `json:"a"`
a string
// AliasStringType is a Alias of string
AliasStringType = string

k, v, ranger := Ident("k"), Ident("v"), Ident("ranger")
fmt.Println(
	Stringify(
		ForRange(ranger, k, v).Do(),
	),
)

Output:

for k, v := range ranger {
}

i := Ident("i")
fmt.Println(
	Stringify(
		For(
			Define(i).By(Valuer(0)),
			AssignWith(token.LSS, i).By(Valuer(10)),
			Inc(i),
		).Do(),
	),
)

Output:

for i := 0; i < 10; i++ {
}

ids := Idents("a", "b", "C", "Type.Field")
for _, id := range ids {
	fmt.Println(string(id.Bytes()))
}

Output:

a
b
C
Type.Field

fmt.Println(string(Inc(Ident("i")).Bytes()))

Output:

i++

fmt.Println(string(KeyValue(Valuer("key"), Valuer("value")).Bytes()))

Output:

"key": "value"

fmt.Println(Stringify(Paren(Valuer(1))))

Output:

(1)

ch1, ch2 := "ch1", "ch2"

fmt.Println(Stringify(DeclVar(
	Assign(Var(nil, ch1)).By(CallMakeChan(Int, 10)),
	Assign(Var(nil, ch2)).By(CallMakeChan(String, 10)),
	Var(String, "ret"),
)))
fmt.Println(Stringify(
	Select(
		CaseClause(Define(Ident("i")).By(Arrow(Ident(ch1)))).Do(
			Assign(Ident("ret")).By(
				Ref(Ident("fmt"), Call("Sprintf", Ident("i")))),
		),
		CaseClause(Define(Ident("s")).By(Arrow(Ident(ch2)))).Do(
			Assign(Ident("ret")).By(Ident("s")),
		),
		CaseClause().Do(),
	),
))
fmt.Println(Stringify(Return(Ident("ret"))))

Output:

var (
ch1 = make(chan int, 10)
ch2 = make(chan string, 10)
ret string
)
select {
case i := <-ch1:
ret = fmt.Sprintf(i)
case s := <-ch2:
ret = s
default:
}
return ret

fmt.Println(Stringify(Star(Int)))

Output:

*int

fmt.Println(Stringify(Switch(nil).When(clauses...)))

os := Ident("os")
tar := Ident("tar")
_ = runtime.GOOS
fmt.Print(Stringify(
	Switch(os).
		InitWith(Define(os).By(Ref(Ident("runtime"), Ident("GOOS")))).
		When(
			CaseClause(Valuer("darwin")).Do(
				Assign(tar).By(Ident("OS_DARWIN")),
			),
			CaseClause(Valuer("linux")).Do(
				Assign(tar).By(Ident("OS_LINUX")),
			),
			CaseClause(Valuer("windows")).Do(
				Assign(tar).By(Ident("OS_WINDOWS")),
			),
			CaseClause().Do(
				Assign(tar).By(Ident("OS_UNKNOWN")),
			),
			CaseClause(Valuer("doNothing")),
		),
))

Output:

switch {
case 1, 2:
case <-time.After():
default:
return a, Fn(1)
}
switch os := runtime.GOOS; os {
case "darwin":
tar = OS_DARWIN
case "linux":
tar = OS_LINUX
case "windows":
tar = OS_WINDOWS
default:
tar = OS_UNKNOWN
case "doNothing":
}

ta := TypeAssert(String, Ident("value"))
fmt.Println(string(ta.Bytes()))

ta = TypeAssert(Type("Name"), Ident("value"))
fmt.Println(string(ta.Bytes()))

ta = TypeAssert(Star(Type("Name")), Ident("value"))
fmt.Println(string(ta.Bytes()))

Output:

value.(string)
value.(Name)
value.(*Name)