Inject package session to methods without breaking interfaces

[dave]

We can't rely on injecting the PackageSession into methods because we break interfaces.

Consider:

var i int

type T struct{}

func (T) Write(data []byte) (int, error) {
    i++
    return 0, nil
}

func foo() {
    t := T{}
    fmt.Fprint(t, "foo")
}

We need access to the PackageSession inside the Write method, but we can't add it to the signature without no longer satisfying the io.Writer interface. I believe only solution is to add the PackageSession to T itself, so the code would become:

type T struct{
    psess *PacckageSession
}

func (t T) Write(data []byte) (int, error) {
    t.psess.i++
    return 0, nil
}

func (psess *PackageSession)foo() {
    t := T{
        psess: psess,
    }
    fmt.Fprint(t, "foo")
}

// in package-session.go:

type PackageSession struct {
    i int
}
...

This is complex enough if all types were structs. When you consider all non-struct types would need to be converted to structs is becomes a very hard problem - e.g.:

type T int

//...

t := T(1)

fmt.Println(t)

need to become:

type T struct{
    psess *PackageSession
    Value int
}

//...

t := T{
    psess: psess,
    Value: 1,
}

fmt.Println(t.Value)