Get fortran compiling

Author: znicholls

meson.build

@@ -69,8 +69,9 @@ if pyprojectwheelbuild_enabled
     'src/example_fgen_basic/get_wavelength.f90',
     'src/example_fgen_basic/kind_parameters.f90',
     'src/example_fgen_basic/result/result.f90',
-    'src/example_fgen_basic/result/result0D_int.f90',
     'src/example_fgen_basic/result/result_int.f90',
+    'src/example_fgen_basic/result/result_int1D.f90',
+    'src/example_fgen_basic/result/result_none.f90',
   )
 
   # All Python files (wrappers and otherwise)

src/example_fgen_basic/error_v/error_v.f90

@@ -37,7 +37,7 @@ module m_error_v
 
         procedure, public :: build
         procedure, public :: finalise
-        final :: clean_up
+        final :: finalise_auto
         ! get_res sort of not needed (?)
         ! get_err sort of not needed (?)
 
@@ -95,14 +95,17 @@ subroutine finalise(self)
 
     end subroutine finalise
 
-    subroutine clean_up(self)
+    subroutine finalise_auto(self)
         !! Finalise the instance (i.e. free/deallocate)
+        !!
+        !! This method is expected to be called automatically
+        !! by clever clean up, which is why it differs from [TODO x-ref] `finalise`
 
         type(ErrorV), intent(inout) :: self
         ! Hopefully can leave without docstring (like Python)
 
-        call self%finalise()
+        call self % finalise()
 
-    end subroutine clean_up
+    end subroutine finalise_auto
 
 end module m_error_v

src/example_fgen_basic/pyfgen_runtime/exceptions.py

@@ -18,6 +18,12 @@ def __init__(self, compiled_extension_name: str):
         super().__init__(error_msg)
 
 
+class FortranError(Exception):
+    """
+    Base class for errors that originated on the Fortran side
+    """
+
+
 class MissingOptionalDependencyError(ImportError):
     """
     Raised when an optional dependency is missing

src/example_fgen_basic/result/result.f90

@@ -9,23 +9,15 @@ module m_result
     implicit none (type, external)
     private
 
-    type, abstract, public :: Result
+    type, abstract, public :: ResultBase
     !! Result type
     !!
     !! Holds either the result or an error.
 
         ! class(*), allocatable :: data_v(..)
-        ! MZ: assumed rank can only be dummy argument NOT type/class argument
-        ! Data i.e. the result (if no error occurs)
-        !
-        ! Assumed rank array
-        ! (https://fortran-lang.discourse.group/t/assumed-rank-arrays/1049)
-        ! Technically a Fortran 2018 feature,
-        ! so maybe we need to update our file extensions.
-        ! If we can't use this, just comment this out
-        ! and leave each subclass of Result to set its data type
-        ! (e.g. ResultInteger will have `integer :: data`,
-        ! ResultDP1D will have `real(dp), dimension(:), allocatable :: data`)
+        ! assumed rank can only be dummy argument NOT type/class argument
+        ! hence leave this undefined
+        ! Sub-classes have to define what kind of data value they support
 
         class(ErrorV), allocatable :: error_v
         !! Error
@@ -34,35 +26,27 @@ module m_result
 
         private
 
+        ! Expect sub-classes to implement
         ! procedure, public:: build
-        ! TODO: Think about whether build should be on the abstract class
-        ! or just on each concrete implementation
         procedure, public :: is_error
-        procedure, public :: clean_up
+        ! Expect sub-classes to implement
+        ! procedure, public :: finalise
+        ! final :: finalise_auto
 
-    end type Result
+    end type ResultBase
 
-    !  interface Result
-    !! Constructor interface - see build (TODO: figure out cross-ref syntax) for details
+    ! Expect sub-classes to implement
+    ! interface ResultSubClass
+    !! Constructor interface - see build [cross-ref goes here] for details
     !    module procedure :: constructor
-    ! end interface Result
+    ! end interface ResultSubClass
 
 contains
 
-    subroutine clean_up(self)
-        !! Finalise the instance (i.e. free/deallocate)
-
-        class(Result), intent(inout) :: self
-        ! Hopefully can leave without docstring (like Python)
-
-        deallocate (self % error_v)
-
-    end subroutine clean_up
-
     pure function is_error(self) result(is_err)
         !! Determine whether `self` contains an error or not
 
-        class(Result), intent(in) :: self
+        class(ResultBase), intent(in) :: self
         ! Hopefully can leave without docstring (like Python)
 
         logical :: is_err

src/example_fgen_basic/result/result0D_int.f90

@@ -1,94 +1,127 @@
-!> Result value for integers
+!> Result type for integers
 !>
 !> Inspired by the excellent, MIT licensed
 !> https://github.com/samharrison7/fortran-error-handler
 module m_result_int
 
     use m_error_v, only: ErrorV
-    use m_result, only: Result
+    use m_result, only: ResultBase
+    use m_result_none, only: ResultNone
 
     implicit none (type, external)
     private
 
-    type, extends(Result), public :: ResultInteger1D
+    type, extends(ResultBase), public :: ResultInt
     !! Result type that holds integer values
-    !!
-    !! Holds either an integer value or an error.
 
-        integer, allocatable :: data_v(:)
+        integer, allocatable :: data_v
         !! Data i.e. the result (if no error occurs)
 
-        ! class(ErrorV), allocatable :: error_v
-        !! Error
+        ! Note: the error_v attribute comes from ResultBase
 
     contains
 
         private
 
         procedure, public :: build
-        ! `finalise` and `is_error` come from abstract base class
-        final :: finalise
+        procedure, public :: finalise
+        final :: finalise_auto
 
-    end type ResultInteger1D
+    end type ResultInt
 
-    interface ResultInteger1D
-    !! Constructor interface - see build (TODO: figure out cross-ref syntax) for details
+    interface ResultInt
+    !! Constructor interface - see build [TODO: x-ref] for details
         module procedure :: constructor
-    end interface ResultInteger1D
+    end interface ResultInt
 
 contains
 
     function constructor(data_v, error_v) result(self)
         !! Build instance
 
-        type(ResultInteger1D) :: self
+        type(ResultInt) :: self
         ! Hopefully can leave without docstring (like Python)
 
-        class(ErrorV), intent(inout), optional :: error_v
-        !! Error message
-
-        integer, allocatable, intent(in), optional :: data_v(:)
+        integer, intent(in), optional :: data_v
         !! Data
 
-        call self % build(data_v_in=data_v, error_v_in=error_v)
+        class(ErrorV), intent(in), optional :: error_v
+        !! Error
+
+        type(ResultNone) :: build_res
+
+        build_res = self % build(data_v_in=data_v, error_v_in=error_v)
+
+        if (build_res % is_error()) then
+
+            ! This interface has to return the initialised object,
+            ! it cannot return a Result type,
+            ! so we have no choice but to raise a fatal error here.
+            print *, build_res % error_v % message
+            error stop build_res % error_v % code
+
+        ! else
+            ! Assume no error occurred and initialisation was fine
+
+        end if
 
     end function constructor
 
-    subroutine build(self, data_v_in, error_v_in)
+    function build(self, data_v_in, error_v_in) result(res)
         !! Build instance
 
-        class(ResultInteger1D), intent(inout) :: self
+        class(ResultInt), intent(out) :: self
         ! Hopefully can leave without docstring (like Python)
 
-        integer, intent(in), optional :: data_v_in(:)
+        integer, intent(in), optional :: data_v_in
         !! Data
 
-        class(ErrorV), intent(inout), optional :: error_v_in
+        class(ErrorV), intent(in), optional :: error_v_in
         !! Error message
 
+        type(ResultNone) :: res
+        !! Result
+
         if (present(data_v_in) .and. present(error_v_in)) then
-            error_v_in % message = "Both data and error were provided"
+            res % error_v % message = "Both data and error were provided"
+
         else if (present(data_v_in)) then
             allocate (self % data_v, source=data_v_in)
             ! No error - no need to call res % build
+
         else if (present(error_v_in)) then
             allocate (self % error_v, source=error_v_in)
             ! No error - no need to call res % build
+
         else
-            error_v_in % message = "Neither data nor error were provided"
+            res % error_v % message = "Neither data nor error were provided"
+
         end if
 
-    end subroutine build
+    end function build
 
     subroutine finalise(self)
-      !! Finalise instance
+        !! Finalise the instance (i.e. free/deallocate)
 
-        type(ResultInteger1D), intent(inout) :: self
+        class(ResultInt), intent(inout) :: self
         ! Hopefully can leave without docstring (like Python)
 
         if (allocated(self % data_v)) deallocate (self % data_v)
-        if (allocated(self % error_v)) call self % clean_up()
+        if (allocated(self % error_v)) deallocate(self % error_v)
 
     end subroutine finalise
 
+    subroutine finalise_auto(self)
+        !! Finalise the instance (i.e. free/deallocate)
+        !!
+        !! This method is expected to be called automatically
+        !! by clever clean up, which is why it differs from [TODO x-ref] `finalise`
+
+        type(ResultInt), intent(inout) :: self
+        ! Hopefully can leave without docstring (like Python)
+
+        call self % finalise()
+
+    end subroutine finalise_auto
+
 end module m_result_int