Golang结构定义模式

Question

I'm currently playing with Go, was wondering what are the patterns for defining the data types. For example take the Bencode and representing it as a Go data structure.

like in Haskell

data BEncode = BInt Integer
         | BString L.ByteString
         | BList [BEncode]
         | BDict (Map String BEncode)

in C, we can do something like this

struct Bencoding;

typedef struct ListNode {
    struct Bencoding *cargo;
    struct ListNode *next;
} ListNode;

typedef struct DictNode {
    char *key;
    struct Bencoding *value;
    struct DictNode *next;
} DictNode;

typedef struct Bencoding {
    BType type;
    union {
        long long val;  // used when type == BInt
        ListNode *list; // used when type == BList
        char *str;      // used when type == BString
        DictNode *dict;
    } cargo; // data
} Bencoding;

what is the best way to define these kinds of data structures in Golang. Are there any patterns / good practices with Golang.

Answer 1

Like this?

type BEncodeType int

const (
    TypeBInt BEncodeType = iota
    TypeBString
    TypeBList
    TypeBDict
)

type BEncode interface {
    Type() BEncodeType
    Val() interface{}
}

type BInt int

func (n *BInt) Type() BEncodeType {
    return TypeBInt
}
func (n *BInt) Val() interface{} {
    return n
}

type BString string

func (n *BString) Type() BEncodeType {
    return TypeBString
}
func (n *BString) Val() interface{} {
    return n
}

type BList []BEncode

func (n *BList) Type() BEncodeType {
    return TypeBList
}
func (n *BList) Val() interface{} {
    return n
}

type BDict map[string]BEncode

func (n *BDict) Type() BEncodeType {
    return TypeBDict
}
func (n *BDict) Val() interface{} {
    return n
}