Returning JSON structs of different types, dynamically?

I'm playing around with Go and having trouble adapting some of my "inheriting" designs from other languages to its structure. I've coded in OCaml and some other languages bearing a similar structure, but I'm confused. Without type inheritance it becomes a bit strange to return JSON from different places using shared structures.

I have to iterate recursively through input data as needed to build a single JSON object to respond with.

Take for instance:

{
    "appVersion": "1.0.0",
    "messageStatus": "received"
}

... and:

{
    "appVersion": "1.0.0",
    "uploadStatus": "received"
}

The only way I can find to make this work in Go so far is to copy and paste the base structure that includes "appVersion" into the two output generating functions separately, but I don't want to do that because I don't want to have to maintain the same set of code twice.

Here's where I'm stuck trying to fix that:

type JSONResponse struct {
    appVersion string
}
type MessageJSONResponse struct {
    JSONResponse
    messageStatus string
}
type UploadJSONResponse struct {
    JSONResponse
    uploadStatus string
}

... Then:

type Message struct {
	formattingVersion *int

}

func NewMessageObject(r *http.Request) (bool, *MessageJSONResponse) {
	message := new(Message)

	if (true) {
		// #TODO: INSERT LOGIC HERE!
		*message.formattingVersion = 2;

	}

	if (message.formattingVersion != nil) {
		response := new(MessageJSONResponse)
		response.messageStatus = "OK"

		return false, errorResponse

	}

	return true, nil

}

... And:

func init() {
	http.Handle("/endpoints/message", JSONResponseHandler(messageHandler))

}

func JSONResponseHandler(h func (w http.ResponseWriter, r *http.Request) interface {}) http.Handler {

// #TODO - convert `JSONResponse` into actual JSON or output JSON Error!

}

func messageHandler(w http.ResponseWriter, r *http.Request) JSONResponse { // #BROKEN TYPES?

	hasError, messageResponse := NewMessageObject(r)
	if (hasError || messageResponse==nil) { return nil } // #TODO
	////

	// #TODO ... more message things.

	return messageResponse;

};

This approach (sorry for any code mistakes, really long day and I'm headed to bed) doesn't work because in order to pass the varied return values around... the type can't change, etc.

The JSONResponseHandler wrapper method actually works on my end but only with the interface {} type given the variations in type... so I've left it out since it'd clutter up the code. However, if I use interface {} on subsequent blocks with optional asterisked return properties (such as "NewMessageObject"), the JSON constructors seems to ignore those values since they're wrapped in an empty interface instead of just exposed as their raw type. However, they have to have a nil option....

What's wrong? The design in general? I'm basically trying to build a JSON object response (or return with a JSON-formatted error) through subsequent calls based on input data... in a neatly abstracted way.

To solve your json issue, you could use one struct and tag each field with json:"omitempty":

package main

import (
    "encoding/json"
    "fmt"
)

type foostruct struct {
    Myfoo   string `json:"myfoo,omitempty"`
    Yourfoo string `json:"yourfoo,omitempty"`
    Ourfoo string `json:"ourfoo,omitempty"`
}

func main() {
    j := []byte("{\"myfoo\":\"mine\", \"yourfoo\":\"yours\"}")
    fstruct := &foostruct{}
    err := json.Unmarshal(j, fstruct)
    if err != nil {
	    panic(err)
    }

    b, err := json.Marshal(fstruct)
    if err != nil {
	    panic(err)
    }

    fmt.Println(string(b))
}

You'll see the the output does not contain the field "ourfoo":

{"myfoo":"mine","yourfoo":"yours"}

Try it out here:
http://play.golang.org/p/zKwFaxbLJu

I use map instead of struct on my application, especially when I want to return back a json answer to client. Its give me more flexibility. Please take a look this :

package main

import (
	"encoding/json"
	"fmt"
)

func main() {
	m := make(map[string]interface{})
	m["appVersion"] = "0.0.1"
	m["uploadStatus"] = "success"

	strJson, _ := json.Marshal(m)
	str := string(strJson)
	fmt.Println("---ENCODING--")
	fmt.Println(str)

	//put it back
	fmt.Println("---DECODING--")
	n := make(map[string]interface{})
	json.Unmarshal([]byte(str), &n)
	for key, val := range n {
		fmt.Println(key, ":", val)
	}
}

and the output is :

---ENCODING--
{"appVersion":"0.0.1","uploadStatus":"success"}
---DECODING--
appVersion : 0.0.1
uploadStatus : success

You can check here : http://play.golang.org/p/h4b4-nkZ4M