use list comprehension instead of temporary array in the implementation of filter

Author: milancurcic

VERSION

@@ -1 +1 @@
-0.4.0
+0.4.1

src/lib/mod_functional.f90

@@ -906,15 +906,10 @@ pure function filter_i1(f, x) result(filter)
   !! This specific procedure is for 1-byte integers.
   !! Overloaded by generic procedure `filter`.
   procedure(f_i1_logical) :: f !! Filtering function
-  integer(i1), dimension(:), intent(in) :: x !! Input array
-  integer(i1), dimension(:), allocatable :: filter
-  logical, dimension(:), allocatable :: f_x
+  integer(i1), intent(in) :: x(:) !! Input array
+  integer(i1), allocatable :: filter(:)
   integer :: i
-  allocate(f_x(size(x)))
-  do concurrent(i = 1:size(x))
-    f_x(i) = f(x(i))
-  enddo
-  filter = pack(x, f_x)
+  filter = pack(x, [(f(x(i)), i = 1, size(x))])
 end function filter_i1
 
 
@@ -923,15 +918,10 @@ pure function filter_i2(f, x) result(filter)
   !! This specific procedure is for 2-byte integers.
   !! Overloaded by generic procedure `filter`.
   procedure(f_i2_logical) :: f !! Filtering function
-  integer(i2), dimension(:), intent(in) :: x !! Input array
-  integer(i2), dimension(:), allocatable :: filter
-  logical, dimension(:), allocatable :: f_x
+  integer(i2), intent(in) :: x(:) !! Input array
+  integer(i2), allocatable :: filter(:)
   integer :: i
-  allocate(f_x(size(x)))
-  do concurrent(i = 1:size(x))
-    f_x(i) = f(x(i))
-  enddo
-  filter = pack(x, f_x)
+  filter = pack(x, [(f(x(i)), i = 1, size(x))])
 end function filter_i2
 
 
@@ -940,15 +930,10 @@ pure function filter_i4(f, x) result(filter)
   !! This specific procedure is for 4-byte integers.
   !! Overloaded by generic procedure `filter`.
   procedure(f_i4_logical) :: f !! Filtering function
-  integer(i4), dimension(:), intent(in) :: x !! Input array
-  integer(i4), dimension(:), allocatable :: filter
-  logical, dimension(:), allocatable :: f_x
+  integer(i4), intent(in) :: x(:) !! Input array
+  integer(i4), allocatable :: filter(:)
   integer :: i
-  allocate(f_x(size(x)))
-  do concurrent(i = 1:size(x))
-    f_x(i) = f(x(i))
-  enddo
-  filter = pack(x, f_x)
+  filter = pack(x, [(f(x(i)), i = 1, size(x))])
 end function filter_i4
 
 
@@ -957,15 +942,10 @@ pure function filter_i8(f, x) result(filter)
   !! This specific procedure is for 8-byte integers.
   !! Overloaded by generic procedure `filter`.
   procedure(f_i8_logical) :: f !! Filtering function
-  integer(i8), dimension(:), intent(in) :: x !! Input array
-  integer(i8), dimension(:), allocatable :: filter
-  logical, dimension(:), allocatable :: f_x
+  integer(i8), intent(in) :: x(:) !! Input array
+  integer(i8), allocatable :: filter(:)
   integer :: i
-  allocate(f_x(size(x)))
-  do concurrent(i = 1:size(x))
-    f_x(i) = f(x(i))
-  enddo
-  filter = pack(x, f_x)
+  filter = pack(x, [(f(x(i)), i = 1, size(x))])
 end function filter_i8
 
 
@@ -974,15 +954,10 @@ pure function filter_r4(f, x) result(filter)
   !! This specific procedure is for 4-byte reals.
   !! Overloaded by generic procedure `filter`.
   procedure(f_r4_logical) :: f !! Filtering function
-  real(r4), dimension(:), intent(in) :: x !! Input array
-  real(r4), dimension(:), allocatable :: filter
-  logical, dimension(:), allocatable :: f_x
+  real(r4), intent(in) :: x(:) !! Input array
+  real(r4), allocatable :: filter(:)
   integer :: i
-  allocate(f_x(size(x)))
-  do concurrent(i = 1:size(x))
-    f_x(i) = f(x(i))
-  enddo
-  filter = pack(x, f_x)
+  filter = pack(x, [(f(x(i)), i = 1, size(x))])
 end function filter_r4
 
 
@@ -991,15 +966,10 @@ pure function filter_r8(f, x) result(filter)
   !! This specific procedure is for 8-byte reals.
   !! Overloaded by generic procedure `filter`.
   procedure(f_r8_logical) :: f !! Filtering function
-  real(r8), dimension(:), intent(in) :: x !! Input array
-  real(r8), dimension(:), allocatable :: filter
-  logical, dimension(:), allocatable :: f_x
+  real(r8), intent(in) :: x(:) !! Input array
+  real(r8), allocatable :: filter(:)
   integer :: i
-  allocate(f_x(size(x)))
-  do concurrent(i = 1:size(x))
-    f_x(i) = f(x(i))
-  enddo
-  filter = pack(x, f_x)
+  filter = pack(x, [(f(x(i)), i = 1, size(x))])
 end function filter_r8
 
 
@@ -1008,15 +978,10 @@ pure function filter_r16(f, x) result(filter)
   !! This specific procedure is for 16-byte reals.
   !! Overloaded by generic procedure `filter`.
   procedure(f_r16_logical) :: f !! Filtering function
-  real(r16), dimension(:), intent(in) :: x !! Input array
-  real(r16), dimension(:), allocatable :: filter
-  logical, dimension(:), allocatable :: f_x
+  real(r16), intent(in) :: x(:) !! Input array
+  real(r16), allocatable :: filter(:)
   integer :: i
-  allocate(f_x(size(x)))
-  do concurrent(i = 1:size(x))
-    f_x(i) = f(x(i))
-  enddo
-  filter = pack(x, f_x)
+  filter = pack(x, [(f(x(i)), i = 1, size(x))])
 end function filter_r16
 
 
@@ -1025,15 +990,10 @@ pure function filter_c4(f, x) result(filter)
   !! This specific procedure is for 4-byte reals.
   !! Overloaded by generic procedure `filter`.
   procedure(f_c4_logical) :: f !! Filtering function
-  complex(r4), dimension(:), intent(in) :: x !! Input array
-  complex(r4), dimension(:), allocatable :: filter
-  logical, dimension(:), allocatable :: f_x
+  complex(r4), intent(in) :: x(:) !! Input array
+  complex(r4), allocatable :: filter(:)
   integer :: i
-  allocate(f_x(size(x)))
-  do concurrent(i = 1:size(x))
-    f_x(i) = f(x(i))
-  enddo
-  filter = pack(x, f_x)
+  filter = pack(x, [(f(x(i)), i = 1, size(x))])
 end function filter_c4
 
 
@@ -1042,15 +1002,10 @@ pure function filter_c8(f, x) result(filter)
   !! This specific procedure is for 8-byte complex reals.
   !! Overloaded by generic procedure `filter`.
   procedure(f_c8_logical) :: f !! Filtering function
-  complex(r8), dimension(:), intent(in) :: x !! Input array
-  complex(r8), dimension(:), allocatable :: filter
-  logical, dimension(:), allocatable :: f_x
+  complex(r8), intent(in) :: x(:) !! Input array
+  complex(r8), allocatable :: filter(:)
   integer :: i
-  allocate(f_x(size(x)))
-  do concurrent(i = 1:size(x))
-    f_x(i) = f(x(i))
-  enddo
-  filter = pack(x, f_x)
+  filter = pack(x, [(f(x(i)), i = 1, size(x))])
 end function filter_c8
 
 
@@ -1059,15 +1014,10 @@ pure function filter_c16(f, x) result(filter)
   !! This specific procedure is for 16-byte complex reals.
   !! Overloaded by generic procedure `filter`.
   procedure(f_c16_logical) :: f !! Filtering function
-  complex(r16), dimension(:), intent(in) :: x !! Input array
-  complex(r16), dimension(:), allocatable :: filter
-  logical, dimension(:), allocatable :: f_x
+  complex(r16), intent(in) :: x(:) !! Input array
+  complex(r16), allocatable :: filter(:)
   integer :: i
-  allocate(f_x(size(x)))
-  do concurrent(i = 1:size(x))
-    f_x(i) = f(x(i))
-  enddo
-  filter = pack(x, f_x)
+  filter = pack(x, [(f(x(i)), i = 1, size(x))])
 end function filter_c16