generic matching error

[fowlmouth]

Error: ambiguous call; both a44.>>(left: PStream, right: var T): PStream and a44.>>(left: PStream, right: var T): PStream match for: (PStream, int16)

import streams

proc `>>` [T: int32|uint32|float32] (left: PStream; right: var T): PStream {.discardable.}=
  right = cast[t](left.readInt32)
  return left
proc `>>` [T: int16|uint16] (left:PStream; right:var T):PStream{.discardable.}=
  right = cast[t](left.readint16)
  return left
proc `>>` [T: int8|uint8|char|byte] (left: PStream; right: var T): PStream{.discardable.}=
  right = cast[T](left.readInt8)
  return left


var 
  x: int32
  y: int16
  z: int8
  stream = newStringStream("ABCDEFGJHSDOFIJ")
stream >> x >> y >> z

[fowlmouth]

Final module (havent tried this on devel branch)

import streams

type TScalar* = int8 | uint8 | byte | char | bool |
                int16| uint16| int32|uint32|
                float32|float64|int64|uint64

proc `>>`* [T: TScalar] (L: PStream; R: var T): PStream {.discardable.} =
  if L.readData(R.addr, sizeof(T)) != sizeof(T):
    raise newexception(eio, "exception message")
  L
proc `<<`* [T: TScalar] (L: PStream; R: T): PStream {.discardable.} =
  L.write R
  L

# length-encoded string. the length is int16
proc `>>`* (L: PStream; R: var string): PStream {.discardable.} =
  let len = L.readInt16 
  R = L.readStr(len)
  L
proc `<<`* (L: PStream; R: string): PStream {.discardable.} =
  L.write R.len.int16
  L.write R
  L

# fixed-length string
proc `>>`* [T] (L: PStream; R: var openarray[T]): PStream {.discardable.} =
  if L.readData(R[0].addr, R.len * sizeof(T)) != R.len * sizeof(T):
    raise newexception(eio,"exception message")
  L
proc `<<`* (L: PStream; fixedString: tuple[len: int, str: string]): PStream {.discardable.}=
  if fixedString.str.len < fixedString.len:
    L.write fixedString.str
    for i in fixedString.str.len .. < fixedString.len:
      L.write '\0'
  else:
    L.write fixedString.str[0 .. fixedString.len]
  L



when isMainModule:
  block:
    var s = newStringStream()
    block:
      s << 1'i8 << 2'i8 << (5,"foo")
      assert s.data == "\1\2foo\0\0"

      s << "xx"

    s.setPosition 0
    block:
      var i1, i2: int8
      var str: array[5,char]
      s >> i1 >> i2 >> str
      assert i1 == 1'i8
      assert i2 == 2'i8
      assert ($str == "foo")

      var str2: string
      s >> str2
      assert str2 == "xx"

  block:
    type TThing = object
      id: int32
      name: string

    proc `>>` (L:PSTREAM; R:VAR TTHING): PSTREAM {.discardable.}=
      L >> R.ID >> R.NAME

    var s = newStringStream()
    s.write "\1\0\0\0\1\0z"
    s.setPosition 0
    var t: TThing
    s >> t
    assert t == TThing(id: 1, name: "z")

[fowlmouth]

this is fixed