syn

type Apply[T any] struct {
	Function Term[T]
	Argument Term[T]
}

type Binder interface {
	VarEncode(e *encoder) error
	VarDecode(d *decoder) (Binder, error)

	ParameterEncode(e *encoder) error
	ParameterDecode(d *decoder) (Binder, error)

	TextName() string

	fmt.Stringer
}

type Bls12_381G1Element struct {
	Inner *bls.G1Jac
}

type Bls12_381G2Element struct {
	Inner *bls.G2Jac
}

type Bls12_381MlResult struct {
	Inner *bls.GT
}

type Bool struct {
	Inner bool
}

type Builtin struct {
	builtin.DefaultFunction
}

type ByteString struct {
	Inner []byte
}

type Case[T any] struct {
	Constr   Term[T]
	Branches []Term[T]
}

type Constant struct {
	Con IConstant
}

type Constr[T any] struct {
	Tag    uint
	Fields []Term[T]
}

type Data struct {
	Inner data.PlutusData
}

type DeBruijn int

type Delay[T any] struct {
	Term Term[T]
}

type Error struct{}

type Eval interface {
	Binder
	LookupIndex() int
}

type Force[T any] struct {
	Term Term[T]
}

type IConstant interface {
	Typ() Typ
	// contains filtered or unexported methods
}

type Integer struct {
	Inner *big.Int
}

type Lambda[T any] struct {
	ParameterName T
	Body          Term[T]
}

type Name struct {
	Text   string
	Unique Unique
}

type NamedDeBruijn struct {
	Text  string
	Index DeBruijn
}

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

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

type Program[T any] struct {
	Version [3]uint32
	Term    Term[T]
}

type ProtoList struct {
	LTyp Typ
	List []IConstant
}

type ProtoPair struct {
	FstType Typ
	SndType Typ
	First   IConstant
	Second  IConstant
}

type String struct {
	Inner string
}

type TBls12_381G1Element struct{}

type TBls12_381G2Element struct{}

type TBls12_381MlResult struct{}

type TBool struct{}

type TByteString struct{}

type TData struct{}

type TInteger struct{}

type TList struct {
	Typ
}

type TPair struct {
	First  Typ
	Second Typ
}

type TString struct{}

type TUnit struct{}

type Term[T any] interface {
	// contains filtered or unexported methods
}

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

type Unique uint64

type Unit struct{}

type Var[T any] struct {
	Name T
}