sunx.ai

Production  = production_name "=" [ Expression ] "." .
Expression  = Alternative { "|" Alternative } .
Alternative = Term { Term } .
Term        = production_name | token [ "…" token ] | Group | Option | Repetition .
Group       = "(" Expression ")" .
Option      = "[" Expression "]" .
Repetition  = "{" Expression "}" .

|   或
()  分組
[]  可選 (出現 0 或 1 次)
{}  可重複 (出現 0 到 n 次)

newline        = /* Unicode 代碼點 U+000A */ .
unicode_char   = /* 排除換行以外的任意 Unicode 代碼點 */ .
unicode_letter = /* 一個字母（"Letter"）類型的 Unicode 代碼點  */ .
unicode_digit  = /* 一個數字（"Number, decimal digit"）類型的 Unicode 代碼點  */ .

letter        = unicode_letter | "_" .
decimal_digit = "0" … "9" .
octal_digit   = "0" … "7" .
hex_digit     = "0" … "9" | "A" … "F" | "a" … "f" .

identifier = letter { letter | unicode_digit } .

a
_x9
ThisVariableIsExported
αβ

break        default      func         interface    select
case         defer        go           map          struct
chan         else         goto         package      switch
const        fallthrough  if           range        type
continue     for          import       return       var

+    &     +=    &=     &&    ==    !=    (    )
-    |     -=    |=     ||    <     <=    [    ]
*    ^     *=    ^=     <-    >     >=    {    }
/    <<    /=    <<=    ++    =     :=    ,    ;
%    >>    %=    >>=    --    !     ...   .    :
     &^          &^=

int_lit     = decimal_lit | octal_lit | hex_lit .
decimal_lit = ( "1" … "9" ) { decimal_digit } .
octal_lit   = "0" { octal_digit } .
hex_lit     = "0" ( "x" | "X" ) hex_digit { hex_digit } .

42
0600
0xBadFace
170141183460469231731687303715884105727

float_lit = decimals "." [ decimals ] [ exponent ] |
            decimals exponent |
            "." decimals [ exponent ] .
decimals  = decimal_digit { decimal_digit } .
exponent  = ( "e" | "E" ) [ "+" | "-" ] decimals .

0.
72.40
072.40  // == 72.40
2.71828
1.e+0
6.67428e-11
1E6
.25
.12345E+5

imaginary_lit = (decimals | float_lit) "i" .

0i
011i  // == 11i
0.i
2.71828i
1.e+0i
6.67428e-11i
1E6i
.25i
.12345E+5i

\a   U+0007 alert or bell
\b   U+0008 退格符
\f   U+000C form feed
\n   U+000A line feed or newline
\r   U+000D carriage return
\t   U+0009 水平制表符
\v   U+000b 垂直制表符
\\   U+005c 反斜線
\'   U+0027 單引號  (只在 rune 字面值中有效)
\"   U+0022 雙引號  (只在字符串字面值中有效)

rune_lit         = "'" ( unicode_value | byte_value ) "'" .
unicode_value    = unicode_char | little_u_value | big_u_value | escaped_char .
byte_value       = octal_byte_value | hex_byte_value .
octal_byte_value = `\` octal_digit octal_digit octal_digit .
hex_byte_value   = `\` "x" hex_digit hex_digit .
little_u_value   = `\` "u" hex_digit hex_digit hex_digit hex_digit .
big_u_value      = `\` "U" hex_digit hex_digit hex_digit hex_digit
                           hex_digit hex_digit hex_digit hex_digit .
escaped_char     = `\` ( "a" | "b" | "f" | "n" | "r" | "t" | "v" | `\` | "'" | `"` ) .

'a'
'ä'
'本'
'\t'
'\000'
'\007'
'\377'
'\x07'
'\xff'
'\u12e4'
'\U00101234'
'\''         // 包含單引號的 rune 字面值
'aa'         // 無效: 太多字符
'\xa'        // 無效: 缺少十六進制數
'\0'         // 無效: 缺少八進制數
'\uDFFF'     // 無效: surrogate half
'\U00110000' // 無效: 非法的 Unicode 代碼點

string_lit             = raw_string_lit | interpreted_string_lit .
raw_string_lit         = "`" { unicode_char | newline } "`" .
interpreted_string_lit = `"` { unicode_value | byte_value } `"` .

`abc`                // 等價於 "abc"
`\n
\n`                  // 等價於 "\\n\n\\n"
"\n"
"\""                 // 等價於 `"`
"Hello, world!\n"
"日本語"
"\u65e5本\U00008a9e"
"\xff\u00FF"
"\uD800"             // 無效: surrogate half
"\U00110000"         // 無效: 無效的 Unicode 代碼點

"日本語"                                 // UTF-8 文本
`日本語`                                 // UTF-8 文本作為原生字面值
"\u65e5\u672c\u8a9e"                    // 確定的 Unicode 代碼點 
"\U000065e5\U0000672c\U00008a9e"        // 確定的 Unicode 代碼點
"\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e"  // 確定的 UTF-8 字節

var x interface{}  // x 的靜態類型為 interface{} 值為 nil
var v *T           // v 的靜態類型為 *T 值為 nil
x = 42             // x 的動態類型為 int 值為 42
x = v              // x 動態類型為 *T 值為 (*T)(nil)

Type      = TypeName | TypeLit | "(" Type ")" .
TypeName  = identifier | QualifiedIdent .
TypeLit   = ArrayType | StructType | PointerType | FunctionType | InterfaceType |
	    SliceType | MapType | ChannelType .

type (
	A1 = string
	A2 = A1
)

type (
	B1 string
	B2 B1
	B3 []B1
	B4 B3
)

uint8       8 位無符號整數集合 (0 to 255)
uint16      16 位無符號整數集合 (0 to 65535)
uint32      32 位無符號整數集合 (0 to 4294967295)
uint64      64 位無符號整數集合 (0 to 18446744073709551615)

int8        8 位有符號整數集合 (-128 to 127)
int16       16 位有符號整數集合 (-32768 to 32767)
int32       32 位有符號整數集合 (-2147483648 to 2147483647)
int64       64 位有符號整數集合 (-9223372036854775808 to 9223372036854775807)

float32     IEEE-754 32 位浮點數集合
float64     IEEE-754 64 位浮點數集合

complex64   實部虛部都為 float32 的複數集合
complex128  實部虛部都為 float64 的複數集合

byte        uint8 的別名
rune        int32 的別名

uint     32 或 64 位
int      和 uint 位數相同
uintptr  能夠容納指針值的無符號整數

ArrayType   = "[" ArrayLength "]" ElementType .
ArrayLength = Expression .
ElementType = Type .

[32]byte
[2*N] struct { x, y int32 }
[1000]*float64
[3][5]int
[2][2][2]float64  // same as [2]([2]([2]float64))

SliceType = "[" "]" ElementType .

make([]T, length, capacity)

make([]int, 50, 100)
new([100]int)[0:50]

StructType    = "struct" "{" { FieldDecl ";" } "}" .
FieldDecl     = (IdentifierList Type | EmbeddedField) [ Tag ] .
EmbeddedField = [ "*" ] TypeName .
Tag           = string_lit .

// 空結構體.
struct {}

// 6個字段的結構體.
struct {
	x, y int
	u float32
	_ float32  // padding
	A *[]int
	F func()
}

// 一個包含 4 個嵌入字段 T1, *T2, P.T3 和 *P.T4 的結構體
struct {
	T1        // 字段名為 T1
	*T2       // 字段名為 T2
	P.T3      // 字段名為 T3
	*P.T4     // 字段名為 T4
	x, y int  // 字段名為 x 和 y
}

struct {
	T     // 嵌入字段 *T 與 *P.T 衝突
	*T    // 嵌入字段 T 與 *P.T 衝突
	*P.T  // 嵌入字段 T 與 *T 衝突
}

struct {
	x, y float64 ""  // 空 tag 和缺省 tag 相同
	name string  "any string is permitted as a tag"
	_    [4]byte "ceci n'est pas un champ de structure"
}

// 結構體對應一個 TimeStamp 的 protocol buffer.
// tag 字符串中定義了 protocol buffer 字段對應的數字;
// 一般使用 reflect 包读取他們.
struct {
	microsec  uint64 `protobuf:"1"`
	serverIP6 uint64 `protobuf:"2"`
}

PointerType = "*" BaseType .
BaseType    = Type .

*Point
*[4]int

FunctionType   = "func" Signature .
Signature      = Parameters [ Result ] .
Result         = Parameters | Type .
Parameters     = "(" [ ParameterList [ "," ] ] ")" .
ParameterList  = ParameterDecl { "," ParameterDecl } .
ParameterDecl  = [ IdentifierList ] [ "..." ] Type .

func()
func(x int) int
func(a, _ int, z float32) bool
func(a, b int, z float32) (bool)
func(prefix string, values ...int)
func(a, b int, z float64, opt ...interface{}) (success bool)
func(int, int, float64) (float64, *[]int)
func(n int) func(p *T)

InterfaceType      = "interface" "{" { MethodSpec ";" } "}" .
MethodSpec         = MethodName Signature | InterfaceTypeName .
MethodName         = identifier .
InterfaceTypeName  = TypeName .

// A simple File interface
interface {
	Read(b Buffer) bool
	Write(b Buffer) bool
	Close()
}

func (p T) Read(b Buffer) bool { return … }
func (p T) Write(b Buffer) bool { return … }
func (p T) Close() { … }

interface{}

type Locker interface {
	Lock()
	Unlock()
}

func (p T) Lock() { … }
func (p T) Unlock() { … }

type ReadWriter interface {
	Read(b Buffer) bool
	Write(b Buffer) bool
}

type File interface {
	ReadWriter  // 與添加 ReadWriter 接口中的方法是等價的
	Locker      // 與添加 Locker 接口中的方法是等價的 
	Close()
}

type LockedFile interface {
	Locker
	File        // 無效: Lock, Unlock 不是唯一的
	Lock()      // 無效: Lock 不是唯一的
}

// 無效: Bad 不能嵌入它自己
type Bad interface {
	Bad
}

// 無效: Bad1 不能嵌入已經引用它的 Bad2
type Bad1 interface {
	Bad2
}
type Bad2 interface {
	Bad1
}

MapType     = "map" "[" KeyType "]" ElementType .
KeyType     = Type .

map[string]int
map[*T]struct{ x, y float64 }
map[string]interface{}

make(map[string]int)
make(map[string]int, 100)

ChannelType = ( "chan" | "chan" "<-" | "<-" "chan" ) ElementType .

chan T          // 可以接收和發送 T 類型的數據
chan<- float64  // 只能發送 float64 類型的值
<-chan int      // 只能接收

chan<- chan int    // 等價於 chan<- (chan int)
chan<- <-chan int  // 等價於 chan<- (<-chan int)
<-chan <-chan int  // 等價於 <-chan (<-chan int)
chan (<-chan int)

make(chan int, 100)

type (
	A0 = []string
	A1 = A0
	A2 = struct{ a, b int }
	A3 = int
	A4 = func(A3, float64) *A0
	A5 = func(x int, _ float64) *[]string
)

type (
	B0 A0
	B1 []string
	B2 struct{ a, b int }
	B3 struct{ a, c int }
	B4 func(int, float64) *B0
	B5 func(x int, y float64) *A1
)

type	C0 = B0

A0, A1, and []string
A2 and struct{ a, b int }
A3 and int
A4, func(int, float64) *[]string, and A5

B0, B0, and C0
[]int and []int
struct{ a, b *T5 } and struct{ a, b *T5 }
func(x int, y float64) *[]string, func(int, float64) (result *[]string), and A5

x                   T           x 可以表示 T 的值，因為：

'a'                 byte        97 在 byte 類型值的集合中
97                  rune        rune 是 int32 的別名，97 在 32 位整型值的集合中
"foo"               string      "foo" 在字符串值的集合中
1024                int16       1024 在 16 位整型值的集合中
42.0                byte        42 在 8 位無符號整型值的集合中
1e10                uint64      10000000000 在 64 位無符號整型值的集合中
2.718281828459045   float32     2.718281828459045 的近似值 2.7182817 在 float32 類型值的集合中
-1e-1000            float64     -1e-1000 的近視值 IEEE -0.0，等於 0 
0i                  int         0 是整型值
(42 + 0i)           float32     42.0 (0 虛部) 在 float32 類型值的集合中

x                   T           x 不能表示 T 的值，因為：

0                   bool        0 不在布爾值的集合中
'a'                 string      'a' 是 rune 類型, 它不在字符串類型的值集合中
1024                byte        1024 不在 8 位無符號整型值的集合中
-1                  uint16      -1 不在 16 位無符號整型值的集合中
1.1                 int         1.1 不是整型值
42i                 float32     (0 + 42i) 不在 float32 類型值的集合中
1e1000              float64     1e1000 取近似值時會溢出成 IEEE

Block = "{" StatementList "}" .
StatementList = { Statement ";" } .

Declaration   = ConstDecl | TypeDecl | VarDecl .
TopLevelDecl  = Declaration | FunctionDecl | MethodDecl .

Types:
	bool byte complex64 complex128 error float32 float64
	int int8 int16 int32 int64 rune string
	uint uint8 uint16 uint32 uint64 uintptr

Constants:
	true false iota

Zero value:
	nil

Functions:
	append cap close complex copy delete imag len
	make new panic print println real recover

ConstDecl      = "const" ( ConstSpec | "(" { ConstSpec ";" } ")" ) .
ConstSpec      = IdentifierList [ [ Type ] "=" ExpressionList ] .

IdentifierList = identifier { "," identifier } .
ExpressionList = Expression { "," Expression } .

const Pi float64 = 3.14159265358979323846
const zero = 0.0         // 無類型浮點數常量
const (
	size int64 = 1024
	eof        = -1  // 無類型整型常量
)
const a, b, c = 3, 4, "foo"  // a = 3, b = 4, c = "foo", 無類型整型和字符串常量
const u, v float32 = 0, 3    // u = 0.0, v = 3.0

const (
	Sunday = iota
	Monday
	Tuesday
	Wednesday
	Thursday
	Friday
	Partyday
	numberOfDays  // 非導出常量
)

const ( // iota is reset to 0
	c0 = iota  // c0 == 0
	c1 = iota  // c1 == 1
	c2 = iota  // c2 == 2
)

const ( // iota is reset to 0
	a = 1 << iota  // a == 1
	b = 1 << iota  // b == 2
	c = 3          // c == 3  (沒有使用 iota 不過它的值依然遞增)
	d = 1 << iota  // d == 8
)

const ( // iota is reset to 0
	u         = iota * 42  // u == 0     (無類型整型常量)
	v float64 = iota * 42  // v == 42.0  (float64 類型常量)
	w         = iota * 42  // w == 84    (無類型整型常量)
)

const x = iota  // x == 0  (iota 被重置)
const y = iota  // y == 0  (iota 被重置)

const (
	bit0, mask0 = 1 << iota, 1<<iota - 1  // bit0 == 1, mask0 == 0  (iota == 0)
	bit1, mask1                           // bit1 == 2, mask1 == 1  (iota == 1)
	_, _                                  //                        (iota == 2, unused)
	bit3, mask3                           // bit3 == 8, mask3 == 7  (iota == 3)
)

TypeDecl = "type" ( TypeSpec | "(" { TypeSpec ";" } ")" ) .
TypeSpec = AliasDecl | TypeDef .

AliasDecl = identifier "=" Type .

type (
	nodeList = []*Node  // nodeList 和 []*Node 是相同類型
	Polar    = polar    // Polar 和 polar 表示相同類型
)

TypeDef = identifier Type .

type (
	Point struct{ x, y float64 }  // Point 和 struct{ x, y float64 } 是不同類型
	polar Point                   // polar 和 Point 表示不同類型
)

type TreeNode struct {
	left, right *TreeNode
	value *Comparable
}

type Block interface {
	BlockSize() int
	Encrypt(src, dst []byte)
	Decrypt(src, dst []byte)
}

// Mutex 是一個擁有 Lock 和 Unlock 兩個方法的數據類型。
type Mutex struct         { /* Mutex fields */ }
func (m *Mutex) Lock()    { /* Lock implementation */ }
func (m *Mutex) Unlock()  { /* Unlock implementation */ }

// NewMutex 與 Mutex 結構相同不過方法集為空。
type NewMutex Mutex

// PtrMutex 的底層類型 *Mutex 的方法集沒有改變，
// 但是 PtrMutex 的方法集為空。
type PtrMutex *Mutex

// *PrintableMutex 包含嵌入字段 Mutex 的 Lock 和 Unlock 方法。
type PrintableMutex struct {
	Mutex
}

// MyBlock 是與 Block 有相同方法集的接口類型
type MyBlock Block

type TimeZone int

const (
	EST TimeZone = -(5 + iota)
	CST
	MST
	PST
)

func (tz TimeZone) String() string {
	return fmt.Sprintf("GMT%+dh", tz)
}

VarDecl     = "var" ( VarSpec | "(" { VarSpec ";" } ")" ) .
VarSpec     = IdentifierList ( Type [ "=" ExpressionList ] | "=" ExpressionList ) .

var i int
var U, V, W float64
var k = 0
var x, y float32 = -1, -2
var (
	i       int
	u, v, s = 2.0, 3.0, "bar"
)
var re, im = complexSqrt(-1)
var _, found = entries[name]  // map lookup; only interested in "found"

var d = math.Sin(0.5)  // d is float64
var i = 42             // i is int
var t, ok = x.(T)      // t is T, ok is bool
var n = nil            // illegal

ShortVarDecl = IdentifierList ":=" ExpressionList .

"var" IdentifierList = ExpressionList .

i, j := 0, 10
f := func() int { return 7 }
ch := make(chan int)
r, w := os.Pipe(fd)  // os.Pipe() 返回兩個值
_, y, _ := coord(p)  // coord() 返回三個值，我們只關注 y

field1, offset := nextField(str, 0)
field2, offset := nextField(str, offset)  // 重新聲明 offset
a, a := 1, 2                              // 非法：聲明了 a 兩次並且沒有新的變量

FunctionDecl = "func" FunctionName Signature [ FunctionBody ] .
FunctionName = identifier .
FunctionBody = Block .

func IndexRune(s string, r rune) int {
   for i, c := range s {
   	if c == r {
   		return i
   	}
   }
   // 無效：缺少 return 語句
}

func min(x int, y int) int {
	if x < y {
		return x
	}
	return y
}

func flushICache(begin, end uintptr)  // 由外部實現

MethodDecl = "func" Receiver MethodName Signature [ FunctionBody ] .
Receiver   = Parameters .

func (p *Point) Length() float64 {
	return math.Sqrt(p.x * p.x + p.y * p.y)
}

func (p *Point) Scale(factor float64) {
	p.x *= factor
	p.y *= factor
}

func(p *Point, factor float64)

Operand     = Literal | OperandName | MethodExpr | "(" Expression ")" .
Literal     = BasicLit | CompositeLit | FunctionLit .
BasicLit    = int_lit | float_lit | imaginary_lit | rune_lit | string_lit .
OperandName = identifier | QualifiedIdent.

QualifiedIdent = PackageName "." identifier .

math.Sin	// 表示 math 包中的 Sin 函數

CompositeLit  = LiteralType LiteralValue .
LiteralType   = StructType | ArrayType | "[" "..." "]" ElementType |
                SliceType | MapType | TypeName .
LiteralValue  = "{" [ ElementList [ "," ] ] "}" .
ElementList   = KeyedElement { "," KeyedElement } .
KeyedElement  = [ Key ":" ] Element .
Key           = FieldName | Expression | LiteralValue .
FieldName     = identifier .
Element       = Expression | LiteralValue .