Pure procedure and intent(out) polymorphic pointer argument

ivanpribec · November 12, 2024, 10:10pm

In case of pointer arguments, intent applies to the association status and not the target. It’s surprising. See this discussion: Meaning of the intent for pointer dummy arguments

As to the original question, you can find some discussion on this constraint here:

github.com/j3-fortran/fortran_proposals

Constructing Objects With Polymorphic Components Not Possible in Pure Context?

opened 10:53PM - 21 Dec 20 UTC

everythingfunctional

Clause 15

Given the following constraints from the standard: > C1585 The function resul…t of a pure function shall not be both polymorphic and allocatable, or have a polymorphic allocatable ultimate component. > C1588 An INTENT (OUT) dummy argument of a pure procedure shall not be polymorphic or have a polymorphic allocatable ultimate component. it seems it would not be possible to write (let alone call in a pure context) a constructor for an object with a polymorphic component that is pure. To my mind this eliminates an entire class of data structures that one would find useful (and expect to be useable) in a pure context. For example, a simple binary tree of integers might be expected to be implemented like the following. ```Fortran module tree_m implicit none private public :: tree_t, node, leaf type, abstract :: tree_t contains procedure(sum_i), deferred :: sum end type abstract interface pure function sum_i(self) result(sum) class(tree_t), intent(in) :: self integer :: sum end function end interface type, extends(tree_t) :: node_t private class(tree_t), allocatable :: left, right contains procedure :: sum => node_sum end type type, extends(tree_t) :: leaf_t private integer :: val contains procedure :: sum => leaf_sum end type contains pure function node_constructor(left, right) result(node) ! pure not allowed class(tree_t), intent(in) :: left, right type(node_t) :: node allocate(node%left, source = left) allocate(node%right, source = right) end function pure function leaf_constructor(val) result(leaf) integer, intent(in) :: val type(leaf_t) :: leaf leaf%val = val end function pure function node_sum(self) result(sum) class(node_t), intent(in) :: self integer :: sum sum = self%left%sum() + self%right%sum() end function pure function leaf_sum(self) result(sum) class(leaf_t), intent(in) :: self integer :: sum sum = self%val end function end module ``` and then be able to use it like the following in a pure context. ```Fortran class(tree_t), allocatable :: local_tree integer :: total allocate(tree, source = node(node(leaf(1), leaf(2)), leaf(3))) total = tree%sum() ``` But, even though the node constructor * does not modify its inputs * does not reference (let alone modify) any other entities * does not perform any IO it still cannot be made pure due to the above constraints. Does anyone know why (or if) these constraints are necessary? It seems most compilers are not enforcing them.

Topic		Replies	Views
A dummy target in a pure subroutine must be intent(inout) (?) Help	6	240	April 19, 2024
Polymorphic behavior of derived types	6	1002	October 13, 2022
Final procedure for polymorphic base type Help	4	569	August 10, 2022
Smart-Pointers 2.2.0 released Announcements	5	827	April 4, 2023
Example from N1601 Fortran 2003 final draft invalid?	4	471	February 2, 2021

Pure procedure and intent(out) polymorphic pointer argument

Related topics