- Changed the behavior of the given/when method; now it calls '~~' in…

…stead of '=='

- Added the given/exact method which calls '==' internally.
- given/> now points to given/exact
- given/~ now points to given/when

Example:
	given("hello")
	   when("e") 	  { say "when"; continue  }   # true ("hello" contains "e")
	   when(/^he/)    { say "when2"; continue }   # true ("hello" matches /^he/)
	   exact("hello") { say "exact"; continue }   # true ("hello" == "hello")

- Improved the smart-match operator (~~) to make a finall '==' call before returning false.

MANIFEST

@@ -394,6 +394,7 @@ scripts/quicksort.sf
 scripts/quicksort_in_parallel.sf
 scripts/quoted_strings.sf
 scripts/rand.sf
+scripts/read_a_configuration_file.sf
 scripts/rec_reverse.sf
 scripts/recursion.sf
 scripts/regex.sf

lib/Sidef/Object/Object.pm

@@ -160,7 +160,8 @@ package Sidef::Object::Object {
                 return $second->contains($first);
             }
 
-            Sidef::Types::Bool::Bool->false;
+            state $method = '==';
+            $first->$method($second);
         };
 
         # Negation of smart match

lib/Sidef/Parser.pm

@@ -2205,7 +2205,6 @@ package Sidef::Parser {
                                                error => "operator '$method' requires a right-side argument",
                                               );
                         }
-
                     }
 
                     $has_arg || do {
@@ -2570,11 +2569,8 @@ package Sidef::Parser {
                     if (defined $arg) {
                         push @{$struct{$self->{class}}[-1]{call}}, {method => 'do', arg => [$arg]};
 
-                        if (/\G\h*(\R\h*)?(?=$self->{method_name_re}|$self->{operators_re})/goc) {
-
-                            if (defined $1) {
-                                $self->{line}++;
-                            }
+                        if (not(($self->parse_whitespace(code => $opt{code}))[1])
+                            and /(?=$self->{method_name_re}|$self->{operators_re})/o) {
 
                             my $code = '. ' . substr($_, pos);
                             my $methods = $self->parse_methods(code => \$code);

lib/Sidef/Types/Block/Switch.pm

@@ -13,9 +13,20 @@ package Sidef::Types::Block::Switch {
     sub when {
         my ($self, $arg) = @_;
 
-        if (ref($self->{obj}) eq ref($arg)) {
+        state $method = '~~';
+        if ($arg->$method($self->{obj})->get_value) {
+            $self->{do_block} = 1;
+        }
+
+        $self;
+    }
+
+    sub exact {
+        my ($self, $arg) = @_;
+
+        if (ref($arg) eq ref($self->{obj})) {
             state $method = '==';
-            if ($self->{obj}->$method($arg)->get_value) {
+            if ($self->{obj}->$method($arg)) {
                 $self->{do_block} = 1;
             }
         }
@@ -32,7 +43,7 @@ package Sidef::Types::Block::Switch {
             }
         }
         else {
-            return $self->when($arg);
+            return $self->exact($arg);
         }
 
         $self;
@@ -58,8 +69,9 @@ package Sidef::Types::Block::Switch {
 
     {
         no strict 'refs';
-        *{__PACKAGE__ . '::' . '>'} = \&when;
+        *{__PACKAGE__ . '::' . '~'} = \&when;
         *{__PACKAGE__ . '::' . '?'} = \&case;
+        *{__PACKAGE__ . '::' . '>'} = \&exact;
         *{__PACKAGE__ . '::' . ':'} = \&default;
     }
 

scripts/given_when_test.sf

@@ -5,10 +5,11 @@
 #
 
 range(1, 10).each { |i|
+
     given (i)
-        > 3          { say "three"; next }
-        ? (i%2 == 0) { say "even";  next }
-        > 9          { say "nine";  break };
+        > 3           { say "three"; next }          # exact
+        ? (i.is_even) { say "even";  next }          # boolean
+        ~ 9           { say "nine";  break };        # smartmatch
 
     if (i % 2 == 0) {
         die "Got an even number!";

scripts/read_a_configuration_file.sf

@@ -0,0 +1,69 @@
+#!/usr/bin/ruby
+
+#
+## http://rosettacode.org/wiki/Read_a_configuration_file
+#
+
+var fullname = (var favouritefruit = "");
+var needspeeling = (var seedsremoved = false);
+var otherfamily = [];
+
+DATA.each { |line|
+    var(key, value) = line.strip.split(/\h+/, 2)...;
+
+    given(key)
+        ~ /^([#;]|\h*$)/    {  }
+        > "FULLNAME"        { fullname = value }
+        > "FAVOURITEFRUIT"  { favouritefruit = value }
+        > "NEEDSPEELING"    { needspeeling = true }
+        > "SEEDSREMOVED"    { seedsremoved = true }
+        > "OTHERFAMILY"     { otherfamily = value.split(',')»strip»() }
+        ~ /^./              { say "#{key}: unknown key" }
+    ;
+}
+
+say "fullname       = #{fullname}";
+say "favouritefruit = #{favouritefruit}";
+say "needspeeling   = #{needspeeling}";
+say "seedsremoved   = #{seedsremoved}";
+
+otherfamily.each_with_index {|i, name|
+    say "otherfamily(#{i+1}) = #{name}";
+};
+
+assert_eq(fullname, 'Foo Barber');
+assert_eq(favouritefruit, 'banana');
+assert_eq(needspeeling, true);
+assert_eq(seedsremoved, false);
+assert_eq(otherfamily[0], 'Rhu Barber');
+assert_eq(otherfamily[1], 'Harry Barber');
+
+__DATA__
+# This is a configuration file in standard configuration file format
+#
+# Lines beginning with a hash or a semicolon are ignored by the application
+# program. Blank lines are also ignored by the application program.
+
+# This is the fullname parameter
+FULLNAME Foo Barber
+
+# This is a favourite fruit
+FAVOURITEFRUIT banana
+
+# This is a boolean that should be set
+NEEDSPEELING
+
+# This boolean is commented out
+; SEEDSREMOVED
+
+# Configuration option names are not case sensitive, but configuration parameter
+# data is case sensitive and may be preserved by the application program.
+
+# An optional equals sign can be used to separate configuration parameter data
+# from the option name. This is dropped by the parser.
+
+# A configuration option may take multiple parameters separated by commas.
+# Leading and trailing whitespace around parameter names and parameter data fields
+# are ignored by the application program.
+
+OTHERFAMILY Rhu Barber, Harry Barber

scripts/switch.sf

@@ -91,10 +91,10 @@ given([8,9,10])
     when ("x") do {
         "Not the right place! (1)".die;
     }
-    when([8,10,9]) do {
+    exact([8,10,9]) do {
         "Not the right place! (2)".die;
     }
-    when ([8,9,10]) do {
+    exact([8,9,10]) do {
         "Right place! (5)".say;
     }
     when ([42]) do {
@@ -107,7 +107,7 @@ given(0)
     when (1) do {
         "Not the right place! (1)".die;
     }
-    when ('0') do {
+    exact ('0') do {
         "Not the right place! (2)".die;
     }
     when (0) do {