Set and Set* don't support custom type

[oldme-git]

func TestI(t *testing.T) {
  type myInt int
  var i myInt = 123

  err := rdb.Set(ctx, "key", i, 0).Err()
  if err != nil {
    t.Fatal(err)
  }
}

result: redis: can't marshal * (implement encoding.BinaryMarshaler)

[OrHayat]

i got hit by this bug today is there reason why the fix was not merged?

[ndyakov]

since @oldme-git is not responding in PRs and it issues, if anyone would like to take a look at this - feel free, if not, we are going to consider it for v10.

[meshhi13]

I can take a look at this if it's alright.

[meshhi13]

Created PR, take a look!

[OrHayat]

@ndyakov @meshhi13

I didn't know you are willing to take fixes, I didn't see @ndyakov comment on my issue until the PR showed up.

While I think the fix is technically correct, there is a big room for improvement. The bug isn't really about named types. It's that WriteArg is a type switch on concrete Go
types, so anything that isn't exactly int, *int, string, ... falls through to the error. Adding a reflect fallback under that switch patches the reported case but keeps
the design that caused it. The read side has the same problem in a different form: every Cmd has a hand-written readReply.

I'd like to propose to do a new encoder/decoder like jsonv2 did with more flexaible appraoch to seiralzie/desrailze stuff

func (w *Writer) WriteArg(v any) error {
      switch v := v.(type) { // fast path for hot types, unchanged
      case string:
              return w.string(v)
      case []byte:
              return w.bytes(v)
      case int64:
              return w.int(v)
      case encoding.BinaryMarshaler:
              ...
      }
      return w.writeReflect(reflect.ValueOf(v)) // Kind switch, derefs pointers, recurses
}

That's roughly the shape the PR already has. The difference is treating the Kind switch as the real implementation and the concrete switch as an optimization, instead of the other
way around.

Another one: the read side

ScanDumpCmd.readReply today:

n, err := rd.ReadMapLen()   // BF.SCANDUMP replies *2 [iter, data], not a map
...
for i := 0; i < n; i++ {    // runs exactly once because ReadMapLen returns len/2
      iter, err := rd.ReadInt()
....
      data, err := rd.ReadString()
....
      cmd.val.Data = data
      cmd.val.Iter = iter
}

It works because 2/2 == 1. With a decoder that fills struct fields in declaration order from an array reply, the whole body becomes:

func (cmd *ScanDumpCmd) readReply(rd *proto.Reader) error {
      return proto.Decode(rd, &cmd.val)
}

There are 90 readReply bodies in the root package. Most of them are one of four shapes: scalar, slice of scalar, positional array into struct, or RESP3 map into struct (with a
RESP2 flat-array fallback). All four are expressible generically. The genuinely irregular ones (FT.SEARCH, CLUSTER SHARDS, version-dependent XINFO fields) keep a hand-written body
through a hook, same as UnmarshalerFrom in jsonv2:

type RESPUnmarshaler interface {
      UnmarshalRESPFrom(rd *proto.Reader) error
}

ill attempt an mvp/poc and see how it is going
if it will work as i think it can ill open pr or draft
either way its nice to see an annoying bug getting solved