stored-procedures - transact - stored procedure with return value sql

Fortran guardar procedimiento como propiedad en tipo derivado

Question

¿Es posible almacenar un procedimiento como una propiedad de un tipo derivado? Estaba pensando en algo como:

  module funcs_mod
  public :: add
  contains
  function add(y,z) result (x)
    integer,intent(in) :: y,z
    integer :: x
    x = y + z
  end function
  end module

  module type_A_mod
  use funcs_mod
  public :: type_A,set_operator
  type type_A
    procedure(),pointer,nopass :: operator
  end type
  contains
  subroutine set_operator(A,operator)
    external :: operator
    type(type_A),intent(inout) :: A
    A%operator => operator
  end subroutine
  function operate(A,y,z) result(x)
    type(type_A),intent(in) :: A
    integer,intent(in) :: y,z
    integer :: x
    x = A%operator(y,z)
  end function
  end module

  program test
  use type_A_mod
  use funcs_mod
  type(type_A) :: A
  call set_operator(A,add)
  write(*,*) operate(A,1,2)
  end program

Pero esto no se compila correctamente. Se muestran varios errores, incluyendo:

1) Error de sintaxis en el componente de puntero de procedimiento

y

2) ''operator'' en (1) no es miembro de la estructura ''type_a''

Además de algunas declaraciones de uso sin éxito. ¿Hay alguna manera de hacer esto correctamente? Cualquier ayuda es muy apreciada.

ACTUALIZAR:

He modificado el procedure,pointer a procedure(),pointer y ahora los errores son

1) El atributo FUNCTION entra en conflicto con el atributo SUBROUTINE en ''operator''

y

2) No se puede convertir DESCONOCIDO en INTEGER (4)

Ambos se refieren a la línea x = A%operator(y,z)

Answer 1

Como ha descubierto, la sintaxis para declarar una declaración de puntero de procedimiento requiere procedure([interface]), pointer [, ...] :: ... Usted eligió procedure(), pointer, nopass :: operator .

La consecuencia del procedure() es que no está declarando si el operator es una función o una subrutina. No hay nada de malo en esto, pero luego queda más trabajo en convencer al compilador de que está utilizando las referencias de manera consistente. Parece que tu compilador no te cree.

En lugar de entrar en detalles de lo que el compilador cree que quiere decir, tomaré un enfoque diferente.

Hace referencia al A%operator para una estructura A de tipo con ese componente como resultado de la función de operate . Usted dice claramente al declarar esta última función que su resultado es un número entero.

Ahora, suponiendo que no quiere hacer cosas emocionantes con la conversión tipo / tipo para llegar a ese resultado entero, consideraremos que siempre tiene la intención de que A%operator sea ​​una función con un resultado entero. Eso significa que puede declarar que el componente de puntero a procedimiento es una función con resultado entero.

Esto todavía te deja con opciones:

type type_A
  procedure(integer),pointer,nopass :: operator
end type

siendo una función con resultado entero e interfaz implícita, y

type type_A
  procedure(add),pointer,nopass :: operator
end type

siendo una función con interfaz explícita que coincide con la función add .

Sus opciones de diseño en curso informan su decisión final.

Como nota final, no está utilizando implicit none . Esto es importante cuando consideramos su línea

external :: operator

Si el operator es una función, entonces (por reglas implícitas de tipado) tiene un resultado real (predeterminado). Entonces, quiere cambiar a uno de los siguientes

integer, external :: operator

o

procedure(integer) :: operator

o

procedure(add) :: operator

Para concluir, y hacerse eco del comentario de Vladimir F, piense detenidamente en su diseño. Actualmente tiene restricciones de la referencia de operate (en el resultado de la función y sus argumentos) que parece que realmente sabe que el componente tendrá una interfaz específica. Si está seguro de eso, entonces use el procedure(add) como la declaración /