`13 `div` 5`

is `2`

,
+--- and the value of `-15 `div` 4`

is `-4`

.
+div :: Int -> Int -> Int
+div external
+
+--- Integer remainder. The value is the remainder of the integer division and
+--- it obeys the rule `x `mod` y = x - y * (x `div` y)`

.
+--- Thus, the value of `13 `mod` 5`

is `3`

,
+--- and the value of `-15 `mod` 4`

is `-3`

.
+mod :: Int -> Int -> Int
+mod external
+
+--- Returns an integer (quotient,remainder) pair.
+--- The value is the integer quotient of its arguments
+--- and always truncated towards negative infinity.
+divMod :: Int -> Int -> (Int, Int)
+divMod external
+
+--- Integer division. The value is the integer quotient of its arguments
+--- and always truncated towards zero.
+--- Thus, the value of `13 `quot` 5`

is `2`

,
+--- and the value of `-15 `quot` 4`

is `-3`

.
+quot :: Int -> Int -> Int
+quot external
+
+--- Integer remainder. The value is the remainder of the integer division and
+--- it obeys the rule `x `rem` y = x - y * (x `quot` y)`

.
+--- Thus, the value of `13 `rem` 5`

is `3`

,
+--- and the value of `-15 `rem` 4`

is `-3`

.
+rem :: Int -> Int -> Int
+rem external
+
+--- Returns an integer (quotient,remainder) pair.
+--- The value is the integer quotient of its arguments
+--- and always truncated towards zero.
+quotRem :: Int -> Int -> (Int, Int)
+quotRem external
+
+--- Unary minus. Usually written as "- e".
+negate :: Int -> Int
+negate x = 0 - x
+
+--- Unary minus on Floats. Usually written as "-e".
+negateFloat :: Float -> Float
+negateFloat external
+
+
+-- Constraints (included for backwar compatibility)
+type Success = Bool
+
+--- The always satisfiable constraint.
+success :: Success
+success = True
+
+-- Maybe type
+
+data Maybe a = Nothing | Just a
+
+maybe :: b -> (a -> b) -> Maybe a -> b
+maybe n _ Nothing = n
+maybe _ f (Just x) = f x
+
+
+-- Either type
+
+data Either a b = Left a | Right b
+
+either :: (a -> c) -> (b -> c) -> Either a b -> c
+either f _ (Left x) = f x
+either _ g (Right x) = g x
+
+
+-- Monadic IO
+
+data IO _ -- conceptually: World -> (a,World)
+
+--- Sequential composition of actions.
+--- @param a - An action
+--- @param fa - A function from a value into an action
+--- @return An action that first performs a (yielding result r)
+--- and then performs (fa r)
+(>>=) :: IO a -> (a -> IO b) -> IO b
+(>>=) external
+
+--- The empty action that directly returns its argument.
+return :: a -> IO a
+return external
+
+--- Sequential composition of actions.
+--- @param a1 - An action
+--- @param a2 - An action
+--- @return An action that first performs a1 and then a2
+(>>) :: IO _ -> IO b -> IO b
+a >> b = a >>= (\_ -> b)
+
+--- The empty action that returns nothing.
+done :: IO ()
+done = return ()
+
+--- An action that puts its character argument on standard output.
+putChar :: Char -> IO ()
+putChar c = prim_putChar $## c
+
+prim_putChar :: Char -> IO ()
+prim_putChar external
+
+--- An action that reads a character from standard output and returns it.
+getChar :: IO Char
+getChar external
+
+--- An action that (lazily) reads a file and returns its contents.
+readFile :: String -> IO String
+readFile f = prim_readFile $## f
+
+prim_readFile :: String -> IO String
+prim_readFile external
+
+--- An action that writes a file.
+--- @param filename - The name of the file to be written.
+--- @param contents - The contents to be written to the file.
+writeFile :: String -> String -> IO ()
+writeFile f s = (prim_writeFile $## f) $## s
+
+prim_writeFile :: String -> String -> IO ()
+prim_writeFile external
+
+--- An action that appends a string to a file.
+--- It behaves like writeFile if the file does not exist.
+--- @param filename - The name of the file to be written.
+--- @param contents - The contents to be appended to the file.
+appendFile :: String -> String -> IO ()
+appendFile f s = (prim_appendFile $## f) $## s
+
+prim_appendFile :: String -> String -> IO ()
+prim_appendFile external
+
+--- Action to print a string on stdout.
+putStr :: String -> IO ()
+putStr [] = done
+putStr (c:cs) = putChar c >> putStr cs
+
+--- Action to print a string with a newline on stdout.
+putStrLn :: String -> IO ()
+putStrLn cs = putStr cs >> putChar '\n'
+
+--- Action to read a line from stdin.
+getLine :: IO String
+getLine = do c <- getChar
+ if c=='\n' then return []
+ else do cs <- getLine
+ return (c:cs)
+
+----------------------------------------------------------------------------
+-- Error handling in the I/O monad:
+
+--- The (abstract) type of error values.
+--- Currently, it distinguishes between general IO errors,
+--- user-generated errors (see 'userError'), failures and non-determinism
+--- errors during IO computations. These errors can be caught by 'catch'
+--- and shown by 'showError'.
+--- Each error contains a string shortly explaining the error.
+--- This type might be extended in the future to distinguish
+--- further error situations.
+data IOError
+ = IOError String -- normal IO error
+ | UserError String -- user-specified error
+ | FailError String -- failing computation
+ | NondetError String -- non-deterministic computation
+
+--- A user error value is created by providing a description of the
+--- error situation as a string.
+userError :: String -> IOError
+userError s = UserError s
+
+--- Raises an I/O exception with a given error value.
+ioError :: IOError -> IO _
+ioError err = prim_ioError $## err
+
+prim_ioError :: IOError -> IO _
+prim_ioError external
+
+--- Shows an error values as a string.
+showError :: IOError -> String
+showError (IOError s) = "i/o error: " ++ s
+showError (UserError s) = "user error: " ++ s
+showError (FailError s) = "fail error: " ++ s
+showError (NondetError s) = "nondet error: " ++ s
+
+--- Catches a possible error or failure during the execution of an
+--- I/O action. `(catch act errfun)` executes the I/O action
+--- `act`. If an exception or failure occurs
+--- during this I/O action, the function `errfun` is applied
+--- to the error value.
+catch :: IO a -> (IOError -> IO a) -> IO a
+catch external
+
+----------------------------------------------------------------------------
+
+--- Converts an arbitrary term into an external string representation.
+show :: _ -> String
+show x = prim_show $## x
+
+prim_show :: _ -> String
+prim_show external
+
+--- Converts a term into a string and prints it.
+print :: _ -> IO ()
+print t = putStrLn (show t)
+
+--- Solves a constraint as an I/O action.
+--- Note: the constraint should be always solvable in a deterministic way
+doSolve :: Bool -> IO ()
+doSolve b | b = done
+
+
+-- IO monad auxiliary functions:
+
+--- Executes a sequence of I/O actions and collects all results in a list.
+sequenceIO :: [IO a] -> IO [a]
+sequenceIO [] = return []
+sequenceIO (c:cs) = do x <- c
+ xs <- sequenceIO cs
+ return (x:xs)
+
+--- Executes a sequence of I/O actions and ignores the results.
+sequenceIO_ :: [IO _] -> IO ()
+sequenceIO_ = foldr (>>) done
+
+--- Maps an I/O action function on a list of elements.
+--- The results of all I/O actions are collected in a list.
+mapIO :: (a -> IO b) -> [a] -> IO [b]
+mapIO f = sequenceIO . map f
+
+--- Maps an I/O action function on a list of elements.
+--- The results of all I/O actions are ignored.
+mapIO_ :: (a -> IO _) -> [a] -> IO ()
+mapIO_ f = sequenceIO_ . map f
+
+--- Folds a list of elements using an binary I/O action and a value
+--- for the empty list.
+foldIO :: (a -> b -> IO a) -> a -> [b] -> IO a
+foldIO _ a [] = return a
+foldIO f a (x:xs) = f a x >>= \fax -> foldIO f fax xs
+
+--- Apply a pure function to the result of an I/O action.
+liftIO :: (a -> b) -> IO a -> IO b
+liftIO f m = m >>= return . f
+
+--- Like `mapIO`, but with flipped arguments.
+---
+--- This can be useful if the definition of the function is longer
+--- than those of the list, like in
+---
+--- forIO [1..10] $ \n -> do
+--- ...
+forIO :: [a] -> (a -> IO b) -> IO [b]
+forIO xs f = mapIO f xs
+
+--- Like `mapIO_`, but with flipped arguments.
+---
+--- This can be useful if the definition of the function is longer
+--- than those of the list, like in
+---
+--- forIO_ [1..10] $ \n -> do
+--- ...
+forIO_ :: [a] -> (a -> IO b) -> IO ()
+forIO_ xs f = mapIO_ f xs
+
+--- Performs an `IO` action unless the condition is met.
+unless :: Bool -> IO () -> IO ()
+unless p act = if p then done else act
+
+--- Performs an `IO` action when the condition is met.
+when :: Bool -> IO () -> IO ()
+when p act = if p then act else done
+
+----------------------------------------------------------------
+-- Non-determinism and free variables:
+
+--- Non-deterministic choice _par excellence_.
+--- The value of `x ? y` is either `x` or `y`.
+--- @param x - The right argument.
+--- @param y - The left argument.
+--- @return either `x` or `y` non-deterministically.
+(?) :: a -> a -> a
+x ? _ = x
+_ ? y = y
+
+
+--- Evaluates to a fresh free variable.
+unknown :: _
+unknown = let x free in x
+
+----------------------------------------------------------------
+--- Identity type synonym used to mark deterministic operations.
+type DET a = a
+
+--- Identity function used by the partial evaluator
+--- to mark expressions to be partially evaluated.
+PEVAL :: a -> a
+PEVAL x = x
+
+--- Evaluates the argument to normal form and returns it.
+normalForm :: a -> a
+normalForm x = id $!! x
+
+--- Evaluates the argument to ground normal form and returns it.
+--- Suspends as long as the normal form of the argument is not ground.
+groundNormalForm :: a -> a
+groundNormalForm x = id $## x
+
+-- Only for internal use:
+-- Representation of higher-order applications in FlatCurry.
+apply :: (a -> b) -> a -> b
+apply external
+
+-- Only for internal use:
+-- Representation of conditional rules in FlatCurry.
+cond :: Bool -> a -> a
+cond external
+
+--- Non-strict equational constraint. Used to implement functional patterns.
+(=:<=) :: a -> a -> Bool
+(=:<=) external
+
+-- the end of the standard prelude
diff --git a/test/Pretty.curry b/test/pass/Pretty.curry
similarity index 100%
rename from test/Pretty.curry
rename to test/pass/Pretty.curry
diff --git a/test/pass/RecordTest1.curry b/test/pass/RecordTest1.curry
new file mode 100644
index 0000000000000000000000000000000000000000..90781a221516ae2024dc5c3a05eed330cfc616a7
--- /dev/null
+++ b/test/pass/RecordTest1.curry
@@ -0,0 +1,15 @@
+module RecordTest1 where
+
+data Person = Person { firstName :: String, lastName :: String }
+ | Agent { lastName :: String, trueIdentity :: Person }
+
+mike :: Person
+mike = Person { firstName = "Mike", lastName = "Smith" }
+
+jim = Person { lastName = "Parson", firstName = "Jim" }
+
+jd :: Person
+jd = Agent {}
+
+newId :: Person -> Person -> Person
+newId p i = p { trueIdentity = i }
diff --git a/test/RecordTest2.curry b/test/pass/RecordTest2.curry
similarity index 76%
rename from test/RecordTest2.curry
rename to test/pass/RecordTest2.curry
index d5e087970c9ee78ce2dd928ddf1056044de65285..5f30a1662498acd8f161fbc4e66c40b398d83254 100644
--- a/test/RecordTest2.curry
+++ b/test/pass/RecordTest2.curry
@@ -1,6 +1,6 @@
module RecordTest2 where
-import RecordTest
+import RecordTest1
updLN = mike { lastName = "Doe" }
diff --git a/test/pass/RecordTest3.curry b/test/pass/RecordTest3.curry
new file mode 100644
index 0000000000000000000000000000000000000000..8d7c4d363fd79b1e8c09b8ebaaea60851e157801
--- /dev/null
+++ b/test/pass/RecordTest3.curry
@@ -0,0 +1,13 @@
+--- Internal error in record parsing
+--- Redmine - curry-frontend - bug #9
+
+module RecordTest3 where
+
+data Options = Opts { optHelp :: Bool }
+
+options :: [Options -> Options]
+options = []
+
+parseOpts :: Options
+parseOpts = foldl (flip ($)) Opts { optHelp = False } opts
+ where opts = options
diff --git a/test/pass/RecordsPolymorphism.curry b/test/pass/RecordsPolymorphism.curry
new file mode 100644
index 0000000000000000000000000000000000000000..ab44089a0e603da40ebb37eb9620636eae80169d
--- /dev/null
+++ b/test/pass/RecordsPolymorphism.curry
@@ -0,0 +1,21 @@
+--- Missing polymorphism of record labels
+--- Redmine - curry-fronted - bug #445
+
+--- I don't know if it's really a bug or I only don't understand records well.
+--- The following gives a compiling error:
+
+fun :: a -> Bool
+fun _ = True
+
+fun3 :: a -> a -> Bool
+fun3 _ _ = False
+
+data Rec a = Rec { a :: a, b :: Bool }
+
+testRecSel1 = a Rec { a = 'c', b = True }
+
+testRecSel2 x y = a Rec { a = fun x, b = fun3 y y }
+
+--- The type of the record used in testRecSel1 somehow propagates
+--- to the type of the record used in testRecSel2.
+--- If one comments the definition of testRecSel1 then there is no error.
diff --git a/test/Main.curry b/test/pass/ReexportTest.curry
similarity index 56%
rename from test/Main.curry
rename to test/pass/ReexportTest.curry
index 0a0e9e455c57357f93a2a5f458f1d045c27c025a..43719660b165c7c0103ff41d559ec52ac9a0e16f 100644
--- a/test/Main.curry
+++ b/test/pass/ReexportTest.curry
@@ -1,3 +1,5 @@
+--- importing a reexported module
+
import qualified Set
final xs = Set.last xs
diff --git a/test/SelfExport.curry b/test/pass/SelfExport.curry
similarity index 100%
rename from test/SelfExport.curry
rename to test/pass/SelfExport.curry
diff --git a/test/Set.curry b/test/pass/Set.curry
similarity index 100%
rename from test/Set.curry
rename to test/pass/Set.curry
diff --git a/test/SpaceLeak.curry b/test/pass/SpaceLeak.curry
similarity index 100%
rename from test/SpaceLeak.curry
rename to test/pass/SpaceLeak.curry
diff --git a/test/TyConsTest.curry b/test/pass/TyConsTest.curry
similarity index 100%
rename from test/TyConsTest.curry
rename to test/pass/TyConsTest.curry
diff --git a/test/TypedExpr.curry b/test/pass/TypedExpr.curry
similarity index 100%
rename from test/TypedExpr.curry
rename to test/pass/TypedExpr.curry
diff --git a/test/UntypedAcy.curry b/test/pass/UntypedAcy.curry
similarity index 100%
rename from test/UntypedAcy.curry
rename to test/pass/UntypedAcy.curry
diff --git a/test/Unzip.curry b/test/pass/Unzip.curry
similarity index 100%
rename from test/Unzip.curry
rename to test/pass/Unzip.curry
diff --git a/test/AliasClash.curry b/test/warning/AliasClash.curry
similarity index 100%
rename from test/AliasClash.curry
rename to test/warning/AliasClash.curry
diff --git a/test/Case.curry b/test/warning/Case1.curry
similarity index 100%
rename from test/Case.curry
rename to test/warning/Case1.curry
diff --git a/test/Case2.curry b/test/warning/Case2.curry
similarity index 100%
rename from test/Case2.curry
rename to test/warning/Case2.curry
diff --git a/test/CheckSignature.curry b/test/warning/CheckSignature.curry
similarity index 100%
rename from test/CheckSignature.curry
rename to test/warning/CheckSignature.curry
diff --git a/test/warning/List.curry b/test/warning/List.curry
new file mode 100644
index 0000000000000000000000000000000000000000..c61e76dc03be77c867be936a179e401aaa3069b3
--- /dev/null
+++ b/test/warning/List.curry
@@ -0,0 +1,5 @@
+module List (first) where
+
+first :: [a] -> a
+first [] = error "empty"
+first (x:_) = x
diff --git a/test/warning/Maybe.curry b/test/warning/Maybe.curry
new file mode 100644
index 0000000000000000000000000000000000000000..089c539d15aed27244d71ffb6c11520c643ecf71
--- /dev/null
+++ b/test/warning/Maybe.curry
@@ -0,0 +1,72 @@
+------------------------------------------------------------------------------
+--- Library with some useful functions on the Maybe datatype
+---
+--- @author Frank Huch (source from the corresponding Hugs module)
+--- Bernd Brassel (sequence, mapM)
+--- @version April 2005
+------------------------------------------------------------------------------
+
+module Maybe(
+ isJust, isNothing,
+ fromJust, fromMaybe, listToMaybe, maybeToList,
+ catMaybes, mapMaybe,(>>-), sequenceMaybe, mapMMaybe,
+
+ -- ... and what the Prelude exports
+ Maybe(..),
+ maybe
+ ) where
+
+infixl 1 >>-
+
+isJust :: Maybe _ -> Bool
+isJust (Just _) = True
+isJust Nothing = False
+
+isNothing :: Maybe _ -> Bool
+isNothing Nothing = True
+isNothing (Just _) = False
+
+fromJust :: Maybe a -> a
+fromJust (Just a) = a
+fromJust Nothing = error "Maybe.fromJust: Nothing"
+
+fromMaybe :: a -> Maybe a -> a
+fromMaybe d Nothing = d
+fromMaybe _ (Just a) = a
+
+maybeToList :: Maybe a -> [a]
+maybeToList Nothing = []
+maybeToList (Just a) = [a]
+
+listToMaybe :: [a] -> Maybe a
+listToMaybe [] = Nothing
+listToMaybe (a:_) = Just a
+
+catMaybes :: [Maybe a] -> [a]
+catMaybes ms = [ m | (Just m) <- ms ]
+
+mapMaybe :: (a -> Maybe b) -> [a] -> [b]
+mapMaybe f = catMaybes . map f
+
+--- Monadic bind for Maybe.
+--- Maybe can be interpreted as a monad where Nothing is interpreted
+--- as the error case by this monadic binding.
+--- @param maybeValue - Nothing or Just x
+--- @param f - function to be applied to x
+--- @return Nothing if maybeValue is Nothing,
+--- otherwise f is applied to x
+(>>-) :: Maybe a -> (a -> Maybe b) -> Maybe b
+Nothing >>- _ = Nothing
+(Just x) >>- f = f x
+
+--- monadic sequence for maybe
+sequenceMaybe :: [Maybe a] -> Maybe [a]
+sequenceMaybe [] = Just []
+sequenceMaybe (c:cs) = c >>- \x -> sequenceMaybe cs >>- \xs -> Just (x:xs)
+
+--- monadic map for maybe
+mapMMaybe :: (a -> Maybe b) -> [a] -> Maybe [b]
+mapMMaybe f = sequenceMaybe . map f
+
+
+-----------------------------------------------------------------------------
diff --git a/test/NonExhaustivePattern.curry b/test/warning/NonExhaustivePattern.curry
similarity index 69%
rename from test/NonExhaustivePattern.curry
rename to test/warning/NonExhaustivePattern.curry
index 2b0b6c1239be029dfdf111e281ad9578f86501fe..afc5245fbbcb2526a9eb5edf801be35f61cd961f 100644
--- a/test/NonExhaustivePattern.curry
+++ b/test/warning/NonExhaustivePattern.curry
@@ -1,4 +1,3 @@
-{-# LANGUAGE Records #-}
test x = case x of
Just 1 -> True
Just 2 -> True
@@ -20,6 +19,6 @@ f (_:_) = 1
g "a" = 0
-type Record = { list :: [Bool], int :: Int }
+data Record = R { list :: [Bool], int :: Int }
-rec { list = [] | _ } = 0
+rec R { list = [] } = 0
diff --git a/test/OverlappingPatterns.curry b/test/warning/OverlappingPatterns.curry
similarity index 100%
rename from test/OverlappingPatterns.curry
rename to test/warning/OverlappingPatterns.curry
diff --git a/test/warning/Prelude.curry b/test/warning/Prelude.curry
new file mode 100644
index 0000000000000000000000000000000000000000..75dce400eaf45fc857166ef369caefeb79d583f8
--- /dev/null
+++ b/test/warning/Prelude.curry
@@ -0,0 +1,861 @@
+----------------------------------------------------------------------------
+--- The standard prelude of Curry.
+--- All top-level functions defined in this module
+--- are always available in any Curry program.
+---
+--- @category general
+----------------------------------------------------------------------------
+
+{-# OPTIONS_CYMAKE -Wno-incomplete-patterns -Wno-overlapping #-}
+
+module Prelude where
+
+-- Lines beginning with "--++" are part of the prelude
+-- but cannot parsed by the compiler
+
+-- Infix operator declarations:
+
+
+infixl 9 !!
+infixr 9 .
+infixl 7 *, `div`, `mod`, `quot`, `rem`
+infixl 6 +, -
+-- infixr 5 : -- declared together with list
+infixr 5 ++
+infix 4 =:=, ==, /=, <, >, <=, >=, =:<=
+infix 4 `elem`, `notElem`
+infixr 3 &&
+infixr 2 ||
+infixl 1 >>, >>=
+infixr 0 $, $!, $!!, $#, $##, `seq`, &, &>, ?
+
+
+-- externally defined types for numbers and characters
+data Int
+data Float
+data Char
+
+
+type String = [Char]
+
+-- Some standard combinators:
+
+--- Function composition.
+(.) :: (b -> c) -> (a -> b) -> (a -> c)
+f . g = \x -> f (g x)
+
+--- Identity function.
+id :: a -> a
+id x = x
+
+--- Constant function.
+const :: a -> _ -> a
+const x _ = x
+
+--- Converts an uncurried function to a curried function.
+curry :: ((a,b) -> c) -> a -> b -> c
+curry f a b = f (a,b)
+
+--- Converts an curried function to a function on pairs.
+uncurry :: (a -> b -> c) -> (a,b) -> c
+uncurry f (a,b) = f a b
+
+--- (flip f) is identical to f but with the order of arguments reversed.
+flip :: (a -> b -> c) -> b -> a -> c
+flip f x y = f y x
+
+--- Repeats application of a function until a predicate holds.
+until :: (a -> Bool) -> (a -> a) -> a -> a
+until p f x = if p x then x else until p f (f x)
+
+--- Evaluates the first argument to head normal form (which could also
+--- be a free variable) and returns the second argument.
+seq :: _ -> a -> a
+x `seq` y = const y $! x
+
+--- Evaluates the argument to head normal form and returns it.
+--- Suspends until the result is bound to a non-variable term.
+ensureNotFree :: a -> a
+ensureNotFree external
+
+--- Evaluates the argument to spine form and returns it.
+--- Suspends until the result is bound to a non-variable spine.
+ensureSpine :: [a] -> [a]
+ensureSpine l = ensureList (ensureNotFree l)
+ where ensureList [] = []
+ ensureList (x:xs) = x : ensureSpine xs
+
+--- Right-associative application.
+($) :: (a -> b) -> a -> b
+f $ x = f x
+
+--- Right-associative application with strict evaluation of its argument
+--- to head normal form.
+($!) :: (a -> b) -> a -> b
+($!) external
+
+--- Right-associative application with strict evaluation of its argument
+--- to normal form.
+($!!) :: (a -> b) -> a -> b
+($!!) external
+
+--- Right-associative application with strict evaluation of its argument
+--- to a non-variable term.
+($#) :: (a -> b) -> a -> b
+f $# x = f $! (ensureNotFree x)
+
+--- Right-associative application with strict evaluation of its argument
+--- to ground normal form.
+($##) :: (a -> b) -> a -> b
+($##) external
+
+--- Aborts the execution with an error message.
+error :: String -> _
+error x = prim_error $## x
+
+prim_error :: String -> _
+prim_error external
+
+--- A non-reducible polymorphic function.
+--- It is useful to express a failure in a search branch of the execution.
+--- It could be defined by: `failed = head []`
+failed :: _
+failed external
+
+
+-- Boolean values
+-- already defined as builtin, since it is required for if-then-else
+data Bool = False | True
+
+--- Sequential conjunction on Booleans.
+(&&) :: Bool -> Bool -> Bool
+True && x = x
+False && _ = False
+
+
+--- Sequential disjunction on Booleans.
+(||) :: Bool -> Bool -> Bool
+True || _ = True
+False || x = x
+
+
+--- Negation on Booleans.
+not :: Bool -> Bool
+not True = False
+not False = True
+
+--- Useful name for the last condition in a sequence of conditional equations.
+otherwise :: Bool
+otherwise = True
+
+
+--- The standard conditional. It suspends if the condition is a free variable.
+if_then_else :: Bool -> a -> a -> a
+if_then_else b t f = case b of True -> t
+ False -> f
+
+--- Enforce a Boolean condition to be true.
+--- The computation fails if the argument evaluates to `False`.
+solve :: Bool -> Bool
+solve True = True
+
+--- Conditional expression.
+--- An expression like `(c &> e)` is evaluated by evaluating the first
+--- argument to `True` and then evaluating `e`.
+--- The expression has no value if the condition does not evaluate to `True`.
+(&>) :: Bool -> a -> a
+True &> x = x
+
+--- Equality on finite ground data terms.
+(==) :: a -> a -> Bool
+(==) external
+
+--- Disequality.
+(/=) :: a -> a -> Bool
+x /= y = not (x==y)
+
+--- The equational constraint.
+--- `(e1 =:= e2)` is satisfiable if both sides `e1` and `e2` can be
+--- reduced to a unifiable data term (i.e., a term without defined
+--- function symbols).
+(=:=) :: a -> a -> Bool
+(=:=) external
+
+--- Concurrent conjunction.
+--- An expression like `(c1 & c2)` is evaluated by evaluating
+--- the `c1` and `c2` in a concurrent manner.
+(&) :: Bool -> Bool -> Bool
+(&) external
+
+
+--- Ordering type. Useful as a result of comparison functions.
+data Ordering = LT | EQ | GT
+
+--- Comparison of arbitrary ground data terms.
+--- Data constructors are compared in the order of their definition
+--- in the datatype declarations and recursively in the arguments.
+compare :: a -> a -> Ordering
+compare x y | x == y = EQ
+ | x <= y = LT
+ | otherwise = GT
+
+--- Less-than on ground data terms.
+(<) :: a -> a -> Bool
+x < y = not (y <= x)
+
+--- Greater-than on ground data terms.
+(>) :: a -> a -> Bool
+x > y = not (x <= y)
+
+--- Less-or-equal on ground data terms.
+(<=) :: a -> a -> Bool
+(<=) external
+
+--- Greater-or-equal on ground data terms.
+(>=) :: a -> a -> Bool
+x >= y = not (x < y)
+
+--- Maximum of ground data terms.
+max :: a -> a -> a
+max x y = if x >= y then x else y
+
+--- Minimum of ground data terms.
+min :: a -> a -> a
+min x y = if x <= y then x else y
+
+
+-- Pairs
+
+--++ data (a,b) = (a,b)
+
+--- Selects the first component of a pair.
+fst :: (a,_) -> a
+fst (x,_) = x
+
+--- Selects the second component of a pair.
+snd :: (_,b) -> b
+snd (_,y) = y
+
+
+-- Unit type
+--++ data () = ()
+
+
+-- Lists
+
+--++ data [a] = [] | a : [a]
+
+--- Computes the first element of a list.
+head :: [a] -> a
+head (x:_) = x
+
+--- Computes the remaining elements of a list.
+tail :: [a] -> [a]
+tail (_:xs) = xs
+
+--- Is a list empty?
+null :: [_] -> Bool
+null [] = True
+null (_:_) = False
+
+--- Concatenates two lists.
+--- Since it is flexible, it could be also used to split a list
+--- into two sublists etc.
+(++) :: [a] -> [a] -> [a]
+[] ++ ys = ys
+(x:xs) ++ ys = x : xs++ys
+
+--- Computes the length of a list.
+length :: [_] -> Int
+length xs = len xs 0
+ where
+ len [] n = n
+ len (_:ys) n = let np1 = n + 1 in len ys $!! np1
+--length [] = 0
+--length (_:xs) = 1 + length xs
+
+--- List index (subscript) operator, head has index 0.
+(!!) :: [a] -> Int -> a
+(x:xs) !! n | n==0 = x
+ | n>0 = xs !! (n-1)
+
+--- Map a function on all elements of a list.
+map :: (a->b) -> [a] -> [b]
+map _ [] = []
+map f (x:xs) = f x : map f xs
+
+--- Accumulates all list elements by applying a binary operator from
+--- left to right. Thus,
+---
+--- foldl f z [x1,x2,...,xn] = (...((z `f` x1) `f` x2) ...) `f` xn
+foldl :: (a -> b -> a) -> a -> [b] -> a
+foldl _ z [] = z
+foldl f z (x:xs) = foldl f (f z x) xs
+
+--- Accumulates a non-empty list from left to right.
+foldl1 :: (a -> a -> a) -> [a] -> a
+foldl1 f (x:xs) = foldl f x xs
+
+--- Accumulates all list elements by applying a binary operator from
+--- right to left. Thus,
+---
+--- foldr f z [x1,x2,...,xn] = (x1 `f` (x2 `f` ... (xn `f` z)...))
+foldr :: (a->b->b) -> b -> [a] -> b
+foldr _ z [] = z
+foldr f z (x:xs) = f x (foldr f z xs)
+
+--- Accumulates a non-empty list from right to left:
+foldr1 :: (a -> a -> a) -> [a] -> a
+foldr1 _ [x] = x
+foldr1 f (x1:x2:xs) = f x1 (foldr1 f (x2:xs))
+
+--- Filters all elements satisfying a given predicate in a list.
+filter :: (a -> Bool) -> [a] -> [a]
+filter _ [] = []
+filter p (x:xs) = if p x then x : filter p xs
+ else filter p xs
+
+--- Joins two lists into one list of pairs. If one input list is shorter than
+--- the other, the additional elements of the longer list are discarded.
+zip :: [a] -> [b] -> [(a,b)]
+zip [] _ = []
+zip (_:_) [] = []
+zip (x:xs) (y:ys) = (x,y) : zip xs ys
+
+--- Joins three lists into one list of triples. If one input list is shorter
+--- than the other, the additional elements of the longer lists are discarded.
+zip3 :: [a] -> [b] -> [c] -> [(a,b,c)]
+zip3 [] _ _ = []
+zip3 (_:_) [] _ = []
+zip3 (_:_) (_:_) [] = []
+zip3 (x:xs) (y:ys) (z:zs) = (x,y,z) : zip3 xs ys zs
+
+--- Joins two lists into one list by applying a combination function to
+--- corresponding pairs of elements. Thus `zip = zipWith (,)`
+zipWith :: (a->b->c) -> [a] -> [b] -> [c]
+zipWith _ [] _ = []
+zipWith _ (_:_) [] = []
+zipWith f (x:xs) (y:ys) = f x y : zipWith f xs ys
+
+--- Joins three lists into one list by applying a combination function to
+--- corresponding triples of elements. Thus `zip3 = zipWith3 (,,)`
+zipWith3 :: (a->b->c->d) -> [a] -> [b] -> [c] -> [d]
+zipWith3 _ [] _ _ = []
+zipWith3 _ (_:_) [] _ = []
+zipWith3 _ (_:_) (_:_) [] = []
+zipWith3 f (x:xs) (y:ys) (z:zs) = f x y z : zipWith3 f xs ys zs
+
+--- Transforms a list of pairs into a pair of lists.
+unzip :: [(a,b)] -> ([a],[b])
+unzip [] = ([],[])
+unzip ((x,y):ps) = (x:xs,y:ys) where (xs,ys) = unzip ps
+
+--- Transforms a list of triples into a triple of lists.
+unzip3 :: [(a,b,c)] -> ([a],[b],[c])
+unzip3 [] = ([],[],[])
+unzip3 ((x,y,z):ts) = (x:xs,y:ys,z:zs) where (xs,ys,zs) = unzip3 ts
+
+--- Concatenates a list of lists into one list.
+concat :: [[a]] -> [a]
+concat l = foldr (++) [] l
+
+--- Maps a function from elements to lists and merges the result into one list.
+concatMap :: (a -> [b]) -> [a] -> [b]
+concatMap f = concat . map f
+
+--- Infinite list of repeated applications of a function f to an element x.
+--- Thus, `iterate f x = [x, f x, f (f x),...]`
+iterate :: (a -> a) -> a -> [a]
+iterate f x = x : iterate f (f x)
+
+--- Infinite list where all elements have the same value.
+--- Thus, `repeat x = [x, x, x,...]`
+repeat :: a -> [a]
+repeat x = x : repeat x
+
+--- List of length n where all elements have the same value.
+replicate :: Int -> a -> [a]
+replicate n x = take n (repeat x)
+
+--- Returns prefix of length n.
+take :: Int -> [a] -> [a]
+take n l = if n<=0 then [] else takep n l
+ where takep _ [] = []
+ takep m (x:xs) = x : take (m-1) xs
+
+--- Returns suffix without first n elements.
+drop :: Int -> [a] -> [a]
+drop n l = if n<=0 then l else dropp n l
+ where dropp _ [] = []
+ dropp m (_:xs) = drop (m-1) xs
+
+--- (splitAt n xs) is equivalent to (take n xs, drop n xs)
+splitAt :: Int -> [a] -> ([a],[a])
+splitAt n l = if n<=0 then ([],l) else splitAtp n l
+ where splitAtp _ [] = ([],[])
+ splitAtp m (x:xs) = let (ys,zs) = splitAt (m-1) xs in (x:ys,zs)
+
+--- Returns longest prefix with elements satisfying a predicate.
+takeWhile :: (a -> Bool) -> [a] -> [a]
+takeWhile _ [] = []
+takeWhile p (x:xs) = if p x then x : takeWhile p xs else []
+
+--- Returns suffix without takeWhile prefix.
+dropWhile :: (a -> Bool) -> [a] -> [a]
+dropWhile _ [] = []
+dropWhile p (x:xs) = if p x then dropWhile p xs else x:xs
+
+--- (span p xs) is equivalent to (takeWhile p xs, dropWhile p xs)
+span :: (a -> Bool) -> [a] -> ([a],[a])
+span _ [] = ([],[])
+span p (x:xs)
+ | p x = let (ys,zs) = span p xs in (x:ys, zs)
+ | otherwise = ([],x:xs)
+
+--- (break p xs) is equivalent to (takeWhile (not.p) xs, dropWhile (not.p) xs).
+--- Thus, it breaks a list at the first occurrence of an element satisfying p.
+break :: (a -> Bool) -> [a] -> ([a],[a])
+break p = span (not . p)
+
+--- Breaks a string into a list of lines where a line is terminated at a
+--- newline character. The resulting lines do not contain newline characters.
+lines :: String -> [String]
+lines [] = []
+lines (x:xs) = let (l,xs_l) = splitline (x:xs) in l : lines xs_l
+ where splitline [] = ([],[])
+ splitline (c:cs) = if c=='\n'
+ then ([],cs)
+ else let (ds,es) = splitline cs in (c:ds,es)
+
+--- Concatenates a list of strings with terminating newlines.
+unlines :: [String] -> String
+unlines ls = concatMap (++"\n") ls
+
+--- Breaks a string into a list of words where the words are delimited by
+--- white spaces.
+words :: String -> [String]
+words s = let s1 = dropWhile isSpace s
+ in if s1=="" then []
+ else let (w,s2) = break isSpace s1
+ in w : words s2
+ where
+ isSpace c = c == ' ' || c == '\t' || c == '\n' || c == '\r'
+
+--- Concatenates a list of strings with a blank between two strings.
+unwords :: [String] -> String
+unwords ws = if ws==[] then []
+ else foldr1 (\w s -> w ++ ' ':s) ws
+
+--- Reverses the order of all elements in a list.
+reverse :: [a] -> [a]
+reverse = foldl (flip (:)) []
+
+--- Computes the conjunction of a Boolean list.
+and :: [Bool] -> Bool
+and = foldr (&&) True
+
+--- Computes the disjunction of a Boolean list.
+or :: [Bool] -> Bool
+or = foldr (||) False
+
+--- Is there an element in a list satisfying a given predicate?
+any :: (a -> Bool) -> [a] -> Bool
+any p = or . map p
+
+--- Is a given predicate satisfied by all elements in a list?
+all :: (a -> Bool) -> [a] -> Bool
+all p = and . map p
+
+--- Element of a list?
+elem :: a -> [a] -> Bool
+elem x = any (x==)
+
+--- Not element of a list?
+notElem :: a -> [a] -> Bool
+notElem x = all (x/=)
+
+--- Looks up a key in an association list.
+lookup :: a -> [(a,b)] -> Maybe b
+lookup _ [] = Nothing
+lookup k ((x,y):xys)
+ | k==x = Just y
+ | otherwise = lookup k xys
+
+--- Generates an infinite sequence of ascending integers.
+enumFrom :: Int -> [Int] -- [n..]
+enumFrom n = n : enumFrom (n+1)
+
+--- Generates an infinite sequence of integers with a particular in/decrement.
+enumFromThen :: Int -> Int -> [Int] -- [n1,n2..]
+enumFromThen n1 n2 = iterate ((n2-n1)+) n1
+
+--- Generates a sequence of ascending integers.
+enumFromTo :: Int -> Int -> [Int] -- [n..m]
+enumFromTo n m = if n>m then [] else n : enumFromTo (n+1) m
+
+--- Generates a sequence of integers with a particular in/decrement.
+enumFromThenTo :: Int -> Int -> Int -> [Int] -- [n1,n2..m]
+enumFromThenTo n1 n2 m = takeWhile p (enumFromThen n1 n2)
+ where p x | n2 >= n1 = (x <= m)
+ | otherwise = (x >= m)
+
+
+--- Converts a character into its ASCII value.
+ord :: Char -> Int
+ord c = prim_ord $# c
+
+prim_ord :: Char -> Int
+prim_ord external
+
+--- Converts a Unicode value into a character, fails iff the value is out of bounds
+chr :: Int -> Char
+chr n | n >= 0 = prim_chr $# n
+-- chr n | n < 0 || n > 1114111 = failed
+-- | otherwise = prim_chr $# n
+
+prim_chr :: Int -> Char
+prim_chr external
+
+
+-- Types of primitive arithmetic functions and predicates
+
+--- Adds two integers.
+(+) :: Int -> Int -> Int
+(+) external
+
+--- Subtracts two integers.
+(-) :: Int -> Int -> Int
+(-) external
+
+--- Multiplies two integers.
+(*) :: Int -> Int -> Int
+(*) external
+
+--- Integer division. The value is the integer quotient of its arguments
+--- and always truncated towards negative infinity.
+--- Thus, the value of `13 `div` 5`

is `2`

,
+--- and the value of `-15 `div` 4`

is `-4`

.
+div :: Int -> Int -> Int
+div external
+
+--- Integer remainder. The value is the remainder of the integer division and
+--- it obeys the rule `x `mod` y = x - y * (x `div` y)`

.
+--- Thus, the value of `13 `mod` 5`

is `3`

,
+--- and the value of `-15 `mod` 4`

is `-3`

.
+mod :: Int -> Int -> Int
+mod external
+
+--- Returns an integer (quotient,remainder) pair.
+--- The value is the integer quotient of its arguments
+--- and always truncated towards negative infinity.
+divMod :: Int -> Int -> (Int, Int)
+divMod external
+
+--- Integer division. The value is the integer quotient of its arguments
+--- and always truncated towards zero.
+--- Thus, the value of `13 `quot` 5`

is `2`

,
+--- and the value of `-15 `quot` 4`

is `-3`

.
+quot :: Int -> Int -> Int
+quot external
+
+--- Integer remainder. The value is the remainder of the integer division and
+--- it obeys the rule `x `rem` y = x - y * (x `quot` y)`

.
+--- Thus, the value of `13 `rem` 5`

is `3`

,
+--- and the value of `-15 `rem` 4`

is `-3`

.
+rem :: Int -> Int -> Int
+rem external
+
+--- Returns an integer (quotient,remainder) pair.
+--- The value is the integer quotient of its arguments
+--- and always truncated towards zero.
+quotRem :: Int -> Int -> (Int, Int)
+quotRem external
+
+--- Unary minus. Usually written as "- e".
+negate :: Int -> Int
+negate x = 0 - x
+
+--- Unary minus on Floats. Usually written as "-e".
+negateFloat :: Float -> Float
+negateFloat external
+
+
+-- Constraints (included for backwar compatibility)
+type Success = Bool
+
+--- The always satisfiable constraint.
+success :: Success
+success = True
+
+-- Maybe type
+
+data Maybe a = Nothing | Just a
+
+maybe :: b -> (a -> b) -> Maybe a -> b
+maybe n _ Nothing = n
+maybe _ f (Just x) = f x
+
+
+-- Either type
+
+data Either a b = Left a | Right b
+
+either :: (a -> c) -> (b -> c) -> Either a b -> c
+either f _ (Left x) = f x
+either _ g (Right x) = g x
+
+
+-- Monadic IO
+
+data IO _ -- conceptually: World -> (a,World)
+
+--- Sequential composition of actions.
+--- @param a - An action
+--- @param fa - A function from a value into an action
+--- @return An action that first performs a (yielding result r)
+--- and then performs (fa r)
+(>>=) :: IO a -> (a -> IO b) -> IO b
+(>>=) external
+
+--- The empty action that directly returns its argument.
+return :: a -> IO a
+return external
+
+--- Sequential composition of actions.
+--- @param a1 - An action
+--- @param a2 - An action
+--- @return An action that first performs a1 and then a2
+(>>) :: IO _ -> IO b -> IO b
+a >> b = a >>= (\_ -> b)
+
+--- The empty action that returns nothing.
+done :: IO ()
+done = return ()
+
+--- An action that puts its character argument on standard output.
+putChar :: Char -> IO ()
+putChar c = prim_putChar $## c
+
+prim_putChar :: Char -> IO ()
+prim_putChar external
+
+--- An action that reads a character from standard output and returns it.
+getChar :: IO Char
+getChar external
+
+--- An action that (lazily) reads a file and returns its contents.
+readFile :: String -> IO String
+readFile f = prim_readFile $## f
+
+prim_readFile :: String -> IO String
+prim_readFile external
+
+--- An action that writes a file.
+--- @param filename - The name of the file to be written.
+--- @param contents - The contents to be written to the file.
+writeFile :: String -> String -> IO ()
+writeFile f s = (prim_writeFile $## f) $## s
+
+prim_writeFile :: String -> String -> IO ()
+prim_writeFile external
+
+--- An action that appends a string to a file.
+--- It behaves like writeFile if the file does not exist.
+--- @param filename - The name of the file to be written.
+--- @param contents - The contents to be appended to the file.
+appendFile :: String -> String -> IO ()
+appendFile f s = (prim_appendFile $## f) $## s
+
+prim_appendFile :: String -> String -> IO ()
+prim_appendFile external
+
+--- Action to print a string on stdout.
+putStr :: String -> IO ()
+putStr [] = done
+putStr (c:cs) = putChar c >> putStr cs
+
+--- Action to print a string with a newline on stdout.
+putStrLn :: String -> IO ()
+putStrLn cs = putStr cs >> putChar '\n'
+
+--- Action to read a line from stdin.
+getLine :: IO String
+getLine = do c <- getChar
+ if c=='\n' then return []
+ else do cs <- getLine
+ return (c:cs)
+
+----------------------------------------------------------------------------
+-- Error handling in the I/O monad:
+
+--- The (abstract) type of error values.
+--- Currently, it distinguishes between general IO errors,
+--- user-generated errors (see 'userError'), failures and non-determinism
+--- errors during IO computations. These errors can be caught by 'catch'
+--- and shown by 'showError'.
+--- Each error contains a string shortly explaining the error.
+--- This type might be extended in the future to distinguish
+--- further error situations.
+data IOError
+ = IOError String -- normal IO error
+ | UserError String -- user-specified error
+ | FailError String -- failing computation
+ | NondetError String -- non-deterministic computation
+
+--- A user error value is created by providing a description of the
+--- error situation as a string.
+userError :: String -> IOError
+userError s = UserError s
+
+--- Raises an I/O exception with a given error value.
+ioError :: IOError -> IO _
+ioError err = prim_ioError $## err
+
+prim_ioError :: IOError -> IO _
+prim_ioError external
+
+--- Shows an error values as a string.
+showError :: IOError -> String
+showError (IOError s) = "i/o error: " ++ s
+showError (UserError s) = "user error: " ++ s
+showError (FailError s) = "fail error: " ++ s
+showError (NondetError s) = "nondet error: " ++ s
+
+--- Catches a possible error or failure during the execution of an
+--- I/O action. `(catch act errfun)` executes the I/O action
+--- `act`. If an exception or failure occurs
+--- during this I/O action, the function `errfun` is applied
+--- to the error value.
+catch :: IO a -> (IOError -> IO a) -> IO a
+catch external
+
+----------------------------------------------------------------------------
+
+--- Converts an arbitrary term into an external string representation.
+show :: _ -> String
+show x = prim_show $## x
+
+prim_show :: _ -> String
+prim_show external
+
+--- Converts a term into a string and prints it.
+print :: _ -> IO ()
+print t = putStrLn (show t)
+
+--- Solves a constraint as an I/O action.
+--- Note: the constraint should be always solvable in a deterministic way
+doSolve :: Bool -> IO ()
+doSolve b | b = done
+
+
+-- IO monad auxiliary functions:
+
+--- Executes a sequence of I/O actions and collects all results in a list.
+sequenceIO :: [IO a] -> IO [a]
+sequenceIO [] = return []
+sequenceIO (c:cs) = do x <- c
+ xs <- sequenceIO cs
+ return (x:xs)
+
+--- Executes a sequence of I/O actions and ignores the results.
+sequenceIO_ :: [IO _] -> IO ()
+sequenceIO_ = foldr (>>) done
+
+--- Maps an I/O action function on a list of elements.
+--- The results of all I/O actions are collected in a list.
+mapIO :: (a -> IO b) -> [a] -> IO [b]
+mapIO f = sequenceIO . map f
+
+--- Maps an I/O action function on a list of elements.
+--- The results of all I/O actions are ignored.
+mapIO_ :: (a -> IO _) -> [a] -> IO ()
+mapIO_ f = sequenceIO_ . map f
+
+--- Folds a list of elements using an binary I/O action and a value
+--- for the empty list.
+foldIO :: (a -> b -> IO a) -> a -> [b] -> IO a
+foldIO _ a [] = return a
+foldIO f a (x:xs) = f a x >>= \fax -> foldIO f fax xs
+
+--- Apply a pure function to the result of an I/O action.
+liftIO :: (a -> b) -> IO a -> IO b
+liftIO f m = m >>= return . f
+
+--- Like `mapIO`, but with flipped arguments.
+---
+--- This can be useful if the definition of the function is longer
+--- than those of the list, like in
+---
+--- forIO [1..10] $ \n -> do
+--- ...
+forIO :: [a] -> (a -> IO b) -> IO [b]
+forIO xs f = mapIO f xs
+
+--- Like `mapIO_`, but with flipped arguments.
+---
+--- This can be useful if the definition of the function is longer
+--- than those of the list, like in
+---
+--- forIO_ [1..10] $ \n -> do
+--- ...
+forIO_ :: [a] -> (a -> IO b) -> IO ()
+forIO_ xs f = mapIO_ f xs
+
+--- Performs an `IO` action unless the condition is met.
+unless :: Bool -> IO () -> IO ()
+unless p act = if p then done else act
+
+--- Performs an `IO` action when the condition is met.
+when :: Bool -> IO () -> IO ()
+when p act = if p then act else done
+
+----------------------------------------------------------------
+-- Non-determinism and free variables:
+
+--- Non-deterministic choice _par excellence_.
+--- The value of `x ? y` is either `x` or `y`.
+--- @param x - The right argument.
+--- @param y - The left argument.
+--- @return either `x` or `y` non-deterministically.
+(?) :: a -> a -> a
+x ? _ = x
+_ ? y = y
+
+
+--- Evaluates to a fresh free variable.
+unknown :: _
+unknown = let x free in x
+
+----------------------------------------------------------------
+--- Identity type synonym used to mark deterministic operations.
+type DET a = a
+
+--- Identity function used by the partial evaluator
+--- to mark expressions to be partially evaluated.
+PEVAL :: a -> a
+PEVAL x = x
+
+--- Evaluates the argument to normal form and returns it.
+normalForm :: a -> a
+normalForm x = id $!! x
+
+--- Evaluates the argument to ground normal form and returns it.
+--- Suspends as long as the normal form of the argument is not ground.
+groundNormalForm :: a -> a
+groundNormalForm x = id $## x
+
+-- Only for internal use:
+-- Representation of higher-order applications in FlatCurry.
+apply :: (a -> b) -> a -> b
+apply external
+
+-- Only for internal use:
+-- Representation of conditional rules in FlatCurry.
+cond :: Bool -> a -> a
+cond external
+
+--- Non-strict equational constraint. Used to implement functional patterns.
+(=:<=) :: a -> a -> Bool
+(=:<=) external
+
+-- the end of the standard prelude
diff --git a/test/Shadow.curry b/test/warning/ShadowingSymbols.curry
similarity index 67%
rename from test/Shadow.curry
rename to test/warning/ShadowingSymbols.curry
index 432957d3993112223169b32e875265e4259f5c7a..13db4a7c360616e18314df2184aabf0e00d6ad93 100644
--- a/test/Shadow.curry
+++ b/test/warning/ShadowingSymbols.curry
@@ -1,4 +1,4 @@
-module Shadow where
+module ShadowingSymbols where
main = do
x <- return True
@@ -12,4 +12,4 @@ main2 = do
f x = g 1 where g x = x
-lc = [x | x <- [1..10], x <- [1..10]]
\ No newline at end of file
+lc = [x | x <- [1..10], x <- [1..10]]