Defer in Fortran
Fortran does not have a direct equivalent to the defer
keyword in Go. However, we can achieve similar functionality using subroutines and explicit calls. Here’s how we can implement a similar concept in Fortran:
program main
use iso_fortran_env, only: error_unit
implicit none
integer :: file_unit
call create_file("/tmp/defer.txt", file_unit)
call write_file(file_unit)
call close_file(file_unit)
end program main
subroutine create_file(filename, file_unit)
character(len=*), intent(in) :: filename
integer, intent(out) :: file_unit
integer :: iostat
print *, "creating"
open(newunit=file_unit, file=filename, status='replace', iostat=iostat)
if (iostat /= 0) then
print *, "Error opening file"
stop
end if
end subroutine create_file
subroutine write_file(file_unit)
integer, intent(in) :: file_unit
print *, "writing"
write(file_unit, *) "data"
end subroutine write_file
subroutine close_file(file_unit)
use iso_fortran_env, only: error_unit
integer, intent(in) :: file_unit
integer :: iostat
print *, "closing"
close(file_unit, iostat=iostat)
if (iostat /= 0) then
write(error_unit, *) "Error closing file"
stop 1
end if
end subroutine close_file
In this Fortran version, we’ve created a program that performs similar operations to the original example. Here’s a breakdown of the changes and explanations:
We define a main program that calls subroutines to create, write to, and close a file.
The
create_file
subroutine opens a file and returns the file unit number.The
write_file
subroutine writes data to the file.The
close_file
subroutine closes the file and checks for any errors during closing.We use explicit error handling with
iostat
to check for errors when opening and closing the file.Instead of using
defer
, we explicitly call theclose_file
subroutine at the end of the main program.
To run the program, you would typically compile it and then execute the resulting binary:
$ gfortran -o defer_example defer_example.f90
$ ./defer_example
creating
writing
closing
This Fortran implementation achieves a similar result to the original example, demonstrating file operations with proper error handling. While it doesn’t have the automatic deferred execution that Go’s defer
provides, it follows a similar pattern of ensuring that the file is closed after it’s been written to.