Changeset 17870

Timestamp:

09/16/07 15:05:07 (14 months ago)

Author:

ryporter

Message:

Fix how the range operator handles rationals

Files:

• src/Pugs/Prim.hs (modified) (4 diffs)
• t/operators/range.t (modified) (3 diffs)

src/Pugs/Prim.hs

@@ -1456 +1456 @@
     op1Range (VInt int)
 
+{- In the four op2Range* functions below, rationals
+have to be handled separately because Haskell ranges 
+are different from Perl 6 ranges.  For example, 
+in Haskell, [1.1 .. 2] will return [1.1,2.1].  So, we
+run the elements through a filter to ensure that the 
+upper bound is satisfied 
+-}
 op2Range :: Val -> Val -> Eval Val
 op2Range (VStr s) y  = do
@@ -1468 +1475 @@
 op2Range (VRat n) y  = do
     y'  <- fromVal y
-    return . VList $ map VRat [n .. y']
+    return . VList $ map VRat (filter (<= y') [n .. y'])
 op2Range x (VRat n)  = do
     x'  <- fromVal x
-    return . VList $ map VRat [x' .. n]
+    return . VList $ map VRat (filter (<= n) [x' .. n])
 op2Range x y         = do
     x'  <- fromVal x
@@ -1477 +1484 @@
     return . VList $ map VInt [x' .. y']
 
+-- because the right-exclusivity of a range can leave it
+-- with no remaining elements, we need to check before
+-- removing an element when enforcing left-exclusivity
+removeRangeFirst :: [Val] -> [Val]
+removeRangeFirst vals = if null vals then vals else init vals
+
 op2RangeExclRight :: Val -> Val -> Eval Val
+op2RangeExclRight (VRat n) y  = do
+    y' <- fromVal y
+    return . VList $ map VRat (filter (< y') [n .. y'])
+op2RangeExclRight x (VRat n)  = do
+    x'  <- fromVal x
+    return . VList $ map VRat (filter (< n) [x' .. n])
 op2RangeExclRight x y = do
     VList vals <- op2Range x y
-    return . VList $ init vals
+    return . VList $ removeRangeFirst vals
 
 op2RangeExclLeft :: Val -> Val -> Eval Val
+op2RangeExclLeft (VRat n) y  = do
+    y'  <- fromVal y
+    return . VList $ map VRat (filter (\v -> n < v && v <= y') [n .. y'])
+op2RangeExclLeft x (VRat n)  = do
+    x'  <- fromVal x
+    return . VList $ map VRat (filter (\v -> x' < v && v <= n) [x' .. n])
 op2RangeExclLeft x y = do
     VList vals <- op2Range x y
@@ -1488 +1513 @@
 
 op2RangeExclBoth :: Val -> Val -> Eval Val
+op2RangeExclBoth (VRat n) y  = do
+    y'  <- fromVal y
+    return . VList $ map VRat (filter (\v -> n < v && v < y') [n .. y'])
+op2RangeExclBoth x (VRat n)  = do
+    x'  <- fromVal x
+    return . VList $ map VRat (filter (\v -> x' < v && v < n) [x' .. n])
 op2RangeExclBoth x y = do
     VList vals <- op2Range x y
-    return . VList $ init (tail vals)
+    return . VList $ removeRangeFirst (tail vals)
 
 op2ChainedList :: Val -> Val -> Val

t/operators/range.t

@@ -3 +3 @@
 use Test;
 
-plan 47;
+plan 50;
 
 # 3..2 must *not* produce "3 2".  Use reverse to get a reversed range. -lwall
@@ -34 +34 @@
 is [1^..^2], [], "double-exclusive range (^..^) can produce null range";
 
+# tests of (x ^..^ x) here and below ensure that our implementation
+# of double-exclusive range does not blindly remove an element
+# from the head and tail of a list
+is [1^..^1], [], "double-exclusive range (x ^..^ x) where x is an int";
+
 is ["a"^.."z"], ["b".."z"], "bottom-exclusive string range (^..) works";
 is ["a"..^"z"], ["a".."y"], "top-exclusive string range (..^) works";
 is ["a"^..^"z"], ["b".."y"], "double-exclusive string range (^..^) works";
 is ['a'^..^'b'], [], "double-exclusive string range (^..^) can produce null range";
+is ['a' ^..^ 'a'], [], "double-exclusive range (x ^..^ x) where x is a char";
 
 is 1.5 ~~ 1^..^2, Bool::True, "lazy evaluation of the range operator", :todo<bug>;
@@ -70 +76 @@
 is ~(1.1 ^..^ 4.9), "2.1 3.1 4.1", "both exclusive float range";
 is ~(1.9 ^..^ 4.9), "2.9 3.9"    , "both exclusive float range";
-
+is [1.1 ^..^ 1.1], [], "double-exclusive range (x ^..^ x) where x is a float";
 
 # Test that the operands are forced to scalar context