JSON Marshal struct with method return as field

Is it possible to marshal a struct with method return as field? For example, I want this JSON

{
  "cards": [1,2,3],
  "value": 6,
  "size": 3
}

With this kind of struct

type Deck struct {
   Cards []int    `json:"cards"`
   Value func() int `json:"value"`
   Size  func() int `json:"size"`
}

Anyone?

You can implement a Marshaler like this http://play.golang.org/p/ySUFcUOHCZ (or this http://play.golang.org/p/ndwKu-7Y5m )

<!-- language: lang-go -->

package main

import "fmt"
import "encoding/json"

type Deck struct {
	Cards []int
}

func (d Deck) Value() int {
	value := 0
	for _, v := range d.Cards {
		value = value + v
	}
	return value
}
func (d Deck) Size() int {
	return len(d.Cards)
}

func (d Deck) MarshalJSON() ([]byte, error) {
	return json.Marshal(struct {
		Cards []int `json:"cards"`
		Value int   `json:"value"`
		Size  int   `json:"size"`
	}{
		Cards: d.Cards,
		Value: d.Value(),
		Size:  d.Size(),
	})
}

func main() {
	deck := Deck{
		Cards: []int{1, 2, 3},
	}

	b, r := json.Marshal(deck)
	fmt.Println(string(b))
	fmt.Println(r)
}

You could also create a function type that implement JSONMarshaler and JSONUnmarshaler. But it has some drawbacks.

import "fmt"
import "encoding/json"

type IntFunc func() int

func (f IntFunc) MarshalJSON() ([]byte, error) {
	return json.Marshal(f())
}

// NOTES you'll lose the original function here
func (f *IntFunc) UnmarshalJSON(b []byte) error {
	var i int
	err := json.Unmarshal(b, &i)

	// you could either add dummy function or leave it nil by not assigning *f
	*f = func() int { return i }
	return err
}

type Deck struct {
	Cards []int   `json:"cards"`
	Value IntFunc `json:"value"`
	Size  IntFunc `json:"size"`
}

func main() {
	deck := Deck{
		Cards: []int{1, 2, 3},
	}
	deck.Value = ValueOf(&deck)
	deck.Size = SizeOf(&deck)

	fmt.Printf("Size: %v, Cards: %v, Value: %v\n", deck.Size(), deck.Cards, deck.Value())
	deck.Cards = append(deck.Cards, 8)
	fmt.Printf("Size: %v, Cards: %v, Value: %v\n", deck.Size(), deck.Cards, deck.Value())
	fmt.Println()

	b, err := json.Marshal(deck)
	fmt.Println("Marshal Error:", err)
	fmt.Println("Marshal result:", string(b))
	fmt.Println()

	var d2 Deck
	err = json.Unmarshal([]byte(`{"cards":[1,2,3,8],"value":14,"size":4}`), &d2)
	fmt.Println("Unmarshal Error =>", err)
	fmt.Printf("Unmarshal Result => Size: %v, Cards: %v, Value: %v\n", d2.Size(), d2.Cards, d2.Value()) // could throw error if Size() and Value() is nil
}

func SizeOf(d *Deck) IntFunc {
	return func() int {
		return len(d.Cards)
	}
}

func ValueOf(d *Deck) IntFunc {
	return func() int {
		i := 0
		for _, v := range d.Cards {
			i += v
		}
		return i

	}
}

In general, yes. You'd have to use the the reflect package and essentially write your own marshaller.

With Go's encoding/json package, no.