[J3] Co-array question

[John Reid]

Malcolm,

We are in complete agreement here. My mistake was not to say explicitly 
I agree that it should not be a constraint. It should be a requirement.

Cheers,

John.



Malcolm Cohen via J3 wrote:
>
> Hi John,
>
> There is nothing out of the ordinary in the ALLOCATE statement in 
> itself. It is perfectly ordinary Fortran 2003.
>
> > In the context of F2018, it does not seem right that an allocation be
> allowed by referring to an object through a pointer but not by referring
> to the object directly.
>
> There’s nothing at all strange about this **not being a constraint**. 
> It’s a runtime thing. I already expressed my opinion that it’s not 
> standard-conforming at runtime anyway (no interpretation being 
> established), and my support for making the requirement explicit.
>
> We have tons of runtime requirements that cannot be constraints, all 
> over the standard. Even ones to do with type.
>
> Once again, the ALLOCATE on its own is perfectly ordinary, a CLASS(*) 
> allocatable being given the value from another CLASS(*) entity. This 
> is a common thing to do (usually with both being pointers though) with 
> heterogenous structures that use CLASS(*).
>
> And it’s not like it would be difficult in principle to detect 
> violation of the “no coarray components” rule at runtime in SOURCE=. 
> Just have a bit in the type header to indicate it.
>
> Cheers,
>
> -- 
>
> ..............Malcolm Cohen, NAG Oxford/Tokyo.
>
> *From:* J3 <j3-bounces at mailman.j3-fortran.org> *On Behalf Of *John 
> Reid via J3
> *Sent:* Friday, August 20, 2021 7:19 AM
> *To:* General J3 interest list <j3 at mailman.j3-fortran.org>
> *Cc:* John Reid <John.Reid at stfc.ac.uk>; Malcolm Cohen 
> <malcolm at nag-j.co.jp>
> *Subject:* Re: [J3] Co-array question
>
> Malcolm Cohen via J3 wrote:
> >
> > Mark LeAir writes:
> >
> > And is the following in violation of any constraint, or is it now a
> > conforming program?
> >
> > program main
> >
> >   type :: type
> >
> >     integer, allocatable :: coarray[:]
> >
> >   end type
> >
> >   type(type), save, target :: object
> >
> >   class(*), pointer :: pointer
> >
> >   class(*), allocatable :: allocatable
> >
> >   allocate(object%coarray[*]);
> >
> >   pointer => object
> >
> >   allocate(allocatable, source = pointer)
> >
> > end
> >
> > John Reid opines:
> >
> > I think we have an omission here. I see no constraint that disallows it
> > but it should not be allowed.
> >
> > My response:
> >
> > There is nothing here that warrants a constraint – the only
> > possibility would be to prohibit the pointer assignment: goodbye
> > bathwater, goodbye baby.
> >
> It is the allocate statement that is a problem, not the pointer 
> assignment.
> >
> > The pointer can of course be used safely, viz contexts other than as
> > input to SOURCE=.
> >
> Agreed.
> >
> > The program is, I think, non-conforming because the standard does not
> > say what happens. For normal allocatable components there would be a
> > copy made, but that doesn’t apply to coarray components so “no
> > interpretation is established”.
> >
> > I agree that a requirement on the dynamic type of source-expr (in
> > F2018) that it not have a coarray ultimate component would appear to
> > be desirable. (In F202x, that probably should only apply to SOURCE=.)
> >
> In the context of F2018, it does not seem right that an allocation be
> allowed by referring to an object through a pointer but not by referring
> to the object directly.
>
> John.
> >
> > Cheers,
> >
> > --
> >
> > ..............Malcolm Cohen, NAG Oxford/Tokyo.
> >
> > *From:* J3 <j3-bounces at mailman.j3-fortran.org 
> <mailto:j3-bounces at mailman.j3-fortran.org>> *On Behalf Of *Mark
> > LeAir via J3
> > *Sent:* Thursday, August 19, 2021 2:01 AM
> > *To:* fortran standards email list for J3 (j3 at mailman.j3-fortran.org 
> <mailto:j3 at mailman.j3-fortran.org>)
> > <j3 at mailman.j3-fortran.org <mailto:j3 at mailman.j3-fortran.org>>
> > *Cc:* Mark LeAir <mleair at nvidia.com <mailto:mleair at nvidia.com>>
> > *Subject:* [J3] Co-array question
> >
> > Hi,
> >
> > One of our engineers had the following questions about the co-arrays.
> > Can someone from the list answer them?
> >
> > Does the following program constitute a violation of F’2018 C949 (“The
> > declared type of /source-expr /shall not have a coarray ultimate
> > component.”)?
> >
> > program main
> >
> >   type :: type
> >
> >     integer, allocatable :: coarray[:]
> >
> >   end type
> >
> >   type(type), save, target :: object
> >
> >   class(*), allocatable :: allocatable
> >
> >   allocate(object%coarray[*]);
> >
> >   allocate(allocatable, source = object)
> >
> > end
> >
> > And is the following in violation of any constraint, or is it now a
> > conforming program?
> >
> > program main
> >
> >   type :: type
> >
> >     integer, allocatable :: coarray[:]
> >
> >   end type
> >
> >   type(type), save, target :: object
> >
> >   class(*), pointer :: pointer
> >
> >   class(*), allocatable :: allocatable
> >
> >   allocate(object%coarray[*]);
> >
> >   pointer => object
> >
> >   allocate(allocatable, source = pointer)
> >
> > end
> >
> > *Disclaimer*
> >
> > The Numerical Algorithms Group Ltd is a company registered in England
> > and Wales with company number 1249803. The registered office is: 30
> > St. Giles, Oxford, OX1 3LE, United Kingdom. Please see our Privacy
> > Notice <https://www.nag.co.uk/content/privacy-notice> for information
> > on how we process personal data and for details of how to stop or
> > limit communications from us.
> >
> > This e-mail has been scanned for all viruses and malware, and may have
> > been automatically archived by Mimecast Ltd, an innovator in Software
> > as a Service (SaaS) for business.
> >
>