Traits, Generics, and modern-day OO for Fortran

Announcements
81

Nice effort, kudos - the Fortran language development endeavor needs this.

But it’s way too long for me to study fully and to offer anything comprehensively constructive at this time.

One thing though that immediately caught my attention and which, in my “Fortran book,” is fundamentally wrong is to view the following as an “interface”:

   abstract interface :: INumeric
      integer(*) | real(*) | complex(*)
   end interface

A better term shall be entity over interface

82

If you have the time to check out the following Introduction to Go generics, then you’ll see that type sets are interfaces, in the very classical sense.

83

Note it’s entirely in the context of Fortran and its language standard the term “interface” becomes inappropriate

84

i think it’s not an issue of context, but of syntax (or lack thereof).

if Having a value is equivalent to having a function that returns said value, then an interface can represent both.

Since Fortran is purposely explicit, maybe a better approach would be something like:

type interface :: INumeric
    integer(*)
    real(*)
    complex(*)
end interface

abstract interface :: ISum{INumeric :: T}
   function sum(self,x) result(s)
      deferred(self), intent(in) :: self
      type(T),        intent(in) :: x(:)
      type(T)                    :: s
   end function
end interface
85

This sounds quite handy. Thank you.

1 Like
86

I just want to note that I haven’t been ignoring this, but I am trying to find time to come up with examples and responses. Unfortunately that may not be until after the upcoming J3 meeting. Whilst you have made some good points and addressed at least one of my concerns, I think there are still some counter examples to be made.

One quick response wrt to the use of type-sets that I have thought of a new way to formulate. I don’t think they qualify as generic programming. Namely, rather than being a way of writing a generic algorithm, they instead are a shorthand for writing a set of specific implementations of that algorithm. Whilst it may be relatively easy, it does require modifying the existing code to extend it to new types.

3 Likes
87

I am happy to announce, that we have meanwhile revised our traits-based polymorphism design for Fortran, in order to refine it and to generalize it significantly, while making its syntax even more concise. The following list summarizes the changes:

  1. Passed-object dummy arguments were removed from traits. They are now only required to be provided in actual implementations (as in Go). This has obviated the need to use associated types for the declaration of such arguments.

  2. The deferred declaration specifier for associated types has been dropped in favor of declaring associated type names via typedef statements. This allows for the reuse of such names in a trait.

  3. A predefined associated type, itself, to refer to the implementing type, is available.

  4. The signatures of both ordinary procedures, operators, and initializers (i.e. constructors) for types are now all allowed to appear in traits.

  5. Overloaded versions of all these signatures can be specified as well.

  6. The implements statement, and the contains sections of derived types, now provide improved syntax to concisely implement all of the above items. Among other things, this adds type-bound initializers to Fortran.

  7. The previously proposed type casting functionality for generics has been extended. It now works regardless of whether the type to be cast to is language- or user-defined (a feature that was borrowed from Swift).

  8. Fortran’s present, valuable, restriction, of prohibiting its language-intrinsic operators from being overloaded for intrinsic types, can now be honored and enforced by a compiler.

  9. Structural subtyping (a la Go), to supplement the nominal subtyping (a la Swift and Rust) and to thus improve code conciseness even further (as it was done in Mojo), has been added as a candidate for future inclusion into the design.

Check out the newest, significantly updated, version of our document for discussions and illustrations of all these improvements, using revised examples of our Rust, Swift, and Fortran codes!

8 Likes