Go 围棋中的方案解释器

我是一个非常基础的Go程序员，我一直在研究这个小型的Scheme解释器，我一直在试图理解它是如何工作的

我在这里找到的：

我读了这个网页，但我仍然很难理解它是如何工作的，因为源代码显然是由比我更熟悉围棋的人编写的

特别是有几句话我很难理解：

e := expression.(type) // Line 73

我不确定

（type）

部分是什么意思，我以为它是铸造的，但它看起来不像我以前见过的铸造

switch p := procedure.(type) {
case func(...scmer) scmer:
    value = p(args...)
case proc:
    en := &env{make(vars), p.en}
    switch params := p.params.(type) {
    case []scmer:
        for i, param := range params {
            en.vars[param.(symbol)] = args[i]
        }
    default:
        en.vars[params.(symbol)] = args
    }
    value = eval(p.body, en)

老实说，我不太懂这些代码。第73-86行

*tokens = (*tokens)[1:] // Line 208

我不确定这句话是什么意思，因为它的语法很奇怪。我知道它的指针和括号是因为*。但我不确定这些线在做什么

最后是以下几行：

token := (*tokens)[0]
*tokens = (*tokens)[1:]
switch token {
case "(": //a list begins
    L := make([]scmer, 0)
    for (*tokens)[0] != ")" {
        if i := readFrom(tokens); i != symbol("") {
            L = append(L, i)
        }
    }
    *tokens = (*tokens)[1:]
    return L

我也不知道这些线是干什么的。第198-209行

这是完整的代码，如果你想要的话，我知道它有250行长，但我真的很感激尽可能多地解释它的功能

/*
 * A minimal Scheme interpreter, as seen in lis.py and SICP
 * http://norvig.com/lispy.html
 * http://mitpress.mit.edu/sicp/full-text/sicp/book/node77.html
 *
 * Pieter Kelchtermans 2013
 * LICENSE: WTFPL 2.0
 */
package main

import (
    "bufio"
    "fmt"
    "log"
    "os"
    "reflect"
    "strconv"
    "strings"
)

func main() {
    Repl()
}

/*
 Eval / Apply
*/

func eval(expression scmer, en *env) (value scmer) {
    switch e := expression.(type) {
    case number:
        value = e
    case symbol:
        value = en.Find(e).vars[e]
    case []scmer:
        switch car, _ := e[0].(symbol); car {
        case "quote":
            value = e[1]
        case "if":
            if eval(e[1], en).(bool) {
                value = eval(e[2], en)
            } else {
                value = eval(e[3], en)
            }
        case "set!":
            v := e[1].(symbol)
            en.Find(v).vars[v] = eval(e[2], en)
            value = "ok"
        case "define":
            en.vars[e[1].(symbol)] = eval(e[2], en)
            value = "ok"
        case "lambda":
            value = proc{e[1], e[2], en}
        case "begin":
            for _, i := range e[1:] {
                value = eval(i, en)
            }
        default:
            operands := e[1:]
            values := make([]scmer, len(operands))
            for i, x := range operands {
                values[i] = eval(x, en)
            }
            value = apply(eval(e[0], en), values)
        }
    default:
        log.Println("Unknown expression type - EVAL", e)
    }
    return
}

func apply(procedure scmer, args []scmer) (value scmer) {
    switch p := procedure.(type) {
    case func(...scmer) scmer:
        value = p(args...)
    case proc:
        en := &env{make(vars), p.en}
        switch params := p.params.(type) {
        case []scmer:
            for i, param := range params {
                en.vars[param.(symbol)] = args[i]
            }
        default:
            en.vars[params.(symbol)] = args
        }
        value = eval(p.body, en)
    default:
        log.Println("Unknown procedure type - APPLY", p)
    }
    return
}

type proc struct {
    params, body scmer
    en           *env
}

/*
 Environments
*/

type vars map[symbol]scmer
type env struct {
    vars
    outer *env
}

func (e *env) Find(s symbol) *env {
    if _, ok := e.vars[s]; ok {
        return e
    } else {
        return e.outer.Find(s)
    }
}

/*
 Primitives
*/

var globalenv env

func init() {
    globalenv = env{
        vars{ //aka an incomplete set of compiled-in functions
            "+": func(a ...scmer) scmer {
                v := a[0].(number)
                for _, i := range a[1:] {
                    v += i.(number)
                }
                return v
            },
            "-": func(a ...scmer) scmer {
                v := a[0].(number)
                for _, i := range a[1:] {
                    v -= i.(number)
                }
                return v
            },
            "*": func(a ...scmer) scmer {
                v := a[0].(number)
                for _, i := range a[1:] {
                    v *= i.(number)
                }
                return v
            },
            "/": func(a ...scmer) scmer {
                v := a[0].(number)
                for _, i := range a[1:] {
                    v /= i.(number)
                }
                return v
            },
            "<=": func(a ...scmer) scmer {
                return a[0].(number) <= a[1].(number)
            },
            "equal?": func(a ...scmer) scmer {
                return reflect.DeepEqual(a[0], a[1])
            },
            "cons": func(a ...scmer) scmer {
                switch car := a[0]; cdr := a[1].(type) {
                case []scmer:
                    return append([]scmer{car}, cdr...)
                default:
                    return []scmer{car, cdr}
                }
            },
            "car": func(a ...scmer) scmer {
                return a[0].([]scmer)[0]
            },
            "cdr": func(a ...scmer) scmer {
                return a[0].([]scmer)[1:]
            },
            "list": eval(read(
                "(lambda z z)"),
                &globalenv),
        },
        nil}
}

/*
 Parsing
*/

//symbols, numbers, expressions, procedures, lists, ... all implement this interface, which enables passing them along in the interpreter
type scmer interface{}

type symbol string  //symbols are represented by strings
type number float64 //numbers by float64

func read(s string) (expression scmer) {
    tokens := tokenize(s)
    return readFrom(&tokens)
}

//Syntactic Analysis
func readFrom(tokens *[]string) (expression scmer) {
    //pop first element from tokens
    token := (*tokens)[0]
    *tokens = (*tokens)[1:]
    switch token {
    case "(": //a list begins
        L := make([]scmer, 0)
        for (*tokens)[0] != ")" {
            if i := readFrom(tokens); i != symbol("") {
                L = append(L, i)
            }
        }
        *tokens = (*tokens)[1:]
        return L
    default: //an atom occurs
        if f, err := strconv.ParseFloat(token, 64); err == nil {
            return number(f)
        } else {
            return symbol(token)
        }
    }
}

//Lexical Analysis
func tokenize(s string) []string {
    return strings.Split(
        strings.Replace(strings.Replace(s, "(", "( ",
            -1), ")", " )",
            -1), " ")
}

/*
 Interactivity
*/

func String(v scmer) string {
    switch v := v.(type) {
    case []scmer:
        l := make([]string, len(v))
        for i, x := range v {
            l[i] = String(x)
        }
        return "(" + strings.Join(l, " ") + ")"
    default:
        return fmt.Sprint(v)
    }
}

func Repl() {
    scanner := bufio.NewScanner(os.Stdin)
    for fmt.Print("> "); scanner.Scan(); fmt.Print("> ") {
        fmt.Println("==>", String(eval(read(scanner.Text()), &globalenv)))
    }
}

/*
*最小方案解释器，如lis.py和SICP中所示
* http://norvig.com/lispy.html
* http://mitpress.mit.edu/sicp/full-text/sicp/book/node77.html
*
*彼得·凯尔赫特曼2013
*许可证：WTFPL2.0
*/
包干管
进口(
“布菲奥”
“fmt”
“日志”
“操作系统”
“反映”
“strconv”
“字符串”
)
func main（）{
Repl（）
}
/*
评估/应用
*/
func eval（表达式scrmer，en*env）（值scrmer）{
开关e:=表达式。（类型）{
案件编号：
值=e
案例符号：
value=en.Find（e）.vars[e]
案例[]scmer：
转辙机轿厢，:=e[0]（符号）；轿厢{
案例“报价”：
数值=e[1]
案例“如果”：
如果评估（e[1]，en）。（布尔）{
值=评估值（e[2]，en）
}否则{
值=评估值（e[3]，en）
}
案例“集合！”：
v:=e[1]（符号）
en.Find（v.vars[v]=eval（e[2]，en）
value=“确定”
案例“定义”：
en.vars[e[1]（符号）]=eval（e[2]，en）
value=“确定”
“lambda”案：
value=proc{e[1]，e[2]，en}
案例“开始”：
对于u，i:=范围e[1:]{
值=评估值（i，en）
}
违约：
操作数：=e[1:]
值：=make（[]标准计数器，len（操作数））
对于i，x:=范围操作数{
值[i]=eval（x，en）
}
值=应用（评估（e[0]，en），值）
}
违约：
Println（“未知表达式类型-EVAL”，e）
}
返回
}
func apply（过程scrmer，args[]scrmer）（值scrmer）{
开关p:=程序（类型）{
案例功能（…scmer）scmer：
值=p（参数…）
案例过程：
en:=&env{make（vars），p.en}
开关参数：=p.params.（类型）{
案例[]scmer：
对于i，参数：=范围参数{
en.vars[参数（符号）]=参数[i]
}
违约：
en.vars[参数（符号）]=参数
}
值=评估值（p.body，en）
违约：
Println（“未知过程类型-应用”，p）
}
返回
}
类型proc struct{
人体切割机
恩*环境
}
/*
环境
*/
类型变量映射[symbol]scmer
类型env struct{
瓦尔斯
外*环境
}
func（e*env）查找（s符号）*env{
如果u，ok:=e.vars[s]；ok{
返回e
}否则{
返回e.outer.Find（s）
}
}
/*
原语
*/
var globalenv环境
func init（）{
globalenv=env{
vars{//aka是一组不完整的编译函数
“+”：func（一个…单片机）单片机{
v:=a[0]（数字）
对于u，i:=范围a[1:]{
v+=i（数字）
}
返回v
},
“-”：func（一个…scrmer）scrmer{
v:=a[0]（数字）
对于u，i:=范围a[1:]{
v-=i（编号）
}
返回v
},
“*”：func（一个……短接器）短接器{
v:=a[0]（数字）
对于u，i:=范围a[1:]{
v*=i（编号）
}
返回v
},
“/”：func（a…scmer）scmer{
v:=a[0]（数字）
对于u，i:=范围a[1:]{
v/=i（编号）
}
返回v
},
“”）；scanner.Scan（）；fmt.Print（“>”）{
fmt.Println（“==>”，字符串（eval（读取（scanner.Text（）），&globalenv）））
}
}

第一个是类型开关。您可以阅读更多信息

第二个是像python中那样的切片（如果您知道，应该很熟悉）

我们将跳过第一项，并获取切片/列表的其余部分

正如我从你的评论中所看到的，我认为这不是一个很好的尝试golang的起点。

e:=expression.（type）

是一个很好的例子

开关p:=procedure.（type）{

（带有以下case语句）是一个

*tokens=（*tokens）[1://code>是一种更改
*tokens
中存储的值的方法

token := (*tokens)[0]       // Set token to first element of tokens slice.
*tokens = (*tokens)[1:]     // Update tokens to remove first element.
switch token {              // Switch on token.
case "(": //a list begins   // If token is "("
    L := make([]scmer, 0)       // Make a new, empty slice.
    for (*tokens)[0] != ")" {   // While the first element of tokens is not ")":
                                    // Read from tokens; if not empty symbol:
        if i := readFrom(tokens); i != symbol("") {
            L = append(L, i)        // Add the token read (in i) to L.
        }
    }
    *tokens = (*tokens)[1:]     // Remove the first element from tokens.
    return L                    // Return the newly created slice.

我不认为lisp解释器是用新语言检查的好的第一个代码，除非您已经实现了大量自己的lisp解释器。
token := (*tokens)[0]       // Set token to first element of tokens slice.
*tokens = (*tokens)[1:]     // Update tokens to remove first element.
switch token {              // Switch on token.
case "(": //a list begins   // If token is "("
    L := make([]scmer, 0)       // Make a new, empty slice.
    for (*tokens)[0] != ")" {   // While the first element of tokens is not ")":
                                    // Read from tokens; if not empty symbol:
        if i := readFrom(tokens); i != symbol("") {
            L = append(L, i)        // Add the token read (in i) to L.
        }
    }
    *tokens = (*tokens)[1:]     // Remove the first element from tokens.
    return L                    // Return the newly created slice.