Yes, the examples should probably have read something like:

```
julia> methods(f, (Float64,))
# 1 method for generic function "f":
[1] f(x::AbstractFloat) in Main at REPL[3]:1
julia> methods(f, (Int,))
# 1 method for generic function "f":
[1] f(x::Integer) in Main at REPL[2]:1
```

But I think it does not really solve your problem: it tells you which method is used for a particular set of arguments types, rather than telling you the list of all possible argument types for a given method.

I don’t know how to solve your problem directly, but I would perhaps simplify it to the following one, which might be easier to solve: given a type T, is it possible to list all subtyes of T?

A good start for this simplified question would be to use `subtypes`

:

```
julia> subtypes(AbstractVector{Real})
10-element Array{Any,1}:
AbstractRange{Real}
Base.LogicalIndex{Real,A} where A<:(AbstractArray{Bool,N} where N)
Base.ReinterpretArray{Real,1,S,A} where A<:AbstractArray{S,1} where S
Base.ReshapedArray{Real,1,P,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where P<:AbstractArray
Core.Compiler.AbstractRange{Real}
DenseArray{Real,1}
PermutedDimsArray{Real,1,perm,iperm,AA} where AA<:AbstractArray where iperm where perm
SparseArrays.AbstractSparseArray{Real,Ti,1} where Ti
SubArray{Real,1,P,I,L} where L where I where P
Test.GenericArray{Real,1}
```

```
julia> subtypes(AbstractVector{<: Real})
14-element Array{Any,1}:
AbstractRange{T} where T<:Real
Base.LogicalIndex{T,A} where A<:(AbstractArray{Bool,N} where N) where T<:Real
Base.ReshapedArray{T,1,P,MI} where MI<:Tuple{Vararg{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int64},N} where N} where P<:AbstractArray where T<:Real
BitArray{1}
Core.Compiler.AbstractRange{T} where T<:Real
Core.Compiler.BitArray{1}
Core.Compiler.LinearIndices{1,R} where R<:Tuple{Core.Compiler.AbstractUnitRange{Int64}}
DenseArray{T,1} where T<:Real
LinearIndices{1,R} where R<:Tuple{AbstractUnitRange{Int64}}
PermutedDimsArray{T,1,perm,iperm,AA} where AA<:AbstractArray where iperm where perm where T<:Real
SparseArrays.AbstractSparseArray{Tv,Ti,1} where Ti where Tv<:Real
SubArray{T,1,P,I,L} where L where I where P where T<:Real
Test.GenericArray{T,1} where T<:Real
Union{ReinterpretArray{T,1,S,A} where A<:AbstractArray{S,1} where S, ReinterpretArray{T,1,S,A} where A<:AbstractArray{S,1} where S} where T<:Real
```

(you could also apply it recursively to replace all abstract types in the list with the list of their own subtypes, but I would tend to think that this would make the list grow qhickly to unmanageable length)