generic_concepts.nim

type
  Foo[T] = concept x
    x.foo(T)

proc foobar[T](f: Foo[T]) =
  f.foo(42)


type
  FooImpl[T, U] = object
    a: T
    b: U

proc foo[T, U](f: FooImpl[T, U], t: T) =
  echo $t


when isMainModule:
  var f: FooImpl[int, float]

  echo f is Foo[int]  # true

  f.foo(42)           # 42

  f.foobar            # Error: type mismatch: got (FooImpl[system.int, system.float])
                      # but expected one of: 
                      #   foo.foobar(f: Foo[foobar.T])

U is not essential for this to fail:

type
  Foo[T] = concept x
    x.foo(T)

proc foobar[T](f: Foo[T]) =
  f.foo(42)


type
  FooImpl[T] = object
    a: T

proc foo[T](f: FooImpl[T], t: T) =
  echo $t


when isMainModule:
  var f: FooImpl[int]

  echo f is Foo[int]  # true

  f.foo(42)           # 42

  f.foobar            # Error: type mismatch: got (FooImpl[system.int)
                      # but expected one of: 
                      #   foo.foobar(f: Foo[foobar.T])

even T is not needed in the impl type:

type
  Foo[T] = concept x
    x.foo(T)

proc foobar[T](f: Foo[T]) =
  f.foo(42)


type
  FooImpl = object

proc foo(f: FooImpl, t: int) =
  echo $t


when isMainModule:
  var f: FooImpl

  echo f is Foo[int]  # true

  f.foo(42)           # 42

  f.foobar            # Error: type mismatch: got (FooImpl)
                      # but expected one of: 
                      #   foo.foobar(f: Foo[foobar.T])

Workaround:

type
  Foo[T] = concept x
    type Z = x.T                     # <---
    x.foo(Z)

proc foobar(f: Foo) =            # <---
  f.foo(42)


type
  FooImpl[T, U] = object
    a: T
    b: U

proc foo[T, U](f: FooImpl[T, U], t: T) =
  echo $t


when isMainModule:
  var f: FooImpl[int, float]

  echo f is Foo[int]  # true

  f.foo(42)           # 42

  f.foobar            # 42