blank unuseds

Author: jrp2014

src/Eval.hs

@@ -121,7 +121,7 @@ getVar (Atom atom) = do
 getVar n = throw $ TypeMismatch "failure to get variable: " n
 
 ensureAtom :: LispVal -> Eval LispVal
-ensureAtom n@(Atom txt) = return  n
+ensureAtom n@(Atom _) = return n
 ensureAtom n = throw $ TypeMismatch "expected an atomic value" n
 
 extractVar :: LispVal -> T.Text
@@ -134,7 +134,7 @@ getEven (x:xs) = x : getOdd xs
 
 getOdd :: [t] -> [t]
 getOdd [] = []
-getOdd (x:xs) = getEven xs
+getOdd (_:xs) = getEven xs
 
 
 applyLambda :: LispVal -> [LispVal] -> [LispVal] -> Eval LispVal
@@ -178,15 +178,15 @@ eval (List [Atom "if", pred, truExpr, flsExpr]) = do
  (Bool True) -> eval truExpr
  (Bool False) -> eval flsExpr
  _ -> throw $ BadSpecialForm "if's first arg must eval into a boolean"
-eval args@(List ( (:) (Atom "if") _)) = throw $ BadSpecialForm "(if <bool> <s-expr> <s-expr>)"
+eval (List ( (:) (Atom "if") _)) = throw $ BadSpecialForm "(if <bool> <s-expr> <s-expr>)"
 
 eval (List [Atom "begin", rest]) = evalBody rest
 eval (List ((:) (Atom "begin") rest )) = evalBody $ List rest
 
 eval (List [Atom "define", varExpr, defExpr]) = do --top-level define
  EnvCtx{} <- ask
- varAtom <- ensureAtom varExpr
- evalVal <- eval defExpr
+ _varAtom <- ensureAtom varExpr
+ _evalVal <- eval defExpr
  bindArgsEval [varExpr] [defExpr] varExpr
 
 eval (List [Atom "let", List pairs, expr]) = do
@@ -203,33 +203,33 @@ eval (List (Atom "lambda":_) ) = throw $ BadSpecialForm "lambda function expects
 
 
 -- needed to get cadr, etc to work
-eval all@(List [Atom "cdr", List [Atom "quote", List (x:xs)]]) =
+eval (List [Atom "cdr", List [Atom "quote", List (_:xs)]]) =
  return $ List xs
-eval all@(List [Atom "cdr", arg@(List (x:xs))]) =
+eval (List [Atom "cdr", arg@(List (x:xs))]) =
  case x of
  -- proxy for if the list can be evaluated
  Atom _ -> do val <- eval arg
  eval $ List [Atom "cdr", val]
  _ -> return $ List xs
 
 
-eval all@(List [Atom "car", List [Atom "quote", List (x:xs)]]) =
+eval (List [Atom "car", List [Atom "quote", List (x:_)]]) =
  return x
-eval all@(List [Atom "car", arg@(List (x:xs))]) =
+eval (List [Atom "car", arg@(List (x:_))]) =
  case x of
  Atom _ -> do val <- eval arg
  eval $ List [Atom "car", val]
  _ -> return x
 
 
-eval all@(List ((:) x xs)) = do
+eval (List ((:) x xs)) = do
  EnvCtx{..} <- ask
  funVar <- eval x
  xVal <- mapM eval xs
  --liftIO $ TIO.putStr $ T.concat ["eval:\n ", T.pack $ show all,"\n * fnCall: ", T.pack $ show x, "\n * fnVar ", T.pack $ show funVar,"\n * args: ",T.concat (T.pack . show <$> xVal) ,T.pack "\n"]
  case funVar of
  (Fun (IFunc internalFn)) -> internalFn xVal
- (Lambda (IFunc definedFn) (EnvCtx benv bfenv)) -> local (const $ EnvCtx benv fenv) $ definedFn xVal
+ (Lambda (IFunc definedFn) (EnvCtx benv _bfenv)) -> local (const $ EnvCtx benv fenv) $ definedFn xVal
 
  _ -> throw $ NotFunction funVar
 
@@ -242,12 +242,12 @@ updateEnv var e@(Lambda _ _) EnvCtx{..} = EnvCtx env $ Map.insert var e fenv
 updateEnv var e EnvCtx{..} = EnvCtx (Map.insert var e env) fenv
 
 evalBody :: LispVal -> Eval LispVal
-evalBody x@(List [List ((:) (Atom "define") [Atom var, defExpr]), rest]) = do
+evalBody (List [List ((:) (Atom "define") [Atom var, defExpr]), rest]) = do
  evalVal <- eval defExpr
  ctx <- ask
  local (const $ updateEnv var evalVal ctx) $ eval rest
 
-evalBody x@(List ((:) (List ((:) (Atom "define") [Atom var, defExpr])) rest)) = do
+evalBody (List ((:) (List ((:) (Atom "define") [Atom var, defExpr])) rest)) = do
  evalVal <- eval defExpr
  ctx <- ask
  local (const $ updateEnv var evalVal ctx) $ evalBody $ List rest

src/Prim.hs

@@ -113,40 +113,40 @@ putTextFile fileName msg handle = do
 binopFold :: Binary -> LispVal -> [LispVal] -> Eval LispVal
 binopFold op farg args = case args of
  [a,b] -> op a b
- (a:as) -> foldM op farg args
+ (_a:_as) -> foldM op farg args
  []-> throw $ NumArgs 2 args
 
 numBool :: (Integer -> Bool) -> LispVal -> Eval LispVal
 numBool op (Number x) = return $ Bool $ op x
-numBool op x = throw $ TypeMismatch "numeric op " x
+numBool _  x = throw $ TypeMismatch "numeric op " x
 
 numOp :: (Integer -> Integer -> Integer) -> LispVal -> LispVal -> Eval LispVal
 numOp op (Number x) (Number y) = return $ Number $ op x y
-numOp op Nil (Number y) = return $ Number y
-numOp op (Number x) Nil = return $ Number x
-numOp op x (Number y) = throw $ TypeMismatch "numeric op " x
-numOp op (Number x) y = throw $ TypeMismatch "numeric op " y
-numOp op x y = throw $ TypeMismatch "numeric op " x
+numOp _  Nil (Number y) = return $ Number y
+numOp _  (Number x) Nil = return $ Number x
+numOp _ x (Number _) = throw $ TypeMismatch "numeric op " x
+numOp _ (Number _) y = throw $ TypeMismatch "numeric op " y
+numOp _ x _ = throw $ TypeMismatch "numeric op " x
 
 strOp :: (T.Text -> T.Text -> T.Text) -> LispVal -> LispVal -> Eval LispVal
 strOp op (String x) (String y) = return $ String $ op x y
-strOp op Nil (String y) = return $ String y
-strOp op (String x) Nil = return $ String x
-strOp op x (String y) = throw $ TypeMismatch "string op " x
-strOp op (String x) y = throw $ TypeMismatch "string op " y
-strOp op x y = throw $ TypeMismatch "string op " x
+strOp _  Nil (String y) = return $ String y
+strOp _  (String x) Nil = return $ String x
+strOp _ x (String _) = throw $ TypeMismatch "string op " x
+strOp _ (String _) y = throw $ TypeMismatch "string op " y
+strOp _ x _ = throw $ TypeMismatch "string op " x
 
 eqOp :: (Bool -> Bool -> Bool) -> LispVal -> LispVal -> Eval LispVal
 eqOp op (Bool x) (Bool y) = return $ Bool $ op x y
-eqOp op x (Bool y) = throw $ TypeMismatch "bool op " x
-eqOp op (Bool x) y = throw $ TypeMismatch "bool op " y
-eqOp op x y = throw $ TypeMismatch "bool op " x
+eqOp _ x (Bool _) = throw $ TypeMismatch "bool op " x
+eqOp _ (Bool _) y = throw $ TypeMismatch "bool op " y
+eqOp _ x _ = throw $ TypeMismatch "bool op " x
 
 numCmp :: (Integer -> Integer -> Bool) -> LispVal -> LispVal -> Eval LispVal
 numCmp op (Number x) (Number y) = return . Bool $ op x y
-numCmp op x (Number y) = throw $ TypeMismatch "numeric op " x
-numCmp op (Number x) y = throw $ TypeMismatch "numeric op " y
-numCmp op x y = throw $ TypeMismatch "numeric op " x
+numCmp _ x (Number _) = throw $ TypeMismatch "numeric op " x
+numCmp _ (Number _) y = throw $ TypeMismatch "numeric op " y
+numCmp _ x _ = throw $ TypeMismatch "numeric op " x
 
 
 notOp :: LispVal -> Eval LispVal
@@ -163,22 +163,22 @@ eqCmd Nil Nil = return $ Bool True
 eqCmd _ _ = return $ Bool False
 
 cons :: [LispVal] -> Eval LispVal
-cons [x,y@(List yList)] = return $ List $ x:yList
-cons [x,y]  = return $ List [x,y]
+cons [x,List yList] = return $ List $ x:yList
+cons [x,y] = return $ List [x,y]
 cons _ = throw $ ExpectedList "cons, in second argumnet"
 
 
 car :: [LispVal] -> Eval LispVal
 car [List [] ] = return Nil
 car [List (x:_)] = return x
 car [] = return Nil
-car x = throw $ ExpectedList "car"
+car _ = throw $ ExpectedList "car"
 
 cdr :: [LispVal] -> Eval LispVal
-cdr [List (x:xs)] = return $ List xs
+cdr [List (_:xs)] = return $ List xs
 cdr [List []] = return Nil
 cdr [] = return Nil
-cdr x = throw $ ExpectedList "cdr"
+cdr _ = throw $ ExpectedList "cdr"
 
 quote :: [LispVal] -> Eval LispVal
 quote [List xs] = return $ List $ Atom "quote" : xs