diff --git a/egison.cabal b/egison.cabal
--- a/egison.cabal
+++ b/egison.cabal
@@ -1,5 +1,5 @@
 Name:                egison
-Version:             3.3.1
+Version:             3.3.2
 Synopsis:            Programming language with non-linear pattern-matching with backtracking
 Description:
   An interpreter for Egison, the programming langugage that realized non-linear pattern-matching with backtracking.
diff --git a/hs-src/Interpreter/egison.hs b/hs-src/Interpreter/egison.hs
--- a/hs-src/Interpreter/egison.hs
+++ b/hs-src/Interpreter/egison.hs
@@ -128,22 +128,13 @@
     input <- liftIO $ runInputT (settings home) $ getEgisonExpr prompt
     case input of
       Nothing -> return ()
-      Just (Left (topExpr, _)) -> do
+      Just (topExpr, _) -> do
         result <- liftIO $ runEgisonTopExpr env topExpr
         case result of
           Left err -> do
             liftIO $ putStrLn $ show err
             loop env
-          Right env' -> loop env'
-      Just (Right (expr, _)) -> do
-        result <- liftIO $ runEgisonExpr env expr
-        case result of
-          Left err -> do
-            liftIO $ putStrLn $ show err
-            loop env
-          Right val -> do
-            liftIO $ putStrLn $ show val
-            loop env)
+          Right env' -> loop env')
     `catch`
     (\e -> case e of
              UserInterrupt -> putStrLn "" >> loop env
diff --git a/hs-src/Language/Egison/Core.hs b/hs-src/Language/Egison/Core.hs
--- a/hs-src/Language/Egison/Core.hs
+++ b/hs-src/Language/Egison/Core.hs
@@ -13,7 +13,6 @@
     -- * Egison code evaluation
       evalTopExprs
     , evalTopExpr
-    , evalTopExpr'
     , evalExpr
     , evalExprDeep
     , evalRef
@@ -68,7 +67,7 @@
 evalTopExprs env exprs = do
   (bindings, rest) <- collectDefs exprs [] []
   env <- recursiveBind env bindings
-  forM_ rest $ evalTopExpr' env
+  forM_ rest $ evalTopExpr env
   return env
  where
   collectDefs (expr:exprs) bindings rest =
@@ -84,26 +83,25 @@
   collectDefs [] bindings rest = return (bindings, reverse rest)
 
 evalTopExpr :: Env -> EgisonTopExpr -> EgisonM Env
-evalTopExpr env topExpr = evalTopExpr'' env topExpr >>= return . snd
-
-evalTopExpr' :: Env -> EgisonTopExpr -> EgisonM Env
-evalTopExpr' env topExpr = do
-  ret <- evalTopExpr'' env topExpr
-  liftIO $ putStrLn $ fst ret
+evalTopExpr env topExpr = do
+  ret <- evalTopExpr' env topExpr
+  case fst ret of
+    Nothing -> return ()
+    Just output -> liftIO $ putStrLn output
   return $ snd ret
 
-evalTopExpr'' :: Env -> EgisonTopExpr -> EgisonM (String, Env)
-evalTopExpr'' env (Define name expr) = recursiveBind env [(name, expr)] >>= return . ((,) "")
-evalTopExpr'' env (Test expr) = do
+evalTopExpr' :: Env -> EgisonTopExpr -> EgisonM (Maybe String, Env)
+evalTopExpr' env (Define name expr) = recursiveBind env [(name, expr)] >>= return . ((,) Nothing)
+evalTopExpr' env (Test expr) = do
   val <- evalExprDeep env expr
-  return ((show val), env)
-evalTopExpr'' env (Execute expr) = do
+  return (Just (show val), env)
+evalTopExpr' env (Execute expr) = do
   io <- evalExpr env expr
   case io of
-    Value (IOFunc m) -> m >> return ("", env)
+    Value (IOFunc m) -> m >> return (Nothing, env)
     _ -> throwError $ TypeMismatch "io" io
-evalTopExpr'' env (Load file) = loadLibraryFile file >>= evalTopExprs env >>= return . ((,) "")
-evalTopExpr'' env (LoadFile file) = loadFile file >>= evalTopExprs env >>= return . ((,) "")
+evalTopExpr' env (Load file) = loadLibraryFile file >>= evalTopExprs env >>= return . ((,) Nothing)
+evalTopExpr' env (LoadFile file) = loadFile file >>= evalTopExprs env >>= return . ((,) Nothing)
 
 evalExpr :: Env -> EgisonExpr -> EgisonM WHNFData
 evalExpr _ (CharExpr c) = return . Value $ Char c
@@ -177,12 +175,12 @@
   refArray val [] = return val 
   refArray (Value (Array array)) (index:indices) = do
     i <- (liftM fromInteger . fromEgison) index
-    case IntMap.lookup i array of
+    case IntMap.lookup (i + 1) array of
       Just val -> refArray (Value val) indices
       Nothing -> return $ Value Undefined
   refArray (Intermediate (IArray array)) (index:indices) = do
     i <- (liftM fromInteger . fromEgison) index
-    case IntMap.lookup i array of
+    case IntMap.lookup (i + 1) array of
       Just ref -> evalRef ref >>= flip refArray indices
       Nothing -> return $ Value Undefined
   refArray (Value (IntHash hash)) (index:indices) = do
diff --git a/hs-src/Language/Egison/Parser.hs b/hs-src/Language/Egison/Parser.hs
--- a/hs-src/Language/Egison/Parser.hs
+++ b/hs-src/Language/Egison/Parser.hs
@@ -105,11 +105,12 @@
 -- Expressions
 --
 topExpr :: Parser EgisonTopExpr
-topExpr = parens (defineExpr
-              <|> testExpr
-              <|> executeExpr
-              <|> loadFileExpr
-              <|> loadExpr)
+topExpr = try (parens (defineExpr
+                   <|> testExpr
+                   <|> executeExpr
+                   <|> loadFileExpr
+                   <|> loadExpr))
+      <|> Test <$> expr
       <?> "top-level expression"
 
 defineExpr :: Parser EgisonTopExpr
diff --git a/hs-src/Language/Egison/Primitives.hs b/hs-src/Language/Egison/Primitives.hs
--- a/hs-src/Language/Egison/Primitives.hs
+++ b/hs-src/Language/Egison/Primitives.hs
@@ -157,6 +157,8 @@
              , ("char?", isChar)
              , ("tuple?", isTuple)
              , ("collection?", isCollection)
+             , ("array?", isArray)
+             , ("hash?", isHash)
 
              , ("assert", assert)
              , ("assert-equal", assertEqual)
@@ -412,6 +414,7 @@
 isInteger _ = return $ Value $ Bool False
 
 isRational :: PrimitiveFunc
+isRational (Value (Integer _)) = return $ Value $ Bool True
 isRational (Value (Rational _)) = return $ Value $ Bool True
 isRational _ = return $ Value $ Bool False
 
@@ -454,6 +457,18 @@
 isCollection (Value (Collection _)) = return $ Value $ Bool True
 isCollection (Intermediate (ICollection _)) = return $ Value $ Bool True
 isCollection _ = return $ Value $ Bool False
+
+isArray :: PrimitiveFunc
+isArray (Value (Array _)) = return $ Value $ Bool True
+isArray (Intermediate (IArray _)) = return $ Value $ Bool True
+isArray _ = return $ Value $ Bool False
+
+isHash :: PrimitiveFunc
+isHash (Value (IntHash _)) = return $ Value $ Bool True
+isHash (Value (StrHash _)) = return $ Value $ Bool True
+isHash (Intermediate (IIntHash _)) = return $ Value $ Bool True
+isHash (Intermediate (IStrHash _)) = return $ Value $ Bool True
+isHash _ = return $ Value $ Bool False
 
 -- Test
 
diff --git a/hs-src/Language/Egison/Util.hs b/hs-src/Language/Egison/Util.hs
--- a/hs-src/Language/Egison/Util.hs
+++ b/hs-src/Language/Egison/Util.hs
@@ -17,10 +17,10 @@
 import Language.Egison.Parser
 
 -- |Get Egison expression from the prompt. We can handle multiline input.
-getEgisonExpr :: String -> InputT IO (Maybe (Either (String, EgisonTopExpr) (String, EgisonExpr)))
+getEgisonExpr :: String -> InputT IO (Maybe (String, EgisonTopExpr))
 getEgisonExpr prompt = getEgisonExpr' prompt ""
 
-getEgisonExpr' :: String -> String -> InputT IO (Maybe (Either (String, EgisonTopExpr) (String, EgisonExpr)))
+getEgisonExpr' :: String -> String -> InputT IO (Maybe (String, EgisonTopExpr))
 getEgisonExpr' prompt prev = do
   mLine <- case prev of
              "" -> getInputLine prompt
@@ -36,24 +36,16 @@
       case parseTopExpr input of
         Left err | show err =~ "unexpected end of input" -> do
           getEgisonExpr' prompt $ input ++ "\n"
-        Left err | show err =~ "expecting (top-level|\"define\")" ->
-          case parseExpr input of
-            Left err | show err =~ "unexpected end of input" -> do
-              getEgisonExpr' prompt $ input ++ "\n"
-            Left err -> do
-              liftIO $ putStrLn $ show err
-              getEgisonExpr prompt
-            Right expr -> return $ Just $ Right (input, expr)
         Left err -> do
           liftIO $ putStrLn $ show err
           getEgisonExpr prompt
-        Right topExpr -> return $ Just $ Left (input, topExpr)
+        Right topExpr -> return $ Just (input, topExpr)
 
 -- |Get Egison expression from the prompt. We can handle multiline input.
-getEgisonExprOrNewLine :: String -> InputT IO (Either (Maybe String) (Either (String, EgisonTopExpr) (String, EgisonExpr)))
+getEgisonExprOrNewLine :: String -> InputT IO (Either (Maybe String) (String, EgisonTopExpr))
 getEgisonExprOrNewLine prompt = getEgisonExprOrNewLine' prompt ""
 
-getEgisonExprOrNewLine' :: String -> String -> InputT IO (Either (Maybe String) (Either (String, EgisonTopExpr) (String, EgisonExpr)))
+getEgisonExprOrNewLine' :: String -> String -> InputT IO (Either (Maybe String) (String, EgisonTopExpr))
 getEgisonExprOrNewLine' prompt prev = do
   mLine <- case prev of
              "" -> getInputLine prompt
@@ -66,18 +58,10 @@
       case parseTopExpr input of
         Left err | show err =~ "unexpected end of input" -> do
           getEgisonExprOrNewLine' prompt $ input ++ "\n"
-        Left err | show err =~ "expecting (top-level|\"define\")" ->
-          case parseExpr input of
-            Left err | show err =~ "unexpected end of input" -> do
-              getEgisonExprOrNewLine' prompt $ input ++ "\n"
-            Left err -> do
-              liftIO $ putStrLn $ show err
-              getEgisonExprOrNewLine prompt
-            Right expr -> return $ Right $ Right (input, expr)
         Left err -> do
           liftIO $ putStrLn $ show err
           getEgisonExprOrNewLine prompt
-        Right topExpr -> return $ Right $ Left (input, topExpr)
+        Right topExpr -> return $ Right (input, topExpr)
 
 -- |Complete Egison keywords
 completeEgison :: Monad m => CompletionFunc m
diff --git a/sample/demo1.egi b/sample/demo1.egi
--- a/sample/demo1.egi
+++ b/sample/demo1.egi
@@ -1,9 +1,9 @@
-;; Extract all twin primes with non-linear pattern-matching against the infinite list of prime numbers
+;; Extract all twin primes from the infinite list of prime numbers with pattern-matching!
 (define $twin-primes
   (match-all primes (list integer)
     [<join _ <cons $p <cons ,(+ p 2) _>>>
      [p (+ p 2)]]))
 
 ;; Enumerate first 10 twin primes
-(test (take 10 twin-primes))
+(take 10 twin-primes)
 ;=>{[3 5] [5 7] [11 13] [17 19] [29 31] [41 43] [59 61] [71 73] [101 103] [107 109]}