Add ResultInt and clean up suggested Result implemenations

Author: znicholls

meson.build

@@ -69,6 +69,7 @@ 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/result_int.f90',
   )
 
   # All Python files (wrappers and otherwise)

src/example_fgen_basic/result/result.f90

@@ -12,7 +12,7 @@ module m_result
     !!
     !! Holds either the result or an error.
 
-        class(*), allocatable :: data(..)
+        class(*), allocatable :: data_v(..)
         !! Data i.e. the result (if no error occurs)
         !!
         ! Assumed rank array
@@ -31,9 +31,10 @@ module m_result
 
         private
 
-        procedure, public:: build, finalise, is_error
+        ! procedure, public:: build
         ! TODO: Think about whether build should be on the abstract class
         ! or just on each concrete implementation
+        procedure, public:: finalise, is_error
 
     end type Result
 
@@ -68,16 +69,33 @@ module m_result
     !
     ! end subroutine build
 
-    subroutine finalise(self)
+    function finalise(self) result(res)
         !! Finalise the instance (i.e. free/deallocate)
 
         class(Result), intent(inout) :: self
         ! Hopefully can leave without docstring (like Python)
 
-        deallocate(self % data)
-        deallocate(self % error)
+        type(ResultNone) :: res
 
-    end subroutine finalise
+        if (allocated(self % data_v) .and. allocated(self % error)) then
+            deallocate(self % data_v)
+            deallocate(self % error)
+            call res % build(message="Both data and error were allocated")
+
+        elseif (allocated(self % data_v)) then
+            deallocate(self % data_v)
+            ! No error - no need to call res % build
+
+        elseif (allocated(self % error)) then
+            deallocate(self % error)
+            ! No error - no need to call res % build
+
+        else
+            call res % build(message="Neither data nor error was allocated")
+
+        end if
+
+    end function finalise
 
     pure function is_error(self) result(is_err)
         !! Determine whether `self` contains an error or not
@@ -88,8 +106,7 @@ pure function is_error(self) result(is_err)
         logical :: is_err
         ! Whether `self` is an error or not
 
-        is_err = self % error_v % is_error()
-        ! TODO: implement is_error on `error_v`
+        is_err = allocated(self % error_v)
 
     end function is_error
 

src/example_fgen_basic/result/result_int.f90

@@ -0,0 +1,68 @@
+!> Result value 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
+
+    implicit none
+    private
+
+    type, extends(Result), public :: ResultInteger
+    !! Result type that holds integer values
+    !!
+    !! Holds either an integer value or an error.
+
+        integer, allocatable :: data_v
+        !! Data i.e. the result (if no error occurs)
+
+        class(ErrorV), allocatable :: error_v
+        !! Error
+
+    contains
+
+        private
+
+        procedure, public:: build
+        ! `finalise` and `is_error` come from abstract base class
+
+    end type ResultInteger
+
+    interface ResultInteger
+    !! Constructor interface - see build (TODO: figure out cross-ref syntax) for details
+        module procedure :: constructor
+    end interface ResultInteger
+
+contains
+
+    subroutine build(self, res, data_v, error_v)
+        !! Build instance
+
+        type(ResultInteger), intent(inout) :: self
+        ! Hopefully can leave without docstring (like Python)
+
+        type(ResultNone), intent(inout) :: res
+        !! Result
+
+        integer, optional, intent(in) :: data_v
+        !! Data
+
+        class(ErrorV), optional, intent(in) :: error_v
+        !! Error message
+
+        if (present(data_v) and present(error_v)) then
+            call res % build(message="Both data and error were provided")
+        elseif (present(data_v)) then
+            allocate(self % data_v, source=data_v)
+            ! No error - no need to call res % build
+        elseif (present(error_v)) then
+            allocate(self % error_v, source=error_v)
+            ! No error - no need to call res % build
+        else
+            call res % build(message="Neither data nor error were provided")
+        end if
+
+    end subroutine build
+
+end module m_result_int