Changeset 2335

Show
Ignore:
Timestamp:
04/25/05 21:09:55 (4 years ago)
Author:
corion
svk:copy_cache_prev:
3850
Message:

splice([], 1) now works

Files:
2 modified

Legend:

Unmodified
Added
Removed
  • src/Pugs/Prim.hs

    r2325 r2335  
    2727 
    2828op0 :: Ident -> [Val] -> Eval Val 
    29 op0 "!"  = fmap opJuncNone . mapM fromVal 
    30 op0 "&"  = fmap opJuncAll . mapM fromVal 
    31 op0 "^"  = fmap opJuncOne . mapM fromVal 
    32 op0 "|"  = fmap opJuncAny . mapM fromVal 
    33 op0 "want"  = const $ fmap VStr (asks envWant) 
     29op0 "!"  = (return . opJuncNone =<<) . mapM fromVal 
     30op0 "&"  = (return . opJuncAll =<<) . mapM fromVal 
     31op0 "^"  = (return . opJuncOne =<<) . mapM fromVal 
     32op0 "|"  = (return . opJuncAny =<<) . mapM fromVal 
     33op0 "want"  = const $ return . VStr =<< asks envWant 
    3434op0 "time"  = const $ do 
    3535    clkt <- liftIO getClockTime 
     
    4040op0 "not" = const retEmpty 
    4141op0 "so" = const (return $ VBool True) 
    42 op0 "¥" = fmap (VList . concat . op0Zip) . mapM fromVal 
     42op0 "¥" = (return . VList . concat . op0Zip =<<) . mapM fromVal 
    4343op0 "Y" = op0 "¥" 
    4444op0 "File::Spec::cwd" = const $ do 
    4545    mycwd <- liftIO getCurrentDirectory 
    4646    return $ VStr mycwd 
    47 op0 "pi" = const $ return (VNum pi) 
     47op0 "pi" = const $ return . VNum $ pi 
    4848op0 "say" = const $ op1 "say" =<< readVar "$_" 
    4949op0 "print" = const $ op1 "print" =<< readVar "$_" 
     
    9797    ref <- fromVal x 
    9898    val' <- case val of 
    99         (VStr str)  -> return (VStr $ strInc str) 
     99        (VStr str)  -> return . VStr $ strInc str 
    100100        _           -> op1Numeric (+1) val 
    101101    writeRef ref val' 
     
    146146                    val     <- readRef ref 
    147147                    str     <- fromVal val 
    148                     return (VStr $ reverse str)) 
     148                    return . VStr $ reverse str) 
    149149                (do ref     <- fromVal v 
    150150                    vals    <- readRef ref 
    151151                    vlist   <- fromVal vals 
    152                     return (VList $ reverse vlist)) 
     152                    return . VList $ reverse vlist) 
    153153        _ -> ifListContext 
    154154            (op1Cast (VList . reverse) v) 
     
    170170op1 "one"  = op1Cast opJuncOne 
    171171op1 "none" = op1Cast opJuncNone 
    172 op1 "perl" = fmap VStr . prettyVal 0 
     172op1 "perl" = (return . VStr =<<) . (prettyVal 0) 
    173173op1 "require_haskell" = \v -> do 
    174174    name    <- fromVal v 
     
    222222op1 "readlink" = \v -> do 
    223223    str  <- fromVal v 
    224     tryIO undef $ fmap VStr (readSymbolicLink str) 
     224    tryIO undef $ return . VStr =<< readSymbolicLink str 
    225225op1 "sleep" = boolIO (threadDelay . (* 1000000)) 
    226226op1 "mkdir" = boolIO createDirectory 
     
    254254            ifListContext 
    255255                (op1 "=" val) 
    256                 (fmap VStr (liftIO $ hGetContents h)) 
     256                (return . VStr =<< (liftIO $ hGetContents h)) 
    257257        _ -> do 
    258258            fileName    <- fromVal val 
     
    306306        (VSocket _) -> boolIO sClose val 
    307307        _           -> boolIO hClose val 
    308 op1 "key" = fmap fst . (fromVal :: Val -> Eval VPair) 
    309 op1 "value" = fmap snd . (fromVal :: Val -> Eval VPair) 
     308op1 "key" = (return . fst =<<) . (fromVal :: Val -> Eval VPair) 
     309op1 "value" = (return . snd =<<) . (fromVal :: Val -> Eval VPair) 
    310310op1 "pairs" = \v -> do 
    311311    pairs <- op1Pairs v 
     
    316316        pair   <- readRef ref 
    317317        fromVal pair 
    318     return (VList $ concat kvs) 
     318    return . VList $ concat kvs 
    319319op1 "keys" = op1Keys 
    320320op1 "values" = op1Values 
     
    336336    getLine :: VHandle -> Eval Val 
    337337    getLine fh = tryIO undef $ 
    338         fmap (VStr . (++ "\n")) (hGetLine fh) 
     338        (return . VStr . (++ "\n") =<< hGetLine fh) 
    339339    handleOf VUndef = handleOf (VList []) 
    340340    handleOf (VList []) = do 
     
    353353                        return hdl 
    354354    handleOf (VStr x) = do 
    355         rv <- tryIO Nothing (fmap Just $ openFile x ReadMode) 
     355        rv <- tryIO Nothing (return . Just =<< openFile x ReadMode) 
    356356        case rv of 
    357357            Nothing  -> retError "No such file or directory" (Val $ VStr x) 
     
    359359    handleOf (VList [x]) = handleOf x 
    360360    handleOf v = fromVal v 
    361 op1 "ref"   = fmap (VStr . show) . evalValType 
     361op1 "ref"   = (return . VStr . show =<<) . evalValType 
    362362op1 "pop"   = \x -> join $ doArray x Array.pop -- monadic join 
    363363op1 "shift" = \x -> join $ doArray x Array.shift -- monadic join 
     
    386386 
    387387op1Cast :: (Value n) => (n -> Val) -> Val -> Eval Val 
    388 op1Cast f val = fmap f (fromVal =<< fromVal' val) 
     388op1Cast f val = return . f =<< fromVal =<< fromVal' val 
    389389 
    390390op2Cast :: (Value n, Value m) => (n -> m -> Val) -> Val -> Val -> Eval Val 
     
    602602op2 "exists" = \x y -> do 
    603603    ref <- fromVal x 
    604     fmap VBool (existsFromRef ref y) 
     604    return . VBool =<< existsFromRef ref y 
    605605op2 "unshift" = op2Array Array.unshift 
    606606op2 "push" = op2Array Array.push 
     
    644644op2 "splice" = \x y -> do 
    645645    fetchSize   <- doArray x Array.fetchSize 
    646     len         <- fromVal y 
     646    len'        <- fromVal y 
    647647    sz          <- fetchSize 
    648     op4 "splice" x y (castV (sz - (len `mod` sz))) (VList [])  
     648    let len = if len' < 0 then if sz > 0 then (len' `mod` sz) else 0 else len' 
     649    op4 "splice" x y (castV (sz - len)) (VList []) 
    649650op2 "sort" = \x y -> do 
    650651    xs <- fromVals x 
     
    768769 
    769770op3 "splice" = \x y z -> do 
    770     op4 "splice" x y z (VList [])  
     771    op4 "splice" x y z (VList []) 
    771772op3 other = \x y z -> return $ VError ("unimplemented 3-ary op: " ++ other) (App other [Val x, Val y, Val z] []) 
    772773 
     
    793794 
    794795-- op4 "splice" = \x y z w-> do 
    795 op4 "splice" = \x y z w -> do  
     796op4 "splice" = \x y z w -> do 
    796797    splice  <- doArray x Array.splice 
    797798    start   <- fromVal y 
     
    807808op2Hyper op x y 
    808809    | VList x' <- x, VList y' <- y 
    809     = fmap VList $ hyperLists x' y' 
     810    = hyperLists x' y' >>= (return . VList) 
    810811    | VList x' <- x 
    811     = fmap VList $ mapM ((flip (op2 op)) y) x' 
     812    = mapM ((flip (op2 op)) y) x' >>= (return . VList) 
    812813    | VList y' <- y 
    813     = fmap VList $ mapM (op2 op x) y' 
     814    = mapM (op2 op x) y' >>= (return . VList) 
    814815    | otherwise 
    815816    = return $ VError "Hyper OP only works on lists" (Val VUndef) 
     
    949950op1Numeric f VUndef     = return . VInt $ f 0 
    950951op1Numeric f (VInt x)   = return . VInt $ f x 
    951 op1Numeric f l@(VList _)= fmap (VInt . f) (fromVal l) 
     952op1Numeric f l@(VList _)= return . VInt . f =<< fromVal l 
    952953op1Numeric f (VRat x)   = return . VRat $ f x 
    953954op1Numeric f (VRef x)   = op1Numeric f =<< readRef x 
    954 op1Numeric f x          = fmap (VNum . f) (fromVal x) 
     955op1Numeric f x          = return . VNum . f =<< fromVal x 
    955956 
    956957--- XXX wrong: try num first, then int, then vcast to Rat (I think) 
  • t/builtins/arrays/splice.t

    r2314 r2335  
    132132 
    133133# un comment this to test, but now it causes a fatal error 
    134 eval_ok '# splice([], 1)', '... this causes a fatal error'; 
    135  
     134@a = splice([], 1); 
     135is +@a, 0, '... empty lists are not fatal anymore';