Fortran subroutine left to user - fortran

Question

I am trying in an object-oriented fashion to have a type that implements all functionalities, except for one function that should be implemented by the user.
Suppose I have two modules with types, an animal and a cat extending animal. Now I'd like to implement a way of passing a custom procedure to any animal. I don't know what is the best way of implementing such a feature. Right now I've succeeded in having all cat objects have a function caller that that will take a subroutine as an argument, but only if the type is explicit, or in other words, if the type is not an animal and at runtime I create a cat:
animal
module animal_module
implicit none
type, abstract :: animal
private
integer, public :: nlegs = -1
contains
procedure :: legs
procedure :: speak
end type animal
interface animal
module procedure init_animal
end interface animal
contains
type(animal) function init_animal(this)
class(animal), intent(inout) :: this
print *, "Animal!"
this%nlegs = -4
end function init_animal
function legs(this) result(n)
class(animal), intent(in) :: this
integer :: n
n = this%nlegs
end function legs
subroutine speak(this, ntimes)
class(animal), intent(in) :: this
integer, intent(in) :: ntimes
integer :: i
do i = 1, ntimes
print *, "generic animal :: speak"
end do
end subroutine speak
end module animal_module
cat
module cat_module
use animal_module, only : animal
implicit none
type, extends(animal) :: cat
private
real :: hidden = 23.
contains
! something like this? maybe a pointer?
procedure :: caller
procedure :: speak
end type cat
interface cat
module procedure init_cat
end interface cat
abstract interface
subroutine sub_interface
end subroutine
end interface
contains
type(cat) function init_cat()
print *, "Cat!"
init_cat%nlegs = 4
end function init_cat
subroutine caller(this, sub)
class(cat), intent(inout) :: this
procedure(sub_interface) :: sub
print *, "caller begin", this%nlegs
call sub()
print *, "caller ended", this%nlegs
end subroutine caller
subroutine speak(this, ntimes)
class(cat), intent(in) :: this
integer, intent(in) :: ntimes
integer :: i
do i = 1, ntimes
print *, "cat :: meow"
end do
end subroutine speak
end module cat_module
main program
subroutine ahoy
print *, "ahoy"
end subroutine ahoy
program oo
use animal_module
use cat_module
use bee_module
implicit none
class(animal), allocatable :: q
procedure(sub_interface) :: ahoy
class(cat), allocatable :: p
! THIS WON'T WORK
allocate(cat :: q)
q = cat()
call q%caller(ahoy)
! no problem with this
allocate(cat :: p)
p = cat()
call p%caller(ahoy)
end program
The error I am getting in calling caller from an animal is
/oo/main.F90(28): error #6460: This is not a field name that is defined in the encompassing structure. [CALLER]
call q%caller(ahoy)
-----------^
As far as I understand, this should normal: as animal has no clue a cat contains caller, it will not work. Am I right?
How can I let users implement a subroutine that will be called by a caller function? The called function should have access to the type, the user-provided function should be able to modify the hidden integer in a cat object.