- Added support for construct for var in array { ... }

The code is natively translated into an equivalent Perl loop: `for my $var(@{array}) {...}`

Example:
	for i in [1,2,3,4] {
		say i;			# prints each element from the array
	}

MANIFEST

@@ -53,6 +53,7 @@ lib/Sidef/Types/Block/Do.pm
 lib/Sidef/Types/Block/Do.pod
 lib/Sidef/Types/Block/For.pm
 lib/Sidef/Types/Block/For.pod
+lib/Sidef/Types/Block/ForArray.pm
 lib/Sidef/Types/Block/Fork.pm
 lib/Sidef/Types/Block/Fork.pod
 lib/Sidef/Types/Block/Gather.pm
@@ -607,6 +608,7 @@ scripts/Tests/find_the_missing_permutation.sf
 scripts/Tests/first_class_functions_analogously.sf
 scripts/Tests/floyds_triangle.sf
 scripts/Tests/for_two_vars.sf
+scripts/Tests/for_var_in_array.sf
 scripts/Tests/forward_difference.sf
 scripts/Tests/function_composition.sf
 scripts/Tests/functional_modules.sf

META.json

@@ -152,6 +152,9 @@
       "Sidef::Types::Block::For" : {
          "file" : "lib/Sidef/Types/Block/For.pm"
       },
+      "Sidef::Types::Block::ForArray" : {
+         "file" : "lib/Sidef/Types/Block/ForArray.pm"
+      },
       "Sidef::Types::Block::Fork" : {
          "file" : "lib/Sidef/Types/Block/Fork.pm"
       },

META.yml

@@ -80,6 +80,8 @@ provides:
     file: lib/Sidef/Types/Block/Do.pm
   Sidef::Types::Block::For:
     file: lib/Sidef/Types/Block/For.pm
+  Sidef::Types::Block::ForArray:
+    file: lib/Sidef/Types/Block/ForArray.pm
   Sidef::Types::Block::Fork:
     file: lib/Sidef/Types/Block/Fork.pm
   Sidef::Types::Block::Gather:

lib/Sidef/Deparse/Perl.pm

@@ -846,6 +846,13 @@ HEADER
         elsif ($ref eq 'Sidef::Types::Block::For') {
             ## ok
         }
+        elsif ($ref eq 'Sidef::Types::Block::ForArray') {
+            $code =
+                'for my '
+              . $self->deparse_expr({self => $obj->{var}}) . '(@{'
+              . $self->deparse_expr({self => $obj->{array}}) . '})'
+              . $self->deparse_bare_block($obj->{block}->{code});
+        }
         elsif ($ref eq 'Sidef::Types::Block::If') {
             ## ok
         }

lib/Sidef/Deparse/Sidef.pm

@@ -387,6 +387,12 @@ package Sidef::Deparse::Sidef {
         elsif ($ref eq 'Sidef::Types::Block::Loop') {
             $code = 'loop ' . $self->deparse_expr({self => $obj->{block}});
         }
+        elsif ($ref eq 'Sidef::Types::Block::ForArray') {
+            $code = 'for '
+              . $self->deparse_expr({self => $obj->{var}}) . ' in ('
+              . $self->deparse_expr({self => $obj->{array}}) . ') '
+              . $self->deparse_bare_block($obj->{block}->{code});
+        }
         elsif ($ref eq 'Sidef::Math::Math') {
             $code = 'Math';
         }

lib/Sidef/Parser.pm

@@ -2243,7 +2243,56 @@ package Sidef::Parser {
         if (defined $obj) {
             push @{$struct{$self->{class}}}, {self => $obj};
 
-            if ($obj_key) {
+            # for var in array { ... }
+            if (ref($obj) eq 'Sidef::Types::Block::For' and /\Gfor\h+($self->{var_name_re})\h+in\h+/gc) {
+                my ($var_name, $class_name) = $self->get_name_and_class($1);
+
+                my $array = (
+                             /\G(?=\()/
+                             ? $self->parse_arguments(code => $opt{code})
+                             : $self->parse_obj(code => $opt{code})
+                            );
+
+                my $variable = Sidef::Variable::Variable->new(
+                                                              class => $class_name,
+                                                              name  => $var_name,
+                                                              type  => 'var',
+                                                             );
+
+                my $vars_len = $#{$self->{vars}{$class_name}} + 1;
+
+                unshift @{$self->{vars}{$class_name}},
+                  {
+                    obj   => $variable,
+                    name  => $var_name,
+                    count => 1,
+                    type  => 'var',
+                    line  => $self->{line},
+                  };
+
+                my $block = (
+                             /\G\h*(?=\{)/gc
+                             ? $self->parse_block(code => $opt{code})
+                             : $self->fatal_error(
+                                                  error => "expected a block after the token 'in': for $var_name in { ... }",
+                                                  code  => $_,
+                                                  pos   => pos($_),
+                                                 )
+                            );
+
+                # Remove the loop variable from the current scope
+                splice(@{$self->{vars}{$class_name}}, $#{$self->{vars}{$class_name}} - $vars_len, 1);
+
+                # Replace the old Block::For object with Block::ForArray
+                $struct{$self->{class}}[-1]{self} =
+                  Sidef::Types::Block::ForArray->new(
+                                                     var   => $variable,
+                                                     block => $block,
+                                                     array => $array,
+                                                    );
+            }
+
+            elsif ($obj_key) {
                 my ($method) = $self->get_method_name(code => $opt{code});
                 if (defined $method) {
 

lib/Sidef/Types/Block/ForArray.pm

@@ -0,0 +1,9 @@
+package Sidef::Types::Block::ForArray {
+
+    sub new {
+        my (undef, %opt) = @_;
+        bless \%opt, __PACKAGE__;
+    }
+}
+
+1;

scripts/Tests/for_var_in_array.sf

@@ -0,0 +1,29 @@
+#!/usr/bin/ruby
+
+var arr = [1,2,3,4];
+
+for i in arr {
+    next if i==2;
+    if (i == 2) {
+        die "next error!";
+    }
+}
+
+var i = 42;
+assert_eq(i, 42);
+
+for i in arr {
+    break if i==2;
+    if (i >= 2) {
+        die "break error!";
+    }
+}
+
+assert_eq(i, 42);
+i = 99;
+
+for i in arr {
+    say i;
+}
+
+assert_eq(i, 99);