Add square root for easier illustration

Author: znicholls

meson.build

@@ -66,9 +66,11 @@ if pyprojectwheelbuild_enabled
     'src/example_fgen_basic/error_v/passing.f90',
     'src/example_fgen_basic/fpyfgen/base_finalisable.f90',
     'src/example_fgen_basic/fpyfgen/derived_type_manager_helpers.f90',
+    'src/example_fgen_basic/get_square_root.f90',
     '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_dp.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',

scripts/inject-srcs-into-meson-build.py

@@ -93,6 +93,7 @@ def main():
             meson_variable, sorted(src_paths), REPO_ROOT
         )
 
+        # TODO: something wrong in here
         meson_build_out = re.sub(pattern, substitution, meson_build_out)
 
     with open(REPO_ROOT / "meson.build", "w") as fh:

src/example_fgen_basic/get_square_root.f90

@@ -0,0 +1,36 @@
+!> Get square root of a number
+module m_get_square_root
+
+    use kind_parameters, only: dp
+    use m_error_v, only: ErrorV
+    use m_result_dp, only: ResultDP
+
+    implicit none(type, external)
+    private
+
+    public :: get_square_root
+
+contains
+
+    function get_square_root(inv) result(res)
+        !! Get square root of a number
+
+        real(kind=dp), intent(in) :: inv
+        !! Frequency
+
+        type(ResultDP) :: res
+        !! Result
+        !!
+        !! Square root if the number is positive or zero.
+        !! Error otherwise.
+
+        if (inv >= 0) then
+            res = ResultDP(data_v=sqrt(inv))
+        else
+            ! TODO: include input value in the message
+            res = ResultDP(error_v=ErrorV(code=1, message="Input value was negative"))
+        end if
+
+    end function get_square_root
+
+end module m_get_square_root

src/example_fgen_basic/result/result_dp.f90

@@ -0,0 +1,128 @@
+!> Result type for double precision real values
+!>
+!> Inspired by the excellent, MIT licensed
+!> https://github.com/samharrison7/fortran-error-handler
+module m_result_dp
+
+    use kind_parameters, only: dp
+    use m_error_v, only: ErrorV
+    use m_result, only: ResultBase
+    use m_result_none, only: ResultNone
+
+    implicit none (type, external)
+    private
+
+    type, extends(ResultBase), public :: ResultDP
+    !! Result type that holds integer values
+
+        real(kind=dp), allocatable :: data_v
+        !! Data i.e. the result (if no error occurs)
+
+        ! Note: the error_v attribute comes from ResultBase
+
+    contains
+
+        private
+
+        procedure, public :: build
+        procedure, public :: finalise
+        final :: finalise_auto
+
+    end type ResultDP
+
+    interface ResultDP
+    !! Constructor interface - see build [TODO: x-ref] for details
+        module procedure :: constructor
+    end interface ResultDP
+
+contains
+
+    function constructor(data_v, error_v) result(self)
+        !! Build instance
+
+        type(ResultDP) :: self
+        ! Hopefully can leave without docstring (like Python)
+
+        real(kind=dp), intent(in), optional :: data_v
+        !! Data
+
+        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
+
+    function build(self, data_v_in, error_v_in) result(res)
+        !! Build instance
+
+        class(ResultDP), intent(out) :: self
+        ! Hopefully can leave without docstring (like Python)
+
+        real(kind=dp), intent(in), optional :: data_v_in
+        !! Data
+
+        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
+            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
+            res % error_v % message = "Neither data nor error were provided"
+
+        end if
+
+    end function build
+
+    subroutine finalise(self)
+        !! Finalise the instance (i.e. free/deallocate)
+
+        class(ResultDP), intent(inout) :: self
+        ! Hopefully can leave without docstring (like Python)
+
+        if (allocated(self % data_v)) deallocate (self % data_v)
+        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(ResultDP), intent(inout) :: self
+        ! Hopefully can leave without docstring (like Python)
+
+        call self % finalise()
+
+    end subroutine finalise_auto
+
+end module m_result_dp

tests/unit/test_error_v_creation.py

@@ -29,6 +29,7 @@ def test_create_error_even():
     assert res.message == "Even number supplied"
 
 
+@pytest.mark.xfail(reason="Not implemented")
 def test_create_error_negative_raises():
     # TODO: switch to more precise error type
     with pytest.raises(FortranError):