Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

asthlp

package module

Go to main page

Versions in this module

v0

v0.0.4

Dec 15, 2023

Changes in this version

+ type InterfaceMethodFiller interface

+ Inherits func(name string, tag *ast.BasicLit, docAndComments ...string)

+ Method func(decl MethodDecl, tag *ast.BasicLit, docAndComments ...string)

+ TypeSpec func() *ast.TypeSpec

+ func InterfaceTypeFiller(name string, comment ...string) InterfaceMethodFiller

+ type MethodDecl interface

+ Name func() *ast.Ident

+ Params func(...*ast.Field) MethodDecl

+ Results func(...*ast.Field) MethodDecl

+ Type func() ast.Expr

+ func DeclareMethod(name *ast.Ident) MethodDecl

+ type SliceStringLiteral []string

+ func (s SliceStringLiteral) Expr() ast.Expr

v0.0.3

Aug 12, 2023

v0.0.2

Feb 24, 2023

Changes in this version

+ var NewFn = makeFunc(ast.NewIdent("new"), 1, true)

+ func Break() ast.Stmt

+ func Continue() ast.Stmt

+ func Fallthrough() ast.Stmt

+ func MakeSwitch(init ast.Stmt, tag ast.Expr, cases ...SwitchCase) ast.Stmt

+ func ParenExpr(x ast.Expr) ast.Expr

+ func SliceExpr(x ast.Expr, lo, hi Expression) ast.Expr

v0.0.1

Feb 4, 2023

Changes in this version

+ const Assignment

+ const Decremental

+ const Definition

+ const Incremental

+ var AppendFn = makeFunc(ast.NewIdent("append"), 1, true)

+ var Blank = ast.NewIdent("_")

+ var Bool = ast.NewIdent("bool")

+ var Byte = ast.NewIdent("byte")

+ var BytesEqualFn = makeFunc(SimpleSelector("bytes", "Equal"), 2, false)

+ var BytesEqualFoldFn = makeFunc(SimpleSelector("bytes", "EqualFold"), 2, false)

+ var BytesNewBufferFn = makeFunc(SimpleSelector("bytes", "NewBuffer"), 1, false)

+ var BytesToFloat64Fn = makeFunc(SimpleSelector("utils", "BytesToFloat64"), 1, false)

+ var BytesToInt64Fn = makeFunc(SimpleSelector("utils", "BytesToInt64"), 1, false)

+ var BytesToIntFn = makeFunc(SimpleSelector("utils", "BytesToInt"), 1, false)

+ var BytesToUint64Fn = makeFunc(SimpleSelector("utils", "BytesToUint64"), 1, false)

+ var BytesToUintFn = makeFunc(SimpleSelector("utils", "BytesToUint"), 1, false)

+ var CapFn = makeFunc(ast.NewIdent("cap"), 1, false)

+ var ContextType = SimpleSelector("context", "Context")

+ var DbQueryFn = makeFunc(SimpleSelector("db", "Query"), 1, true)

+ var EmptyInterface = &ast.InterfaceType

+ var EmptyString = StringConstant("").Expr()

+ var ErrorType = ast.NewIdent("error")

+ var False = BoolConstant(false).Expr()

+ var Float32 = ast.NewIdent("float32")

+ var Float64 = ast.NewIdent("float64")

+ var FmtErrorfFn = makeFunc(SimpleSelector("fmt", "Errorf"), 1, true)

+ var FmtFscanfFn = makeFunc(SimpleSelector("fmt", "Fscanf"), 1, true)

+ var FmtSprintfFn = makeFunc(SimpleSelector("fmt", "Sprintf"), 1, true)

+ var Int = ast.NewIdent("int")

+ var Int16 = ast.NewIdent("int16")

+ var Int32 = ast.NewIdent("int32")

+ var Int64 = ast.NewIdent("int64")

+ var Int8 = ast.NewIdent("int8")

+ var JsonMarshal = makeFunc(SimpleSelector("json", "Marshal"), 1, false)

+ var JsonNewDecoder = makeFunc(SimpleSelector("json", "NewDecoder"), 1, false)

+ var JsonNewEncoder = makeFunc(SimpleSelector("json", "NewEncoder"), 1, false)

+ var JsonUnmarshal = makeFunc(SimpleSelector("json", "Unmarshal"), 2, false)

+ var LengthFn = makeFunc(ast.NewIdent("len"), 1, false)

+ var MakeFn = makeFunc(ast.NewIdent("make"), 1, true)

+ var Nil = ast.NewIdent("nil")

+ var RowsErrFn = makeFunc(SimpleSelector("rows", "Err"), 0, false)

+ var RowsNextFn = makeFunc(SimpleSelector("rows", "Next"), 0, false)

+ var RowsScanFn = makeFunc(SimpleSelector("rows", "Scan"), 1, true)

+ var Rune = ast.NewIdent("rune")

+ var StrconvAtoiFn = makeFunc(SimpleSelector("strconv", "Atoi"), 1, false)

+ var StrconvFormatBoolFn = makeFunc(SimpleSelector("strconv", "FormatBool"), 1, false)

+ var StrconvFormatFloatFn = makeFunc(SimpleSelector("strconv", "FormatFloat"), 4, false)

+ var StrconvFormatIntFn = makeFunc(SimpleSelector("strconv", "FormatInt"), 2, false)

+ var StrconvItoaFn = makeFunc(SimpleSelector("strconv", "Itoa"), 1, false)

+ var StrconvParseBoolFn = makeFunc(SimpleSelector("strconv", "ParseBool"), 1, false)

+ var StrconvParseFloatFn = makeFunc(SimpleSelector("strconv", "ParseFloat"), 2, false)

+ var StrconvParseIntFn = makeFunc(SimpleSelector("strconv", "ParseInt"), 3, false)

+ var StrconvParseUintFn = makeFunc(SimpleSelector("strconv", "ParseUint"), 3, false)

+ var String = ast.NewIdent("string")

+ var StringsEqualFoldFn = makeFunc(SimpleSelector("strings", "EqualFold"), 2, false)

+ var StringsJoinFn = makeFunc(SimpleSelector("strings", "Join"), 2, false)

+ var StringsToLowerFn = makeFunc(SimpleSelector("strings", "ToLower"), 1, false)

+ var TimeNowFn = makeFunc(SimpleSelector("time", "Now"), 0, false)

+ var TimeTime = SimpleSelector("time", "Time")

+ var True = BoolConstant(true).Expr()

+ var UInt = ast.NewIdent("uint")

+ var UInt16 = ast.NewIdent("uint16")

+ var UInt32 = ast.NewIdent("uint32")

+ var UInt64 = ast.NewIdent("uint64")

+ var UInt8 = ast.NewIdent("uint8")

+ var UUID = SimpleSelector("uuid", "UUID")

+ var Zero = IntegerConstant(0).Expr()

+ func Add(exps ...ast.Expr) ast.Expr

+ func And(left ast.Expr, expr ...ast.Expr) ast.Expr

+ func ArrayType(expr ast.Expr, l ...ast.Expr) ast.Expr

+ func Assign(varNames VarNames, tok assignToken, rhs ...ast.Expr) ast.Stmt

+ func Binary(left, right ast.Expr, tok token.Token) ast.Expr

+ func Block(statements ...ast.Stmt) *ast.BlockStmt

+ func Call(fn CallFunctionDescriber, args ...ast.Expr) *ast.CallExpr

+ func CallEllipsis(fn CallFunctionDescriber, args ...ast.Expr) *ast.CallExpr

+ func CallStmt(x *ast.CallExpr) ast.Stmt

+ func ClearEmptyExpressions(first ast.Expr, next ...ast.Expr) []ast.Expr

+ func CommentGroup(comments ...string) *ast.CommentGroup

+ func CommentGroupIf(comments ...*string) *ast.CommentGroup

+ func CommentGroupWithTag(tag string, comments ...string) *ast.CommentGroup

+ func CommentStmt(comment string) ast.Stmt

+ func Decrement(expr ast.Expr) ast.Stmt

+ func DeferCall(fn CallFunctionDescriber, args ...ast.Expr) ast.Stmt

+ func EmptyStmt() ast.Stmt

+ func Equal(left, right ast.Expr) ast.Expr

+ func ExpressionTypeAssert(expr, t ast.Expr) ast.Expr

+ func ExpressionTypeConvert(expr ast.Expr, t ast.Expr) ast.Expr

+ func Field(name string, tag *ast.BasicLit, fieldType ast.Expr, docAndComments ...string) *ast.Field

+ func FieldList(fields ...*ast.Field) *ast.FieldList

+ func Great(left, right ast.Expr) ast.Expr

+ func If(condition ast.Expr, body ...ast.Stmt) ast.Stmt

+ func IfElse(condition ast.Expr, body *ast.BlockStmt, alternative *ast.BlockStmt) ast.Stmt

+ func IfInit(initiation ast.Stmt, condition ast.Expr, body ...ast.Stmt) ast.Stmt

+ func IfInitElse(initiation ast.Stmt, condition ast.Expr, body *ast.BlockStmt, ...) ast.Stmt

+ func IfKeyVal(key string, value ast.Expr) ast.Expr

+ func Import(imports map[string]string) ast.Decl

+ func Increment(expr ast.Expr) ast.Stmt

+ func Index(x ast.Expr, index Expression) ast.Expr

+ func IsNil(expr ast.Expr) ast.Expr

+ func KeyValueExpr(key string, val ast.Expr) *ast.KeyValueExpr

+ func MakeCallReturnIfError(varName ast.Expr, callExpr *ast.CallExpr) ast.Stmt

+ func MakeCallWithErrChecking(varName string, callExpr *ast.CallExpr, body ...ast.Stmt) ast.Stmt

+ func MakeLenGreatThanZero(arrayName string) ast.Expr

+ func MakeTagsForField(tags map[string][]string) *ast.BasicLit

+ func MakeTypeSwitch(assign ast.Stmt, cases ...SwitchCase) ast.Stmt

+ func MapType(key, expr ast.Expr) ast.Expr

+ func NewIdent(name string) *ast.Ident

+ func Not(expr ast.Expr) ast.Expr

+ func NotEqual(left, right ast.Expr) ast.Expr

+ func NotNil(expr ast.Expr) ast.Expr

+ func Or(left ast.Expr, expr ...ast.Expr) ast.Expr

+ func Range(define bool, key, value string, x ast.Expr, body ...ast.Stmt) ast.Stmt

+ func Ref(expr ast.Expr) ast.Expr

+ func Return(results ...ast.Expr) *ast.ReturnStmt

+ func ReturnEmpty() ast.Stmt

+ func Selector(x ast.Expr, object string) ast.Expr

+ func SimpleSelector(pack, object string) ast.Expr

+ func Slice(varName string, lo, hi Expression) ast.Expr

+ func Star(expr ast.Expr) ast.Expr

+ func StructType(fields ...*ast.Field) *ast.StructType

+ func Sub(exps ...ast.Expr) ast.Expr

+ func TypeSpec(name string, varType ast.Expr, comment ...string) *ast.TypeSpec

+ func Unary(expr ast.Expr, tok token.Token) ast.Expr

+ func Var(spec ...ast.Spec) ast.Stmt

+ func VariableType(name string, varType ast.Expr, vals ...Expression) *ast.ValueSpec

+ func VariableTypeAssert(varName string, t ast.Expr) ast.Expr

+ func VariableTypeConvert(varName string, t ast.Expr) ast.Expr

+ func VariableValue(name string, vals ...Expression) *ast.ValueSpec

+ type BoolConstant bool

+ func (b BoolConstant) Expr() ast.Expr

+ type CallFunctionDescriber struct

+ ExtensibleNumberOfArguments bool

+ FunctionName ast.Expr

+ MinimumNumberOfArguments int

+ func InlineFunc(f ast.Expr) CallFunctionDescriber

+ type Expression interface

+ Expr func() ast.Expr

+ func FreeExpression(e ast.Expr) Expression

+ type FloatConstant float64

+ func (c FloatConstant) Expr() ast.Expr

+ type FuncDecl interface

+ AppendStmt func(...ast.Stmt) FuncDecl

+ Comments func(...string) FuncDecl

+ Decl func() ast.Decl

+ Lit func() ast.Expr

+ Params func(...*ast.Field) FuncDecl

+ Receiver func(*ast.Field) FuncDecl

+ Results func(...*ast.Field) FuncDecl

+ func DeclareFunction(name *ast.Ident) FuncDecl

+ type IntegerConstant int64

+ func (c IntegerConstant) Expr() ast.Expr

+ type RuneConstant rune

+ func (c RuneConstant) Expr() ast.Expr

+ type SliceByteLiteral []byte

+ func (s SliceByteLiteral) Expr() ast.Expr

+ type StringConstant string

+ func (c StringConstant) Expr() ast.Expr

+ type StructFieldFiller interface

+ Field func(name string, tag *ast.BasicLit, fieldType ast.Expr, docAndComments ...string)

+ TypeSpec func() *ast.TypeSpec

+ func StructTypeFiller(name string, comment ...string) StructFieldFiller

+ type StructFiller interface

+ FillKeyValue func(key string, value ast.Expr) StructFiller

+ func StructLiteral(name ast.Expr) StructFiller

+ type SwitchCase struct

+ func MakeSwitchCase(clause ...ast.Expr) SwitchCase

+ func (c SwitchCase) Body(statements ...ast.Stmt) SwitchCase

+ type UnsignedConstant uint64

+ func (c UnsignedConstant) Expr() ast.Expr

+ type VarDecl interface

+ AppendSpec func(spec ...ast.Spec) VarDecl

+ Comments func(comments ...string) VarDecl

+ Decl func() ast.Decl

+ Stmt func() ast.Stmt

+ func DeclareVariable() VarDecl

+ type VarNames []ast.Expr

+ func MakeVarNames(vars ...string) VarNames

+ type VariableName string

+ func (c VariableName) Expr() ast.Expr