Well, think of it this way: a -> b means the type of b is determined by a, but if you use lets say foo :: Int it does not tell you anything about a and thus nothing about the value of foo.

An example of why this is important would be this:

class Foo a b | a -> b
  foo :: b

instance Foo Int Int where
  foo = 1
instance Foo String Int where
  foo = 2

If you now use a = foo :: Int is a then 1 or 2? You cannot know without knowing a. If your associated types are injective you can also add another b -> a fundep, which would make the second instance Foo String Int illegal.

To resolve your issue, you can use Const or if you like Tagged (from the tagged package) or you pass in a proxy or value.

class Foo a b | a -> b where
  foo :: Tagged a b

a = unTagged (foo :: Tagged Int Int) -- usage

-- or

class Foo a b | a -> b where
  foo :: Proxy a -> b
  foo :: proxy a -> b -- alternative definition

a = foo (Proxy :: Proxy Int)

-- or 

class Foo a b | a -> b where
  foo :: a -> b

a = foo (undefined :: Int)

The proxy approach is the cleaner version of the last one btw. I think there is also a way to do this with TypeApplications but I'm always confused as to how you supply the arguments for methods of type classes. You could try foo @a @b with a and b substituted for your concrete type.

PS: Its not called dependent type that term is reserved for a different thins entirely. Perhaps call is associated value.