Testsuite: tabs -> spaces [skip ci]
authorThomas Miedema <thomasmiedema@gmail.com>
Sat, 18 Jun 2016 20:44:19 +0000 (22:44 +0200)
committerThomas Miedema <thomasmiedema@gmail.com>
Mon, 20 Jun 2016 14:22:07 +0000 (16:22 +0200)
59 files changed:
testsuite/tests/gadt/Nilsson.hs
testsuite/tests/gadt/T3169.hs
testsuite/tests/gadt/T7205.hs
testsuite/tests/gadt/gadt2.hs
testsuite/tests/gadt/gadt25.hs
testsuite/tests/gadt/gadt5.hs
testsuite/tests/gadt/gadt8.hs
testsuite/tests/gadt/josef.hs
testsuite/tests/gadt/nbe.hs
testsuite/tests/gadt/records.hs
testsuite/tests/gadt/red-black.hs
testsuite/tests/gadt/scoped.hs
testsuite/tests/gadt/set.hs
testsuite/tests/gadt/termination.hs
testsuite/tests/gadt/ubx-records.hs
testsuite/tests/gadt/while.hs
testsuite/tests/ghci.debugger/scripts/break012.hs
testsuite/tests/ghci.debugger/scripts/break013.hs
testsuite/tests/ghci.debugger/scripts/break014.hs
testsuite/tests/ghci.debugger/scripts/print021.hs
testsuite/tests/mdo/should_compile/mdo001.hs
testsuite/tests/mdo/should_compile/mdo002.hs
testsuite/tests/mdo/should_compile/mdo004.hs
testsuite/tests/mdo/should_compile/mdo005.hs
testsuite/tests/mdo/should_fail/mdofail005.hs
testsuite/tests/mdo/should_run/mdorun001.hs
testsuite/tests/module/Mod173_Aux.hs
testsuite/tests/module/mod168.hs
testsuite/tests/module/mod171.hs
testsuite/tests/module/mod173.hs
testsuite/tests/perf/should_run/MethSharing.hs
testsuite/tests/perf/should_run/T3245.hs
testsuite/tests/rebindable/DoParamM.hs
testsuite/tests/rebindable/T4851.hs
testsuite/tests/rebindable/rebindable1.hs
testsuite/tests/rebindable/rebindable2.hs
testsuite/tests/rebindable/rebindable3.hs
testsuite/tests/rebindable/rebindable4.hs
testsuite/tests/rebindable/rebindable5.hs
testsuite/tests/rebindable/rebindable6.hs
testsuite/tests/rename/prog001/rn037.hs
testsuite/tests/rename/prog002/rnfail037.hs
testsuite/tests/rename/prog005/View.hs
testsuite/tests/rename/should_compile/RnAux017.hs
testsuite/tests/rename/should_compile/T3221.hs
testsuite/tests/rename/should_compile/rn029.hs
testsuite/tests/rename/should_compile/rn041.hs
testsuite/tests/rename/should_compile/rn043.hs
testsuite/tests/rename/should_compile/rn049.hs
testsuite/tests/rename/should_compile/timing001.hs
testsuite/tests/rename/should_fail/rnfail002.hs
testsuite/tests/rename/should_fail/rnfail004.hs
testsuite/tests/rename/should_fail/rnfail008.hs
testsuite/tests/rename/should_fail/rnfail015.hs
testsuite/tests/rename/should_fail/rnfail017.hs
testsuite/tests/rename/should_fail/rnfail020.hs
testsuite/tests/rename/should_fail/rnfail023.hs
testsuite/tests/safeHaskell/safeLanguage/SafeLang11_B.hs
testsuite/tests/safeHaskell/safeLanguage/SafeLang12_B.hs

index bb2fa1b..50dd3c5 100644 (file)
@@ -1,6 +1,6 @@
 {-# LANGUAGE GADTs, ScopedTypeVariables #-}
 
--- Supplied by Henrik Nilsson, showed up a bug in GADTs 
+-- Supplied by Henrik Nilsson, showed up a bug in GADTs
 
 module Nilsson where
 
@@ -12,7 +12,7 @@ fromEvent = undefined
 usrErr :: String -> String -> String -> a
 usrErr = undefined
 
-type DTime = Double    -- [s]
+type DTime = Double     -- [s]
 
 data SF a b = SF {sfTF :: a -> Transition a b}
 
@@ -53,13 +53,13 @@ sfArr (FDG f)     = sfArrG f
 sfId :: SF' a a
 sfId = sf
     where
-       sf = SFArr (\_ a -> (sf, a)) FDI
+        sf = SFArr (\_ a -> (sf, a)) FDI
 
 
 sfConst :: b -> SF' a b
 sfConst b = sf
     where
-       sf = SFArr (\_ _ -> (sf, b)) (FDC b)
+        sf = SFArr (\_ _ -> (sf, b)) (FDC b)
 
 
 sfNever :: SF' a (Event b)
@@ -76,7 +76,7 @@ sfArrE f fne = sf
 sfArrG :: (a -> b) -> SF' a b
 sfArrG f = sf
     where
-       sf = SFArr (\_ a -> (sf, f a)) (FDG f)
+        sf = SFArr (\_ a -> (sf, f a)) (FDG f)
 
 
 sfAcc :: (c -> a -> (c, b)) -> c -> b -> SF' (Event a) b
@@ -107,10 +107,10 @@ sfAcc f c bne = sf
 -- * We still want to be able to get hold of the original function.
 
 data FunDesc a b where
-    FDI :: FunDesc a a                                 -- Identity function
-    FDC :: b -> FunDesc a b                            -- Constant function
-    FDE :: (Event a -> b) -> b -> FunDesc (Event a) b  -- Event-processing fun
-    FDG :: (a -> b) -> FunDesc a b                     -- General function
+    FDI :: FunDesc a a                                  -- Identity function
+    FDC :: b -> FunDesc a b                             -- Constant function
+    FDE :: (Event a -> b) -> b -> FunDesc (Event a) b   -- Event-processing fun
+    FDG :: (a -> b) -> FunDesc a b                      -- General function
 
 fdFun :: FunDesc a b -> (a -> b)
 fdFun FDI       = id
@@ -142,17 +142,17 @@ vfyNoEv :: Event a -> b -> b
 vfyNoEv NoEvent b = b
 vfyNoEv _       _  = usrErr "AFRP" "vfyNoEv"
                             "Assertion failed: Functions on events must not \
-                           \map NoEvent to Event."
+                            \map NoEvent to Event."
 
 compPrim :: SF a b -> SF b c -> SF a c
 compPrim (SF {sfTF = tf10}) (SF {sfTF = tf20}) = SF {sfTF = tf0}
     where
-       tf0 a0 = (cpXX sf1 sf2, c0)
-           where
-               (sf1, b0) = tf10 a0
-               (sf2, c0) = tf20 b0
+        tf0 a0 = (cpXX sf1 sf2, c0)
+            where
+                (sf1, b0) = tf10 a0
+                (sf2, c0) = tf20 b0
 
-       -- Naming convention: cp<X><Y> where  <X> and <Y> is one of:
+        -- Naming convention: cp<X><Y> where  <X> and <Y> is one of:
         -- X - arbitrary signal function
         -- A - arbitrary pure arrow
         -- C - constant arrow
@@ -165,35 +165,35 @@ compPrim (SF {sfTF = tf10}) (SF {sfTF = tf20}) = SF {sfTF = tf0}
         cpXX sf1                 (SFArr _ fd2)     = cpXA sf1 fd2
         cpXX (SFAcc _ f1 s1 bne) (SFAcc _ f2 s2 cne) =
             sfAcc f (s1, s2) (vfyNoEv bne cne)
-           where
-               f (s1, s2) a =
-                   case f1 s1 a of
-                       (s1', NoEvent) -> ((s1', s2), cne)
-                       (s1', Event b) ->
-                           let (s2', c) = f2 s2 b in ((s1', s2'), c)
+            where
+                f (s1, s2) a =
+                    case f1 s1 a of
+                        (s1', NoEvent) -> ((s1', s2), cne)
+                        (s1', Event b) ->
+                            let (s2', c) = f2 s2 b in ((s1', s2'), c)
         cpXX (SFCpAXA _ fd11 sf12 fd13) (SFCpAXA _ fd21 sf22 fd23) =
             cpAXA fd11 (cpXX (cpXA sf12 (fdComp fd13 fd21)) sf22) fd23
-       cpXX sf1 sf2 = SF' tf
-           where
-               tf dt a = (cpXX sf1' sf2', c)
-                   where
-                       (sf1', b) = (sfTF' sf1) dt a
-                       (sf2', c) = (sfTF' sf2) dt b
+        cpXX sf1 sf2 = SF' tf
+            where
+                tf dt a = (cpXX sf1' sf2', c)
+                    where
+                        (sf1', b) = (sfTF' sf1) dt a
+                        (sf2', c) = (sfTF' sf2) dt b
 
         cpAXA :: FunDesc a b -> SF' b c -> FunDesc c d -> SF' a d
         cpAXA FDI     sf2 fd3     = cpXA sf2 fd3
         cpAXA fd1     sf2 FDI     = cpAX fd1 sf2
         cpAXA (FDC b) sf2 fd3     = cpCXA b sf2 fd3
-        cpAXA fd1     sf2 (FDC d) = sfConst d        
+        cpAXA fd1     sf2 (FDC d) = sfConst d
         cpAXA fd1 (SFArr _ fd2) fd3 = sfArr (fdComp (fdComp fd1 fd2) fd3)
 
-       cpAX :: FunDesc a b -> SF' b c -> SF' a c
+        cpAX :: FunDesc a b -> SF' b c -> SF' a c
         cpAX FDI           sf2 = sf2
         cpAX (FDC b)       sf2 = cpCX b sf2
         cpAX (FDE f1 f1ne) sf2 = cpEX f1 f1ne sf2
         cpAX (FDG f1)      sf2 = cpGX f1 sf2
 
-       cpXA :: SF' a b -> FunDesc b c -> SF' a c
+        cpXA :: SF' a b -> FunDesc b c -> SF' a c
         cpXA sf1 FDI           = sf1
         cpXA sf1 (FDC c)       = sfConst c
         cpXA sf1 (FDE f2 f2ne) = cpXE sf1 f2 f2ne
@@ -204,13 +204,13 @@ compPrim (SF {sfTF = tf10}) (SF {sfTF = tf20}) = SF {sfTF = tf0}
         cpCX b (SFAcc _ _ _ cne)          = sfConst (vfyNoEv b cne)
         cpCX b (SFCpAXA _ fd21 sf22 fd23) =
             cpCXA ((fdFun fd21) b) sf22 fd23
-       cpCX b sf2 = SFCpAXA tf (FDC b) sf2 FDI
-           where
-               tf dt _ = (cpCX b sf2', c)
-                   where
-                       (sf2', c) = (sfTF' sf2) dt b
+        cpCX b sf2 = SFCpAXA tf (FDC b) sf2 FDI
+            where
+                tf dt _ = (cpCX b sf2', c)
+                    where
+                        (sf2', c) = (sfTF' sf2) dt b
 
--- For SPJ: The following version did not work. 
+-- For SPJ: The following version did not work.
 -- The commented out one below did work, by lambda-lifting cpCXAux
         cpCXA :: b -> SF' b c -> FunDesc c d -> SF' a d
         cpCXA b sf2 FDI     = cpCX b sf2
@@ -219,7 +219,7 @@ compPrim (SF {sfTF = tf10}) (SF {sfTF = tf20}) = SF {sfTF = tf0}
             where
                 f3  = fdFun fd3
 
-               cpCXAAux :: SF' b c -> SF' a d
+                cpCXAAux :: SF' b c -> SF' a d
                 cpCXAAux (SFArr _ fd2) = sfConst (f3 ((fdFun fd2) b))
                 cpCXAAux (SFAcc _ _ _ cne) = sfConst (vfyNoEv b (f3 cne))
                 cpCXAAux (SFCpAXA _ fd21 sf22 fd23) = cpCXA ((fdFun fd21) b) sf22 (fdComp fd23 fd3)
@@ -231,7 +231,7 @@ compPrim (SF {sfTF = tf10}) (SF {sfTF = tf20}) = SF {sfTF = tf0}
         cpCXA b sf2 fd3 = cpCXAAux b fd3 (fdFun fd3) sf2
             where
                 -- f3  = fdFun fd3
-               -- Really something like: cpCXAAux :: SF' b c -> SF' a d
+                -- Really something like: cpCXAAux :: SF' b c -> SF' a d
                 cpCXAAux :: b -> FunDesc c d -> (c -> d) -> SF' b c -> SF' a d
                 cpCXAAux b fd3 f3 (SFArr _ fd2) = sfConst (f3 ((fdFun fd2) b))
                 cpCXAAux b fd3 f3 (SFAcc _ _ _ cne) = sfConst (vfyNoEv b (f3 cne))
@@ -239,44 +239,44 @@ compPrim (SF {sfTF = tf10}) (SF {sfTF = tf20}) = SF {sfTF = tf0}
 -}
 
         cpGX :: (a -> b) -> SF' b c -> SF' a c
-       cpGX f1 (SFArr _ fd2) = sfArr (fdComp (FDG f1) fd2)
+        cpGX f1 (SFArr _ fd2) = sfArr (fdComp (FDG f1) fd2)
         cpGX f1 (SFCpAXA _ fd21 sf22 fd23) =
             cpAXA (fdComp (FDG f1) fd21) sf22 fd23
-       cpGX f1 sf2 = SFCpAXA tf (FDG f1) sf2 FDI
-           where
-               tf dt a = (cpGX f1 sf2', c)
-                   where
-                       (sf2', c) = (sfTF' sf2) dt (f1 a)
+        cpGX f1 sf2 = SFCpAXA tf (FDG f1) sf2 FDI
+            where
+                tf dt a = (cpGX f1 sf2', c)
+                    where
+                        (sf2', c) = (sfTF' sf2) dt (f1 a)
 
         cpXG :: SF' a b -> (b -> c) -> SF' a c
-       cpXG (SFArr _ fd1) f2 = sfArr (fdComp fd1 (FDG f2))
+        cpXG (SFArr _ fd1) f2 = sfArr (fdComp fd1 (FDG f2))
         cpXG (SFAcc _ f1 s bne) f2 = sfAcc f s (f2 bne)
             where
                 f s a = let (s', b) = f1 s a in (s', f2 b)
-       cpXG (SFCpAXA _ fd11 sf12 fd22) f2 =
+        cpXG (SFCpAXA _ fd11 sf12 fd22) f2 =
             cpAXA fd11 sf12 (fdComp fd22 (FDG f2))
-       cpXG sf1 f2 = SFCpAXA tf FDI sf1 (FDG f2)
-           where
-               tf dt a = (cpXG sf1' f2, f2 b)
-                   where
-                       (sf1', b) = (sfTF' sf1) dt a
+        cpXG sf1 f2 = SFCpAXA tf FDI sf1 (FDG f2)
+            where
+                tf dt a = (cpXG sf1' f2, f2 b)
+                    where
+                        (sf1', b) = (sfTF' sf1) dt a
 
         cpEX :: (Event a -> b) -> b -> SF' b c -> SF' (Event a) c
-       cpEX f1 f1ne (SFArr _ fd2) = sfArr (fdComp (FDE f1 f1ne) fd2)
-       cpEX f1 f1ne (SFAcc _ f2 s cne) = sfAcc f s (vfyNoEv f1ne cne)
+        cpEX f1 f1ne (SFArr _ fd2) = sfArr (fdComp (FDE f1 f1ne) fd2)
+        cpEX f1 f1ne (SFAcc _ f2 s cne) = sfAcc f s (vfyNoEv f1ne cne)
             where
                 f s a = f2 s (fromEvent (f1 (Event a)))
-       cpEX f1 f1ne (SFCpAXA _ fd21 sf22 fd23) =
+        cpEX f1 f1ne (SFCpAXA _ fd21 sf22 fd23) =
             cpAXA (fdComp (FDE f1 f1ne) fd21) sf22 fd23
-       cpEX f1 f1ne sf2 = SFCpAXA tf (FDE f1 f1ne) sf2 FDI
-           where
-               tf dt ea = (cpEX f1 f1ne sf2', c)
-                   where
+        cpEX f1 f1ne sf2 = SFCpAXA tf (FDE f1 f1ne) sf2 FDI
+            where
+                tf dt ea = (cpEX f1 f1ne sf2', c)
+                    where
                         (sf2', c) = case ea of
-                                       NoEvent -> (sfTF' sf2) dt f1ne
-                                       _       -> (sfTF' sf2) dt (f1 ea)
+                                        NoEvent -> (sfTF' sf2) dt f1ne
+                                        _       -> (sfTF' sf2) dt (f1 ea)
 
-       cpXE :: SF' a (Event b) -> (Event b -> c) -> c -> SF' a c
+        cpXE :: SF' a (Event b) -> (Event b -> c) -> c -> SF' a c
         cpXE (SFArr _ fd1)   f2 f2ne = sfArr (fdComp fd1 (FDE f2 f2ne))
         cpXE (SFAcc _ f1 s bne) f2 f2ne = sfAcc f s (vfyNoEv bne f2ne)
             where
@@ -285,9 +285,9 @@ compPrim (SF {sfTF = tf10}) (SF {sfTF = tf20}) = SF {sfTF = tf0}
                             case eb of NoEvent -> (s', f2ne); _ -> (s', f2 eb)
         cpXE (SFCpAXA _ fd11 sf12 fd13) f2 f2ne =
             cpAXA fd11 sf12 (fdComp fd13 (FDE f2 f2ne))
-       cpXE sf1 f2 f2ne = SFCpAXA tf FDI sf1 (FDE f2 f2ne)
-           where
-               tf dt a = (cpXE sf1' f2 f2ne,
+        cpXE sf1 f2 f2ne = SFCpAXA tf FDI sf1 (FDE f2 f2ne)
+            where
+                tf dt a = (cpXE sf1' f2 f2ne,
                            case eb of NoEvent -> f2ne; _ -> f2 eb)
-                   where
+                    where
                         (sf1', eb) = (sfTF' sf1) dt a
index b52ec2c..bc4326c 100644 (file)
@@ -9,8 +9,8 @@ class Key k where
 
 instance (Key a, Key b) => Key (a,b) where
   type Map (a,b) = MP a b
-  lookup (a,b) (m :: Map (a,b) elt) 
+  lookup (a,b) (m :: Map (a,b) elt)
      = case lookup a m :: Maybe (Map b elt) of
-         Just (m2 :: Map b elt) -> lookup b m2 :: Maybe elt
+          Just (m2 :: Map b elt) -> lookup b m2 :: Maybe elt
 
 data MP a b elt = MP (Map a (Map b elt))
index e8c5559..e6f0eb2 100644 (file)
@@ -7,9 +7,9 @@ data Abs env g v where
 class Eval g env h v where
   eval :: env -> g env h v -> v
 
-evalAbs :: Eval g2 (a2, env) h2 v2 
-       => env 
-       -> Abs env (g2 (a2, env) h2 v2) (a2->v2) 
-       -> (a2->v2)
-evalAbs env (Abs e) x 
+evalAbs :: Eval g2 (a2, env) h2 v2
+        => env
+        -> Abs env (g2 (a2, env) h2 v2) (a2->v2)
+        -> (a2->v2)
+evalAbs env (Abs e) x
   = eval (x, env) e    -- e :: g (a,env) h v
index 886b702..d1c6b4d 100644 (file)
@@ -15,4 +15,4 @@ g (T n) | n >= 3 = if n>3 then GT else EQ
 g (T n)     = LT
 
 main = do   print [f (T 0), f (T 1)]
-           print [g (T 2), g (T 3), g (T 4)]
+            print [g (T 2), g (T 3), g (T 4)]
index 99aecad..452da8c 100644 (file)
@@ -5,7 +5,7 @@
 module Foo where
 
 data TValue t where
-  TList :: [a] -> TValue [a] 
+  TList :: [a] -> TValue [a]
 
 instance (Eq b) => Eq (TValue b) where
     (==) (TList p) (TList q) = (==) p q
@@ -15,19 +15,19 @@ instance (Eq b) => Eq (TValue b) where
 Here's the reasoning (I have done a bit of renaming).
 
 * The TList constructor really has type
-       TList :: forall a. forall x. (a~[x]) => [x] -> TValue a
+        TList :: forall a. forall x. (a~[x]) => [x] -> TValue a
 
 * So in the pattern match we have
-       (Eq b) available from the instance header
-       TList p :: TValue b
-       x is a skolem, existentially bound by the pattern
-       p :: [x]
-       b ~ [x] available from the pattern match
+        (Eq b) available from the instance header
+        TList p :: TValue b
+        x is a skolem, existentially bound by the pattern
+        p :: [x]
+        b ~ [x] available from the pattern match
 
 * On the RHS we find we need (Eq [x]).
 
 * So the constraint problem we have is
-       (Eq b, b~[x]) => Eq [x]
+        (Eq b, b~[x]) => Eq [x]
           ["Given"  =>  "Wanted"]
   Can we prove this?  From the two given constraints we can see
   that we also have Eq [x], and that certainly proves Eq [x].
@@ -38,4 +38,4 @@ consequences of the "given" constraints, we might use the top-level Eq
 a => Eq [a] instance to solve the wanted Eq [x].  And now we need Eq
 x, which *isn't* a consequence of (Eq b, b~[x]).
 
--}
\ No newline at end of file
+-}
index 5db3dee..2dce68f 100644 (file)
@@ -3,21 +3,21 @@
 module Main where
 
 data Term a where
-   Lit    :: Int -> Term Int  
+   Lit    :: Int -> Term Int
    IsZero :: Term Int -> Term Bool
    If     :: Term Bool -> Term a -> Term a -> Term a
-   Pr            :: Term a -> Term b -> Term (a, b)
-   Fst           :: Term (a, b) -> Term a
-   Snd           :: Term (a, b) -> Term b
+   Pr     :: Term a -> Term b -> Term (a, b)
+   Fst    :: Term (a, b) -> Term a
+   Snd    :: Term (a, b) -> Term b
 
 eval :: Term v -> v
-eval (Lit n)       = n  
+eval (Lit n)       = n
 eval (IsZero t)    = eval t == 0
 eval (If t1 t2 t3) = if eval t1 then eval t2 else eval t3
 eval (Pr t1 t2)    = (eval t1, eval t2)
-eval (Fst t)      = case (eval t) of { (a,b) -> a }
-eval (Snd t)      = case (eval t) of { (a,b) -> b }
+eval (Fst t)       = case (eval t) of { (a,b) -> a }
+eval (Snd t)       = case (eval t) of { (a,b) -> b }
 
 term = If (IsZero (Lit 1)) (Pr (Lit 2) (Lit 3)) (Pr (Lit 3) (Lit 4))
 
-main = print (eval term)
\ No newline at end of file
+main = print (eval term)
index 1cad8f6..ebd8b04 100644 (file)
@@ -1,15 +1,15 @@
 {-# LANGUAGE GADTs, KindSignatures #-}
 
 -- Test a couple of trivial things:
---     explicit layout
---     trailing semicolons
---     kind signatures
+--      explicit layout
+--      trailing semicolons
+--      kind signatures
 module ShouldCompile where
 
 data Expr :: * -> * where {
    EInt    :: Int                                 -> Expr Int  ;
    EBool   :: Bool                                -> Expr Bool ;
    EIf     :: (Expr Bool) -> (Expr a) -> (Expr a) -> Expr a    ;
-               -- Note trailing semicolon, should be ok
+                -- Note trailing semicolon, should be ok
   }
 
index 3be7dc2..34bd41b 100644 (file)
@@ -1,7 +1,7 @@
 {-# LANGUAGE GADTs, KindSignatures,
              MultiParamTypeClasses, FunctionalDependencies #-}
 
--- Program from Josef Svenningsson 
+-- Program from Josef Svenningsson
 
 -- Just a short explanation of the program. It contains
 -- some class declarations capturing some definitions from
@@ -10,7 +10,7 @@
 -- function defining the semantics for lambda terms called
 -- 'interp'.
 
--- Made GHC 6.4 bleat 
+-- Made GHC 6.4 bleat
 --    Quantified type variable `t' is unified with
 --        another quantified type variable `terminal'
 --    When trying to generalise the type inferred for `interp'
@@ -38,14 +38,14 @@ class Category arr =>
   inRight :: arr b (coprod a b)
   ccase   :: arr a c -> arr b c -> arr (coprod a b) c
 
-class ProductCategory prod arr => 
+class ProductCategory prod arr =>
       Exponential exp prod arr | arr -> exp where
   eval   :: arr (prod (exp a b) a) b
   curryA :: arr (prod c a) b -> arr c (exp a b)
 
 
-class (Exponential exp prod arr, Terminal terminal arr) => 
-  CartesianClosed terminal exp prod arr | arr -> terminal exp prod 
+class (Exponential exp prod arr, Terminal terminal arr) =>
+  CartesianClosed terminal exp prod arr | arr -> terminal exp prod
 
 data V prod env t where
   Z :: V prod (prod env t) t
@@ -55,13 +55,13 @@ data Lambda terminal (exp :: * -> * -> *) prod env t where
     Unit :: Lambda foo exp prod env foo
     Var  :: V prod env t -> Lambda terminal exp prod env t
 {-    Lam  :: Lambda terminal exp prod (prod env a) t
-        -> Lambda terminal exp prod env (exp a t)
-    App  :: Lambda terminal exp prod env (exp t t') 
-        -> Lambda terminal exp prod env t -> Lambda terminal exp prod env t'
+         -> Lambda terminal exp prod env (exp a t)
+    App  :: Lambda terminal exp prod env (exp t t')
+         -> Lambda terminal exp prod env t -> Lambda terminal exp prod env t'
 -}
 
-interp :: CartesianClosed terminal exp prod arr => 
-         Lambda terminal exp prod s t -> arr s t
+interp :: CartesianClosed terminal exp prod arr =>
+          Lambda terminal exp prod s t -> arr s t
 interp (Unit)       = terminal -- Terminal terminal arr => arr a terminal
 -- interp (Var Z)      = second
 -- interp (Var (S v))  = first `comp` interp (Var v)
index 6014129..103319a 100644 (file)
@@ -11,10 +11,10 @@ data Ty t where
   Arr  :: Ty a -> Ty b -> Ty (a -> b)
 
 data Exp g t where
-  Var   :: Var g t -> Exp g t
-  Lam   :: Ty a -> Exp (g,a) b -> Exp g (a->b) 
-  App   :: Exp g (s -> t) -> Exp g s -> Exp g t
-  If    :: Exp g Bool -> Exp g t -> Exp g t -> Exp g t
+  Var    :: Var g t -> Exp g t
+  Lam    :: Ty a -> Exp (g,a) b -> Exp g (a->b)
+  App    :: Exp g (s -> t) -> Exp g s -> Exp g t
+  If     :: Exp g Bool -> Exp g t -> Exp g t -> Exp g t
   ETrue  :: Exp g Bool
   EFalse :: Exp g Bool
 
@@ -72,12 +72,12 @@ data TyEnv g where
   Cons :: Ty t -> TyEnv h -> TyEnv (h,t)
 
 infer :: TyEnv g -> Exp g t -> Ty t
-infer g (Var x)                = inferVar g x
-infer g (Lam t e)      = Arr t (infer (Cons t g) e)
-infer g (App e e')     = case infer g e of Arr _ t -> t
-infer g (ETrue)                = Bool
-infer g (EFalse)       = Bool
-infer g (If _ e _)     = infer g e
+infer g (Var x)         = inferVar g x
+infer g (Lam t e)       = Arr t (infer (Cons t g) e)
+infer g (App e e')      = case infer g e of Arr _ t -> t
+infer g (ETrue)         = Bool
+infer g (EFalse)        = Bool
+infer g (If _ e _)      = infer g e
 
 inferVar :: TyEnv g -> Var g t -> Ty t
 inferVar (Cons t h) (SVar x) = inferVar h x
@@ -87,8 +87,8 @@ inferVar (Cons t h) (ZVar)   = t
 
 data Tree a = Val a | Choice (Tree a) (Tree a)
 -- doesn't yet force trees to be fully balanced:
---     Val :: a -> Tree a Z
---     Choice :: Tree a n -> Tree a n -> Tree a (S n)
+--      Val :: a -> Tree a Z
+--      Choice :: Tree a n -> Tree a n -> Tree a (S n)
 
 instance Functor Tree where
     fmap = liftM
@@ -114,8 +114,8 @@ flatten t = flatten_ t []
 -- quote & friends -------------------------------------------------------------
 
 -- for values --------------------------
-enumV          :: Ty t -> Tree t
-questionsV     :: Ty t -> [t -> Bool]
+enumV           :: Ty t -> Tree t
+questionsV      :: Ty t -> [t -> Bool]
 
 
 enumV Bool      = Choice (Val True) (Val False)
@@ -123,46 +123,46 @@ enumV (Arr s t) = mkEnum (questionsV s) (enumV t)
  where
    mkEnum [] t = tmap const t
    mkEnum (q:qs) es = do
-                  f1 <- mkEnum qs es
-                  f2 <- mkEnum qs es
-                  return (\d -> if q d then f1 d else f2 d)
+                   f1 <- mkEnum qs es
+                   f2 <- mkEnum qs es
+                   return (\d -> if q d then f1 d else f2 d)
 
-questionsV Bool                = return (\x -> x)
-questionsV (Arr s t)   = do
-                         d <- flatten (enumV s)
-                         q <- questionsV t
-                         return (\f -> q (f d))
+questionsV Bool         = return (\x -> x)
+questionsV (Arr s t)    = do
+                          d <- flatten (enumV s)
+                          q <- questionsV t
+                          return (\f -> q (f d))
 
 -- for expressions ---------------------
-enumE          :: Ty t -> Tree (Exp g t)
-questionsE     :: Ty t -> [Exp g t -> Exp g Bool]
+enumE           :: Ty t -> Tree (Exp g t)
+questionsE      :: Ty t -> [Exp g t -> Exp g Bool]
 
 enumE Bool      = Choice (Val ETrue) (Val EFalse)
 enumE (Arr s t) = tmap (lamE s) (mkEnumE (questionsE s) (enumE t))
  where
    mkEnumE [] t = tmap const t
    mkEnumE (q:qs) es = do
-                       f1 <- mkEnumE qs es
-                       f2 <- mkEnumE qs es
-                       return (\d -> ifE (q d) (f1 d) (f2 d))
-
-questionsE Bool                = return (\x -> x)
-questionsE (Arr s t)   = do
-                         d <- flatten (enumE s)
-                         q <- questionsE t
-                         return (\f -> q (App f d))
-
--- should be 
---     find (List (Exp g Bool) n) -> Tree (Exp g a) n -> Exp g a
+                        f1 <- mkEnumE qs es
+                        f2 <- mkEnumE qs es
+                        return (\d -> ifE (q d) (f1 d) (f2 d))
+
+questionsE Bool         = return (\x -> x)
+questionsE (Arr s t)    = do
+                          d <- flatten (enumE s)
+                          q <- questionsE t
+                          return (\f -> q (App f d))
+
+-- should be
+--      find (List (Exp g Bool) n) -> Tree (Exp g a) n -> Exp g a
 find :: [Exp g Bool] -> Tree (Exp g a) -> Exp g a
-find []                (Val a)         = a
-find (b:bs)    (Choice l r)    = ifE b (find bs l) (find bs r)
-find _         _               = error "bad arguments to find"
+find []         (Val a)         = a
+find (b:bs)     (Choice l r)    = ifE b (find bs l) (find bs r)
+find _          _               = error "bad arguments to find"
 
 quote :: Ty t -> t -> Exp g t
 quote Bool      t = case t of True -> ETrue; False -> EFalse
 quote (Arr s t) f = lamE s (\e -> find (do q <- questionsE s; return (q e))
-                                       (tmap (quote t . f) (enumV s)))
+                                        (tmap (quote t . f) (enumV s)))
 
 -- normalization (by evaluation) -----------------------------------------------
 data BoxExp t = Box (forall g. Exp g t)
@@ -183,4 +183,4 @@ test = [ eqB (nf b22b thrice) (nf b22b once)
        , eqB (nf b22b twice)  (nf b22b once)]
   where nf = normalize
 
-main = print test
\ No newline at end of file
+main = print test
index e28add3..eaa2fd4 100644 (file)
@@ -18,8 +18,7 @@ g (T1 {x=xv, y=yv}) = T2 { x = xv }
 h v = x v + 1
 
 main = do { let t1 = T1 { y = "foo", x = 4 }
-               t2 = g t1
-         ; print (h (f 8 undefined))
-         ; print (h t2)
-       }
-       
\ No newline at end of file
+                t2 = g t1
+          ; print (h (f 8 undefined))
+          ; print (h t2)
+        }
index 29bb324..016ac83 100644 (file)
@@ -5,7 +5,7 @@ module ShouldCompile where
 -- data RBTree = forall n. Root (SubTree Black n)
 
 -- Kind Colour
-data Red 
+data Red
 data Black
 
 -- Kind Nat
@@ -20,12 +20,12 @@ data SubTree c n where
 
 
 ins :: Int -> SubTree c n -> SubTree c n
-ins n Leaf                  = (Fix (RNode Leaf n Leaf))
+ins n Leaf                   = (Fix (RNode Leaf n Leaf))
 ins n (BNode x m y) | n <= m = black (ins n x) m y
 ins n (BNode x m y) | n > m  = black x m (ins n y)
 ins n (RNode x m y) | n <= m = RNode (ins n x) m y
 ins n (RNode x m y) | n > m  = RNode x m (ins n y)
+
 black :: SubTree c n -> Int -> SubTree d n -> SubTree Black (S n)
 black (RNode (Fix u) v c) w (x@(RNode _ _ _)) = Fix(RNode (blacken u) v (BNode c w x))
 
index cafa738..ea321a5 100644 (file)
@@ -28,6 +28,6 @@ g2 (C (p :: x)) = ()
 g3 :: forall x y . D x y -> ()
 -- D (..)  :: D x y
 -- C (..)  :: C sk y
---     sk = y
+--      sk = y
 -- p :: sk
 g3 (D (C (p :: y))) = ()
index 3a78bbb..daafe8e 100644 (file)
@@ -1,6 +1,6 @@
 {-# LANGUAGE GADTs #-}
 
--- Provoked by 
+-- Provoked by
 -- http://www.haskell.org/pipermail/haskell-cafe/2007-January/021086.html
 
 module ShouldCompile where
@@ -29,7 +29,7 @@ unionC1 (SM1 p1 m1) (SM1 p2 m2)
 ---------------------
 data SetM2 a where
      SM2 :: Ord w => Teq a w -> Set.Set w -> SetM2 a
-       -- Different order of args in Teq
+        -- Different order of args in Teq
 
 unionA2 :: SetM2 a -> SetM2 a -> SetM2 a
 unionA2 (SM2 Teq m1) (SM2 Teq m2)
@@ -40,6 +40,6 @@ unionB2 (SM2 p1 m1) (SM2 p2 m2)
   = case p1 of Teq -> case p2 of Teq -> SM2 Teq (m1 `Set.union` m2)
 
 unionC2 :: SetM2 a -> SetM2 a -> SetM2 a
-unionC2 (SM2 p1 m1) (SM2 p2 m2) 
+unionC2 (SM2 p1 m1) (SM2 p2 m2)
   = case (p1,p2) of (Teq,Teq) -> SM2 Teq (m1 `Set.union` m2)
 
index f290322..920091b 100644 (file)
@@ -164,20 +164,20 @@ test4 :: NonTerminating
 test4 = NonTerminating (Apply omega omega) help3
 
 help1 :: Reducible (Apply Omega Omega)
-help1 = Reducible (ReduceSimple 
-               (ReplaceApply (ReplaceVarEq Equal (LiftLambda 
-                       (LiftApply (LiftVarLess LessZero) (LiftVarLess LessZero)))) 
-               (ReplaceVarEq Equal (LiftLambda (LiftApply 
-                       (LiftVarLess LessZero) (LiftVarLess LessZero))))))
+help1 = Reducible (ReduceSimple
+                (ReplaceApply (ReplaceVarEq Equal (LiftLambda
+                        (LiftApply (LiftVarLess LessZero) (LiftVarLess LessZero))))
+                (ReplaceVarEq Equal (LiftLambda (LiftApply
+                        (LiftVarLess LessZero) (LiftVarLess LessZero))))))
 
 help2 :: ReduceEventually (Apply Omega Omega) t -> Equal (Apply Omega Omega) t
 help2 ReduceZero = Equal
-help2 (ReduceSucc (ReduceSimple (ReplaceApply 
-       (ReplaceVarEq _ (LiftLambda (LiftApply (LiftVarLess _) (LiftVarLess _)))) 
-       (ReplaceVarEq _ (LiftLambda (LiftApply (LiftVarLess _) (LiftVarLess _)))))) y)
+help2 (ReduceSucc (ReduceSimple (ReplaceApply
+        (ReplaceVarEq _ (LiftLambda (LiftApply (LiftVarLess _) (LiftVarLess _))))
+        (ReplaceVarEq _ (LiftLambda (LiftApply (LiftVarLess _) (LiftVarLess _)))))) y)
   = case help2 y of
       Equal -> Equal
 
 help3 :: Infinite (Apply Omega Omega)
 help3 x = case help2 x of
-             Equal -> help1
+              Equal -> help1
index ab21dc6..c31b66f 100644 (file)
@@ -9,7 +9,7 @@ data T a where
   T1 :: { w :: !(Int, Int), x :: a, y :: b } -> T (a,b)
   T2 :: { w :: !(Int, Int), x :: a } -> T (a,b)
   T3 :: { z :: Int } -> T Bool
+
 -- T1 :: forall c a b. (c~(a,b)) => (Int,Int) -> a -> b -> T c
 
 f xv yv = T1 { w = (0,0), x = xv, y = yv }
@@ -23,8 +23,8 @@ h v = x v + 1
 i v = let (x,y) = w v in x + y
 
 main = do { let t1 = T1 { w = (0,0), y = "foo", x = 4 }
-               t2 = g t1
-         ; print (h (f 8 undefined))
-         ; print (h t2)
+                t2 = g t1
+          ; print (h (f 8 undefined))
+          ; print (h t2)
           ; print (i t1)
-       }
+        }
index 2040511..c5bbcde 100644 (file)
@@ -7,21 +7,21 @@ succeed = return
 
 data V s t where
   Z :: V (t,m) t
-  S :: V m t -> V (x,m) t 
-  
+  S :: V m t -> V (x,m) t
+
 data Exp s t where
-  IntC  :: Int -> Exp s Int                    -- 5         
-  BoolC :: Bool -> Exp s Bool                  -- True      
-  Plus         :: Exp s Int -> Exp s Int -> Exp s Int  -- x + 3     
-  Lteq         :: Exp s Int -> Exp s Int -> Exp s Bool -- x <= 3    
-  Var          :: V s t -> Exp s t                     -- x         
+  IntC  :: Int -> Exp s Int                     -- 5
+  BoolC :: Bool -> Exp s Bool                   -- True
+  Plus  :: Exp s Int -> Exp s Int -> Exp s Int  -- x + 3
+  Lteq  :: Exp s Int -> Exp s Int -> Exp s Bool -- x <= 3
+  Var   :: V s t -> Exp s t                     -- x
 
 data Com s where
-  Set :: V s t -> Exp s t -> Com s              -- x := e                
-  Seq :: Com s -> Com s -> Com s               -- { s1; s2; }           
-  If :: Exp s Bool -> Com s -> Com s -> Com s  -- if e then x else y    
-  While :: Exp s Bool -> Com s -> Com s        -- while e do s          
-  Declare :: Exp s t -> Com (t,s) -> Com s     -- { int x = 5; s }      
+  Set :: V s t -> Exp s t -> Com s              -- x := e
+  Seq :: Com s -> Com s -> Com s                -- { s1; s2; }
+  If :: Exp s Bool -> Com s -> Com s -> Com s   -- if e then x else y
+  While :: Exp s Bool -> Com s -> Com s         -- while e do s
+  Declare :: Exp s t -> Com (t,s) -> Com s      -- { int x = 5; s }
 
 update :: (V s t) -> t -> s -> s
 update Z n (x,y) = (n,y)
@@ -42,8 +42,8 @@ exec (Seq x y) s = exec y (exec x s)
 exec (If test x1 x2) s =
   if (eval test s) then exec x1 s else exec x2 s
 exec (While test body) s = loop s
-  where loop s = if (eval test s) 
-                    then loop (exec body s) 
+  where loop s = if (eval test s)
+                    then loop (exec body s)
                     else s
 exec (Declare e body) s = store
   where (_,store) = (exec body (eval e s,s))
@@ -54,19 +54,19 @@ v2 = S (S Z)
 v3 = S (S (S Z))
 
 e2 = Lteq (Plus (Var v0)(Var v1)) (Plus (Var v0) (IntC 1))
-  
+
 sum_var = Z
 x = S Z
 
 prog :: Com (Int,(Int,a))
-prog = 
+prog =
  Seq (Set sum_var (IntC 0))
      (Seq (Set x (IntC 1))
      (While (Lteq (Var x) (IntC 5))
             (Seq (Set sum_var (Plus (Var sum_var)(Var x)))
                  (Set x (Plus (Var x) (IntC 1))))))
-                   
-ans = exec prog (34,(12,1))                   
+
+ans = exec prog (34,(12,1))
 main = print ans
 {-
 { sum = 0 ;
@@ -75,7 +75,7 @@ main = print ans
   { sum = sum + x;
     x = x + 1;
   }
-}        
+}
 -}
 
 
@@ -87,15 +87,15 @@ data TyAst = I | B | P TyAst TyAst
 data TypeR t where
   IntR :: TypeR Int
   BoolR :: TypeR Bool
-  PairR :: TypeR a -> TypeR b -> TypeR (a,b) 
+  PairR :: TypeR a -> TypeR b -> TypeR (a,b)
 
 -- Judgments for Types
-data TJudgment = forall t . TJ (TypeR t)   
+data TJudgment = forall t . TJ (TypeR t)
 
 checkT :: TyAst -> TJudgment
 checkT I = TJ IntR
 checkT B = TJ BoolR
-checkT (P x y) = 
+checkT (P x y) =
    case (checkT x,checkT y) of
      (TJ a, TJ b) -> TJ(PairR a b)
 
@@ -111,7 +111,7 @@ match (PairR a b) (PairR c d) =
   do { EqProof <- match a c
      ; EqProof <- match b d
      ; succeed EqProof }
-match _ _ = fail "match fails"     
+match _ _ = fail "match fails"
 
 
 ----------------------------------------------
@@ -121,13 +121,13 @@ checkV :: Int -> TypeR t -> TypeR s -> Maybe(V s t)
 checkV 0 t1 (PairR t2 p) =
   do { EqProof <- match t1 t2
      ; return Z }
-checkV n t1 (PairR ty p) = 
+checkV n t1 (PairR ty p) =
   do { v <- checkV (n-1) t1 p; return(S v)}
 checkV n t1 sr = Nothing
 
 
 -----------------------------------------------------
-data ExpAst 
+data ExpAst
   = IntCA Int
   | BoolCA Bool
   | PlusA ExpAst ExpAst
@@ -135,7 +135,7 @@ data ExpAst
   | VarA Int TyAst
 
 -- Judgments for Expressions
-data EJudgment s = forall t . EJ (TypeR t) (Exp s t)  
+data EJudgment s = forall t . EJ (TypeR t) (Exp s t)
 
 checkE :: ExpAst -> TypeR s -> Maybe (EJudgment s)
 checkE (IntCA n) sr = succeed(EJ IntR (IntC n))
@@ -146,13 +146,13 @@ checkE (PlusA x y) sr =
      ; EJ t2 e2 <- checkE y sr
      ; EqProof <- match t2 IntR
      ; succeed(EJ IntR (Plus e1 e2))}
-checkE (VarA n ty) sr = 
+checkE (VarA n ty) sr =
   do { TJ t <- succeed(checkT ty)
-     ; v <- checkV n t sr 
+     ; v <- checkV n t sr
      ; return(EJ t (Var v)) }
 
 -----------------------------------------------------
-data ComAst 
+data ComAst
   = SetA Int TyAst ExpAst
   | SeqA ComAst ComAst
   | IfA ExpAst ComAst ComAst
@@ -168,22 +168,22 @@ checkC (SetA n ty e) sr =
      ; EJ t2 e1 <- checkE e sr
      ; EqProof <- match t1 t2
      ; return(EC (Set v e1))}
-checkC (SeqA x y) sr = 
+checkC (SeqA x y) sr =
   do { EC c1 <- checkC x sr
      ; EC c2 <- checkC y sr
      ; return(EC (Seq c1 c2)) }
-checkC (IfA e x y) sr = 
+checkC (IfA e x y) sr =
   do { EJ t1 e1 <- checkE e sr
      ; EqProof <- match t1 BoolR
      ; EC c1 <- checkC x sr
      ; EC c2 <- checkC y sr
      ; return(EC(If e1 c1 c2)) }
-checkC (WhileA e x) sr = 
+checkC (WhileA e x) sr =
   do { EJ t1 e1 <- checkE e sr
      ; EqProof <- match t1 BoolR
      ; EC c1 <- checkC x sr
      ; return(EC(While e1 c1)) }
-checkC (DeclareA ty e c) sr = 
+checkC (DeclareA ty e c) sr =
   do { TJ t1 <- succeed(checkT ty)
      ; EJ t2 e2 <- checkE e sr
      ; EqProof <- match t1 t2
@@ -195,7 +195,7 @@ checkC (DeclareA ty e c) sr =
 e1 = Lteq (Plus (Var sum_var)(Var x)) (Plus (Var x) (IntC 1))
 
 {-
-data Store s 
+data Store s
   = M (Code s)
   | forall a b . N (Code a) (Store b) where s = (a,b)
 
@@ -213,4 +213,4 @@ eval2 (Var (S v)) (M x) = eval2 (Var v) (M [| snd $x |])
 test e = [| \ (x,(y,z)) -> $(eval2 e (N [|x|] (N [|y|] (M [|z|])))) |]
 
 -- test e1 --->  [| \ (x,(y,z)) -> x + y <= y + 1 |]
--}
\ No newline at end of file
+-}
index 7b2e2ea..a48afa6 100644 (file)
@@ -1,5 +1,5 @@
 g i = let a = i + 1
-         b = id
+          b = id
           c = ()
           d = (+)
       in (a,b,c,d)
index 53d8432..69e007c 100644 (file)
@@ -1,4 +1,4 @@
 g i = (a,b,c)
       where a = False
-           b = True
+            b = True
             c = ()
index 7dff7b6..1f4313d 100644 (file)
@@ -1,4 +1,4 @@
 g i = let a = False
-         b = True
+          b = True
           c = (a,b)
       in c
index 7c3962d..ff67a0d 100644 (file)
@@ -1,18 +1,18 @@
 -- Test that we can recover unicode DataCons in :print
-data T 
-  = À         -- latin
-  | Α         -- greek
-  | Ⴀ                -- georgian
-  | Ϣ         -- coptic
-  | А         -- cyrillic
-  | Ա         -- armenian
+data T
+  = À          -- latin
+  | Α          -- greek
+  | Ⴀ         -- georgian
+  | Ϣ          -- coptic
+  | А          -- cyrillic
+  | Ա          -- armenian
   deriving Show
 
 test =
-  [ À         -- latin
-  , Α         -- greek
-  , Ⴀ                -- georgian
-  , Ϣ         -- coptic
-  , А         -- cyrillic
-  , Ա         -- armenian
+  [ À          -- latin
+  , Α          -- greek
+  , Ⴀ         -- georgian
+  , Ϣ          -- coptic
+  , А          -- cyrillic
+  , Ա          -- armenian
   ]
index e193743..576a7d0 100644 (file)
@@ -3,14 +3,14 @@
 -- test that we have all the promised instances
 
 module Main(main) where
-import Control.Monad.Fix 
+
+import Control.Monad.Fix
 import qualified Control.Monad.ST      as SST
 import qualified Control.Monad.ST.Lazy as LST
 
 generic :: MonadFix m => m [Int]
 generic = mdo xs <- return (1:xs)
-             return (take 4 xs)
+              return (take 4 xs)
 
 io :: IO [Int]
 io = generic
@@ -20,7 +20,7 @@ sst = generic
 
 lst :: LST.ST s [Int]
 lst = generic
-       
+
 mb :: Maybe [Int]
 mb = generic
 
@@ -28,9 +28,9 @@ ls :: [[Int]]
 ls = generic
 
 main :: IO ()
-main = do 
-       print   =<< io
-       print   $   SST.runST sst       
-       print   $   LST.runST lst
-       print   $   mb  
-       print   $   ls
+main = do
+        print   =<< io
+        print   $   SST.runST sst
+        print   $   LST.runST lst
+        print   $   mb
+        print   $   ls
index 4328257..3f9533f 100644 (file)
@@ -21,11 +21,11 @@ instance Monad X where
   (X a) >>= f = f a
 
 instance MonadFix X where
-  mfix f = fix (f . unX) 
+  mfix f = fix (f . unX)
          where unX ~(X x) = x
 
 z :: X [Int]
 z = mdo x <- return (1:x)
-       return (take 4 x)
+        return (take 4 x)
 
 main = print z
index 544ee6c..fe405b8 100644 (file)
@@ -1,17 +1,17 @@
 {-# OPTIONS -XRecursiveDo #-}
 
--- test let bindings, polymorphism is ok provided they are not 
+-- test let bindings, polymorphism is ok provided they are not
 -- isolated in a recursive segment
 -- NB. this is not what Hugs does!
 
 module Main (main) where
 
-import Control.Monad.Fix 
+import Control.Monad.Fix
 
 t :: IO (Int, Int)
 t = mdo let l [] = 0
             l (x:xs) = 1 + l xs
-       return (l "1", l [1,2,3])
+        return (l "1", l [1,2,3])
 
 main :: IO ()
 main = t >>= print
index 0b6301b..c712c5a 100644 (file)
@@ -4,12 +4,12 @@
 
 module Main (main) where
 
-import Control.Monad.Fix 
+import Control.Monad.Fix
 import Data.Maybe ( fromJust )
 
 t = mdo x <- fromJust (mdo x <- Just (1:x)
-                          return (take 4 x))
-       return x
+                           return (take 4 x))
+        return x
 
 main :: IO ()
-main = print t 
+main = print t
index b4d5291..324973f 100644 (file)
@@ -9,4 +9,4 @@ import Control.Monad.Fix
 
 main :: IO ()
 main = mdo x <- return (1:x)
-          return ()
+           return ()
index 8527e5b..cc30d12 100644 (file)
@@ -7,27 +7,27 @@ import Data.Array.IO
 import Control.Monad
 
 norm a = mdo (_, sz) <- getBounds a
-            s <- ioaA 1 s sz 0
-            return ()
-    where 
-         ioaA i s sz acc
-          | i > sz = return acc
-          | True   = do v <- readArray a i
-                        writeArray a i (v / s)
-                        ioaA (i+1) s sz $! (v + acc)
+             s <- ioaA 1 s sz 0
+             return ()
+    where
+          ioaA i s sz acc
+           | i > sz = return acc
+           | True   = do v <- readArray a i
+                         writeArray a i (v / s)
+                         ioaA (i+1) s sz $! (v + acc)
 
 toList a = do (_, sz) <- getBounds a
-             mapM (\i -> readArray a i) [1..sz]
+              mapM (\i -> readArray a i) [1..sz]
 
 test    :: Int -> IO ()
 test sz = do
-       (arr :: IOArray Int Float) <- newArray (1, sz) 12
-       putStrLn "Before: "
-       toList arr >>= print 
-       norm arr
-       putStrLn "After: "
-       lst <- toList arr 
-       print lst
-       putStrLn ("Normalized sum: " ++ show (sum lst))
+        (arr :: IOArray Int Float) <- newArray (1, sz) 12
+        putStrLn "Before: "
+        toList arr >>= print
+        norm arr
+        putStrLn "After: "
+        lst <- toList arr
+        print lst
+        putStrLn ("Normalized sum: " ++ show (sum lst))
 
 main = test 10
index 1c94791..7cbd88d 100644 (file)
@@ -1,9 +1,9 @@
 module Mod173_Aux( module Mod173_Aux ) where
 
 import qualified Data.List as Mod173_Aux( nub )
-       -- This should not be exported
+        -- This should not be exported
 
-import Data.List as Mod173_Aux( partition ) 
-       -- This one should be exported
+import Data.List as Mod173_Aux( partition )
+        -- This one should be exported
 
-frob x = Mod173_Aux.nub (x::[Int])     -- This one should
+frob x = Mod173_Aux.nub (x::[Int])      -- This one should
index 1c0deaa..eb8e927 100644 (file)
@@ -4,9 +4,9 @@
 -- )
 module M where
 
-import Prelude hiding ( negate, enumFrom, 
-                       enumFromThen, enumFromTo,
-                       enumFromThenTo )
+import Prelude hiding ( negate, enumFrom,
+                        enumFromThen, enumFromTo,
+                        enumFromThenTo )
 import Data.Ix hiding ( rangeSize )
 negate = undefined
 enumFrom = undefined
index a61e886..38a5445 100644 (file)
@@ -3,8 +3,8 @@
 
 module M (module Mod171_A, h) where
 
-import Mod171_A        -- This isn't unused...
-import Mod171_B        -- even though this imports all the same stuff
+import Mod171_A -- This isn't unused...
+import Mod171_B -- even though this imports all the same stuff
 
 h :: Int -> Int
 h = g
index a7e185b..6374557 100644 (file)
@@ -2,10 +2,10 @@ module ShouldCompile where
 
 import Mod173_Aux
 
-t1 = partition         -- From the import
+t1 = partition  -- From the import
 
 nub = True
-t2 = nub       -- Unambiguous; nub should not have been exported
+t2 = nub        -- Unambiguous; nub should not have been exported
 
 t3 = frob
 
index fb69bd4..17276a5 100644 (file)
@@ -2,7 +2,7 @@ module Main where
 
 -- This test works efficiently because the full laziness
 -- pass now floats out applications
---     \x -> f y (x+1)
+--      \x -> f y (x+1)
 -- It'll float out the (f y) if that's a redex
 
 loop :: Double -> [Int] -> Double
@@ -93,5 +93,5 @@ the application of (^) to the two dictionaries during full laziness
 (note that (^) has arity 2 so the application is oversaturated). Why
 doesn't that happen? SetLevels (if this is the right place to look)
 has this:
--}
\ No newline at end of file
+
+-}
index d345fed..806df34 100644 (file)
@@ -7,8 +7,8 @@ import Data.Typeable
 import System.CPUTime
 
 size :: Int
-size = 40000   -- This was big enough to take 5 seconds in 
-                       -- the bad case on my machine.
+size = 40000    -- This was big enough to take 5 seconds in
+                -- the bad case on my machine.
 
 data Any = forall a. (Typeable a) => Any a
 
index 95ff235..686034f 100644 (file)
 
 module DoParamM where
 
-import Prelude (const, String, ($), (.), Maybe(..), 
-               Int, fromInteger, succ, pred, fromEnum, toEnum, 
-               (+), Char, (==), Bool(..),
-               IO, getLine, putStrLn, read, show)
+import Prelude (const, String, ($), (.), Maybe(..),
+                Int, fromInteger, succ, pred, fromEnum, toEnum,
+                (+), Char, (==), Bool(..),
+                IO, getLine, putStrLn, read, show)
 import qualified Prelude
 import qualified Control.Monad.State as State
 import qualified Control.Monad.Identity as IdM
@@ -38,7 +38,7 @@ instance Prelude.Monad m => Monadish (RegularM m) where
     fail   = RegularM . Prelude.fail
     m >>= f = RegularM ((Prelude.>>=) (unRM m) (unRM . f))
 
--- As a warm-up, we write the regular State computation, with the same 
+-- As a warm-up, we write the regular State computation, with the same
 -- type of state throughout. We thus inject Monad.State into the
 -- parameterized monad
 
@@ -53,9 +53,9 @@ test1 = State.runState (unRM c) (0::Int) where
 -- The same in the do-notation
 test1_do = State.runState (unRM c) (0::Int) where
          c = do
-            v <- gget
-            gput (succ v)
-            return v
+             v <- gget
+             gput (succ v)
+             return v
          gget :: (State.MonadState s m) => RegularM m s s s
          gget = RegularM State.get
          gput :: (State.MonadState s m) => s -> RegularM m s s ()
@@ -70,8 +70,8 @@ newtype VST m si so v = VST{runVST:: si -> m (so,v)}
 instance Prelude.Monad m => Monadish (VST m) where
   return x = VST (\si -> Prelude.return (si,x))
   fail x   = VST (\si -> Prelude.fail x)
-  m >>= f  = VST (\si -> (Prelude.>>=) (runVST m si) 
-                                      (\ (sm,x) -> runVST (f x) sm))
+  m >>= f  = VST (\si -> (Prelude.>>=) (runVST m si)
+                                       (\ (sm,x) -> runVST (f x) sm))
 
 vsget :: Prelude.Monad m => VST m si si si
 vsget = VST (\si -> Prelude.return (si,si))
@@ -84,9 +84,9 @@ vsm1 () = vsget >>= (\v -> vsput (succ v) >> return v)
 
 -- The same with the do-notation
 vsm1_do () = do
-            v <- vsget 
-            vsput (succ v)
-            return v
+             v <- vsget
+             vsput (succ v)
+             return v
 
 {-
  *DoParamM> :t vsm1
@@ -102,7 +102,7 @@ test2_do = IdM.runIdentity (runVST (vsm1_do ()) (0::Int))
 
 
 -- Now, we vary the type of the state, from Int to a Char
-vsm2 () = vsget >>= (\v -> vsput ((toEnum (65+v))::Char) >> 
+vsm2 () = vsget >>= (\v -> vsput ((toEnum (65+v))::Char) >>
                            vsget >>= \v' -> return (v,v'))
 
 {-
@@ -113,10 +113,10 @@ vsm2 () = vsget >>= (\v -> vsput ((toEnum (65+v))::Char) >>
 -- The same with the do-notation
  -- the following does not yet work
 vsm2_do () = do
-            v <- vsget
+             v <- vsget
              vsput ((toEnum (65+v))::Char)
              v' <- vsget
-            return (v,v')
+             return (v,v')
 
 test3 = IdM.runIdentity (runVST (vsm2 ()) (0::Int))
 -- ('A',(0,'A'))
@@ -132,7 +132,7 @@ test3_do = IdM.runIdentity (runVST (vsm2_do ()) (0::Int))
     In the first argument of `return', namely `(v == v')'
     In the expression: return (v == v')
 
-vsm3 () = vsget >>= (\v -> vsput ((toEnum (65+v))::Char) >> 
+vsm3 () = vsget >>= (\v -> vsput ((toEnum (65+v))::Char) >>
                            vsget >>= \v' -> return (v==v'))
  -}
 
@@ -140,10 +140,10 @@ vsm3 () = vsget >>= (\v -> vsput ((toEnum (65+v))::Char) >>
  -- The following too must report a type error -- the expression
 --    return (v == v') must be flagged, rather than something else
 vsm3_do () = do
-            v <- vsget
+             v <- vsget
              vsput ((toEnum (65+v))::Char)
              v' <- vsget
-            return (v==v')
+             return (v==v')
 
 
 
@@ -154,7 +154,7 @@ crec1 :: (Prelude.Enum si, Prelude.Monad m) => VST m si si Int
 crec1 = vsget >>= (\s1 -> case fromEnum s1 of
                       0 -> return 0
                       1 -> vsput (pred s1) >> return 1
-                      _ -> vsput True >> 
+                      _ -> vsput True >>
                            crec1 >>= (\v ->
                              (vsput s1 >> -- restore state type to si
                               return (v + 10))))
@@ -162,12 +162,12 @@ crec1 = vsget >>= (\s1 -> case fromEnum s1 of
 -- The same in the do-notation
 crec1_do :: (Prelude.Enum si, Prelude.Monad m) => VST m si si Int
 crec1_do = do
-       s1 <- vsget 
+        s1 <- vsget
         case fromEnum s1 of
            0 -> return 0
            1 -> do {vsput (pred s1); return 1}
            _ -> do
-               vsput True
+                vsput True
                 v <- crec1_do
                 vsput s1 -- restore state type to si
                 return (v + 10)
@@ -208,17 +208,17 @@ runLIO = unLIO
 
 -- User code
 
-tlock1 = lget >>=  (\l -> 
-        return (read l) >>= (\x ->
-        lput (show (x+1))))
+tlock1 = lget >>=  (\l ->
+         return (read l) >>= (\x ->
+         lput (show (x+1))))
 
 tlock1r = runLIO tlock1
 
 -- the same in the do-notation
 tlock1_do = do
-           l <- lget
-           let x = read l
-           lput (show (x+1))
+            l <- lget
+            let x = read l
+            lput (show (x+1))
 
 {-
   *VarStateM> :t tlock1
@@ -228,16 +228,16 @@ tlock1_do = do
 -}
 
 
-tlock2 = lget >>= (\l -> 
-        lock >> (
-        return (read l) >>= (\x ->
-        lput (show (x+1)))))
+tlock2 = lget >>= (\l ->
+         lock >> (
+         return (read l) >>= (\x ->
+         lput (show (x+1)))))
 
 tlock2_do = do
-           l <- lget
-           lock
-           let x = read l
-           lput (show (x+1))
+            l <- lget
+            lock
+            let x = read l
+            lput (show (x+1))
 
 {-
   *VarStateM> :t tlock2
@@ -272,7 +272,7 @@ tlock3r_do = runLIO tlock3_do
 {-
  gives a type error:
     Couldn't match expected type `Locked'
-          against inferred type `Unlocked'
+           against inferred type `Unlocked'
       Expected type: LIO Locked r b
       Inferred type: LIO Unlocked Locked ()
     In the expression: tlock2
@@ -291,7 +291,7 @@ tlock4_do = do {tlock2_do; tlock2_do}
 {-
 DoParamM.hs:298:30:
     Couldn't match expected type `Unlocked'
-          against inferred type `Locked'
+           against inferred type `Locked'
       Expected type: LIO Unlocked r b
       Inferred type: LIO Locked Unlocked ()
     In the second argument of `(>>)', namely `unlock'
index 38ce452..b066046 100644 (file)
@@ -3,7 +3,7 @@ module T4851 where
 
 import Prelude hiding ( id, (.) )
 
-import Control.Category        ( Category(..) )
+import Control.Category ( Category(..) )
 import Control.Arrow
 
 garbage x =
index 4ff8ed2..8fcc5d2 100644 (file)
@@ -2,55 +2,55 @@
 {-# LANGUAGE RebindableSyntax, NPlusKPatterns #-}
 
 module RebindableCase1 where
-       {
---     import Prelude;
-       import Prelude(String,undefined,Maybe(..), (==), (>=) );
+        {
+--      import Prelude;
+        import Prelude(String,undefined,Maybe(..), (==), (>=) );
 
-       return :: a;
-       return = undefined;
+        return :: a;
+        return = undefined;
 
-       infixl 1 >>=;
-       (>>=) :: a;
-       (>>=) = undefined;
+        infixl 1 >>=;
+        (>>=) :: a;
+        (>>=) = undefined;
 
-       infixl 1 >>;
-       (>>) :: a;
-       (>>) = undefined;
+        infixl 1 >>;
+        (>>) :: a;
+        (>>) = undefined;
 
-       fail :: a;
-       fail = undefined;
+        fail :: a;
+        fail = undefined;
 
-       fromInteger :: a;
-       fromInteger = undefined;
+        fromInteger :: a;
+        fromInteger = undefined;
 
-       fromRational :: a;
-       fromRational = undefined;
+        fromRational :: a;
+        fromRational = undefined;
 
-       negate :: a;
-       negate = undefined;
+        negate :: a;
+        negate = undefined;
 
-       (-) :: a;
-       (-) = undefined;
+        (-) :: a;
+        (-) = undefined;
 
 
-       test_do f g = do
-               {
-               f;
-               Just a <- g;
-               return a;
-               };
+        test_do f g = do
+                {
+                f;
+                Just a <- g;
+                return a;
+                };
 
-       test_fromInteger = 1;
+        test_fromInteger = 1;
 
-       test_fromRational = 0.5;
+        test_fromRational = 0.5;
 
-       test_negate a = - a;
+        test_negate a = - a;
 
-       test_fromInteger_pattern 1 = undefined;
-       test_fromInteger_pattern (-1) = undefined;
-       test_fromInteger_pattern (a + 7) = a;
+        test_fromInteger_pattern 1 = undefined;
+        test_fromInteger_pattern (-1) = undefined;
+        test_fromInteger_pattern (a + 7) = a;
 
-       test_fromRational_pattern 0.5 = undefined;
-       test_fromRational_pattern (-0.5) = undefined;
-       test_fromRational_pattern _ = undefined;
-       }
+        test_fromRational_pattern 0.5 = undefined;
+        test_fromRational_pattern (-0.5) = undefined;
+        test_fromRational_pattern _ = undefined;
+        }
index 2f69ac8..e1f3289 100644 (file)
@@ -1,22 +1,22 @@
 {-# LANGUAGE RebindableSyntax, NPlusKPatterns #-}
 
 module Main where
-       {
---     import Prelude;
-       import qualified Prelude;
-       import Prelude(String,undefined,Maybe(..),IO,putStrLn,
-               Integer,(++),Rational, (==), (>=) );
-       
-       import Prelude(Monad(..),Applicative(..),Functor(..));
+        {
+--      import Prelude;
+        import qualified Prelude;
+        import Prelude(String,undefined,Maybe(..),IO,putStrLn,
+                Integer,(++),Rational, (==), (>=) );
+
+        import Prelude(Monad(..),Applicative(..),Functor(..));
         import Control.Monad(ap, liftM);
 
-       debugFunc :: String -> IO a -> IO a;
-       debugFunc s ioa = (putStrLn ("++ " ++ s)) Prelude.>>
-               (ioa Prelude.>>= (\a ->
-                       (putStrLn ("-- " ++ s)) Prelude.>> (Prelude.return a)
-               ));
+        debugFunc :: String -> IO a -> IO a;
+        debugFunc s ioa = (putStrLn ("++ " ++ s)) Prelude.>>
+                (ioa Prelude.>>= (\a ->
+                        (putStrLn ("-- " ++ s)) Prelude.>> (Prelude.return a)
+                ));
 
-       newtype TM a = MkTM {unTM :: IO a};
+        newtype TM a = MkTM {unTM :: IO a};
 
         instance (Functor TM) where
           {
@@ -27,106 +27,106 @@ module Main where
             pure  = return;
             (<*>) = ap;
           };
-       instance (Monad TM) where
-               {
-               return a = MkTM (debugFunc "return" (Prelude.return a));
-
-               (>>=) ma amb = MkTM (debugFunc ">>=" ((Prelude.>>=) (unTM ma) (\a -> unTM (amb a))));
-       
-               (>>) ma mb = MkTM (debugFunc ">>" ((Prelude.>>) (unTM ma) (unTM mb)));
-
-               fail s = MkTM (debugFunc "fail" (Prelude.return undefined));
-               };
-
-       preturn a = MkTM (Prelude.return a);
-
-       fromInteger :: Integer -> Integer;
-       fromInteger a = a Prelude.+ a Prelude.+ a Prelude.+ a Prelude.+ a; -- five times
-
-       fromRational :: Rational -> Rational;
-       fromRational a = a Prelude.+ a Prelude.+ a; -- three times
-
-       negate :: a -> a;
-       negate a = a; -- don't actually negate
-
-       (-) :: a -> a -> a;
-       (-) x y = y; -- changed function
-
-
-       test_do f g = do
-               {
-               f;                              -- >>
-               Just a <- g;    -- >>= (and fail if g returns Nothing)
-               return a;               -- return
-               };
-       
-       test_fromInteger = 27;
-       
-       test_fromRational = 31.5;
-
-       test_negate a = - a;
-
-       test_fromInteger_pattern a@1 = "1=" ++ (Prelude.show a);
-       test_fromInteger_pattern a@(-2) = "(-2)=" ++ (Prelude.show a);
-       test_fromInteger_pattern (a + 7) = "(a + 7)=" ++ Prelude.show a;
-
-       test_fromRational_pattern a@0.5 = "0.5=" ++ (Prelude.show a);
-       test_fromRational_pattern a@(-0.7) = "(-0.7)=" ++ (Prelude.show a);
-       test_fromRational_pattern a = "_=" ++ (Prelude.show a);
-
-       tmPutStrLn s = MkTM (putStrLn s);
-
-       doTest :: String -> TM a -> IO ();
-       doTest s ioa =
-               (putStrLn ("start test " ++ s))
-                       Prelude.>>
-               (unTM ioa)
-                       Prelude.>>
-               (putStrLn ("end test " ++ s));
-
-       main :: IO ();
-       main = 
-               (doTest "test_do failure"
-                       (test_do (preturn ()) (preturn Nothing))
-               )
-                       Prelude.>>
-               (doTest "test_do success"
-                       (test_do (preturn ()) (preturn (Just ())))
-               )
-                       Prelude.>>
-               (doTest "test_fromInteger"
-                       (tmPutStrLn (Prelude.show test_fromInteger)) -- 27 * 5 = 135
-               )
-                       Prelude.>>
-               (doTest "test_fromRational"
-                       (tmPutStrLn (Prelude.show test_fromRational)) -- 31.5 * 3 = 189%2
-               )
-                       Prelude.>>
-               (doTest "test_negate"
-                       (tmPutStrLn (Prelude.show (test_negate 3))) -- 3 * 5 = 15, non-negate
-               )
-                       Prelude.>>
-               (doTest "test_fromInteger_pattern 1"
-                       (tmPutStrLn (test_fromInteger_pattern 1)) -- 1 * 5 = 5, matches "1"
-               )
-                       Prelude.>>
-               (doTest "test_fromInteger_pattern (-2)"
-                       (tmPutStrLn (test_fromInteger_pattern (-2))) -- "-2" = 2 * 5 = 10
-               )
-                       Prelude.>>
-               (doTest "test_fromInteger_pattern 9"
-                       (tmPutStrLn (test_fromInteger_pattern 9)) -- "9" = 45, 45 "-" "7" = "7" = 35
-               )
-                       Prelude.>>
-               (doTest "test_fromRational_pattern 0.5"
-                       (tmPutStrLn (test_fromRational_pattern 0.5)) -- "0.5" = 3%2
-               )
-                       Prelude.>>
-               (doTest "test_fromRational_pattern (-0.7)"
-                       (tmPutStrLn (test_fromRational_pattern (-0.7))) -- "-0.7" = "0.7" = 21%10
-               )
-                       Prelude.>>
-               (doTest "test_fromRational_pattern 1.7"
-                       (tmPutStrLn (test_fromRational_pattern 1.7)) -- "1.7" = 51%10
-               );
-       }
+        instance (Monad TM) where
+                {
+                return a = MkTM (debugFunc "return" (Prelude.return a));
+
+                (>>=) ma amb = MkTM (debugFunc ">>=" ((Prelude.>>=) (unTM ma) (\a -> unTM (amb a))));
+
+                (>>) ma mb = MkTM (debugFunc ">>" ((Prelude.>>) (unTM ma) (unTM mb)));
+
+                fail s = MkTM (debugFunc "fail" (Prelude.return undefined));
+                };
+
+        preturn a = MkTM (Prelude.return a);
+
+        fromInteger :: Integer -> Integer;
+        fromInteger a = a Prelude.+ a Prelude.+ a Prelude.+ a Prelude.+ a; -- five times
+
+        fromRational :: Rational -> Rational;
+        fromRational a = a Prelude.+ a Prelude.+ a; -- three times
+
+        negate :: a -> a;
+        negate a = a; -- don't actually negate
+
+        (-) :: a -> a -> a;
+        (-) x y = y; -- changed function
+
+
+        test_do f g = do
+                {
+                f;                              -- >>
+                Just a <- g;    -- >>= (and fail if g returns Nothing)
+                return a;               -- return
+                };
+
+        test_fromInteger = 27;
+
+        test_fromRational = 31.5;
+
+        test_negate a = - a;
+
+        test_fromInteger_pattern a@1 = "1=" ++ (Prelude.show a);
+        test_fromInteger_pattern a@(-2) = "(-2)=" ++ (Prelude.show a);
+        test_fromInteger_pattern (a + 7) = "(a + 7)=" ++ Prelude.show a;
+
+        test_fromRational_pattern a@0.5 = "0.5=" ++ (Prelude.show a);
+        test_fromRational_pattern a@(-0.7) = "(-0.7)=" ++ (Prelude.show a);
+        test_fromRational_pattern a = "_=" ++ (Prelude.show a);
+
+        tmPutStrLn s = MkTM (putStrLn s);
+
+        doTest :: String -> TM a -> IO ();
+        doTest s ioa =
+                (putStrLn ("start test " ++ s))
+                        Prelude.>>
+                (unTM ioa)
+                        Prelude.>>
+                (putStrLn ("end test " ++ s));
+
+        main :: IO ();
+        main =
+                (doTest "test_do failure"
+                        (test_do (preturn ()) (preturn Nothing))
+                )
+                        Prelude.>>
+                (doTest "test_do success"
+                        (test_do (preturn ()) (preturn (Just ())))
+                )
+                        Prelude.>>
+                (doTest "test_fromInteger"
+                        (tmPutStrLn (Prelude.show test_fromInteger)) -- 27 * 5 = 135
+                )
+                        Prelude.>>
+                (doTest "test_fromRational"
+                        (tmPutStrLn (Prelude.show test_fromRational)) -- 31.5 * 3 = 189%2
+                )
+                        Prelude.>>
+                (doTest "test_negate"
+                        (tmPutStrLn (Prelude.show (test_negate 3))) -- 3 * 5 = 15, non-negate
+                )
+                        Prelude.>>
+                (doTest "test_fromInteger_pattern 1"
+                        (tmPutStrLn (test_fromInteger_pattern 1)) -- 1 * 5 = 5, matches "1"
+                )
+                        Prelude.>>
+                (doTest "test_fromInteger_pattern (-2)"
+                        (tmPutStrLn (test_fromInteger_pattern (-2))) -- "-2" = 2 * 5 = 10
+                )
+                        Prelude.>>
+                (doTest "test_fromInteger_pattern 9"
+                        (tmPutStrLn (test_fromInteger_pattern 9)) -- "9" = 45, 45 "-" "7" = "7" = 35
+                )
+                        Prelude.>>
+                (doTest "test_fromRational_pattern 0.5"
+                        (tmPutStrLn (test_fromRational_pattern 0.5)) -- "0.5" = 3%2
+                )
+                        Prelude.>>
+                (doTest "test_fromRational_pattern (-0.7)"
+                        (tmPutStrLn (test_fromRational_pattern (-0.7))) -- "-0.7" = "0.7" = 21%10
+                )
+                        Prelude.>>
+                (doTest "test_fromRational_pattern 1.7"
+                        (tmPutStrLn (test_fromRational_pattern 1.7)) -- "1.7" = 51%10
+                );
+        }
index 682787f..0434c1d 100644 (file)
 {-# LANGUAGE RebindableSyntax, NPlusKPatterns #-}
 
 module Main where
-       {
---     import Prelude;
-       import qualified Prelude;
-       import Prelude(String,undefined,Maybe(..),IO,putStrLn,
-               Integer,(++),Rational, (==), (>=) );
-
-       debugFunc :: String -> IO a -> IO a;
-       debugFunc s ioa = (putStrLn ("++ " ++ s)) Prelude.>>
-               (ioa Prelude.>>= (\a -> 
-                       (putStrLn ("-- " ++ s)) Prelude.>> (Prelude.return a)
-               ));
-
-       return :: a -> IO a;
-       return a = debugFunc "return" (Prelude.return a);
-
-       infixl 1 >>=;
-       (>>=) :: IO a -> (a -> IO b) -> IO b;
-       (>>=) ma amb = debugFunc ">>=" ((Prelude.>>=) ma amb);
-       
-       infixl 1 >>;
-       (>>) :: IO a -> IO b -> IO b;
-       (>>) ma mb = debugFunc ">>" ((Prelude.>>) ma mb);
-
-       fail :: String -> IO a;
-       fail s = debugFunc "fail" (Prelude.return undefined);
---     fail s = debugFunc "fail" (Prelude.fail s);
-
-       fromInteger :: Integer -> Integer;
-       fromInteger a = a Prelude.+ a Prelude.+ a Prelude.+ a Prelude.+ a; -- five times
-
-       fromRational :: Rational -> Rational;
-       fromRational a = a Prelude.+ a Prelude.+ a; -- three times
-
-       negate :: a -> a;
-       negate a = a; -- don't actually negate
-
-       (-) :: a -> a -> a;
-       (-) x y = y; -- changed function
-
-
-       test_do f g = do
-               {
-               f;                              -- >>
-               Just a <- g;    -- >>= (and fail if g returns Nothing)
-               return a;               -- return
-               };
-       
-       test_fromInteger = 27;
-       
-       test_fromRational = 31.5;
-
-       test_negate a = - a;
-
-       test_fromInteger_pattern a@1 = "1=" ++ (Prelude.show a);
-       test_fromInteger_pattern a@(-2) = "(-2)=" ++ (Prelude.show a);
-       test_fromInteger_pattern (a + 7) = "(a + 7)=" ++ Prelude.show a;
-
-       test_fromRational_pattern a@0.5 = "0.5=" ++ (Prelude.show a);
-       test_fromRational_pattern a@(-0.7) = "(-0.7)=" ++ (Prelude.show a);
-       test_fromRational_pattern a = "_=" ++ (Prelude.show a);
-
-
-       doTest :: String -> IO a -> IO ();
-       doTest s ioa = 
-               (putStrLn ("start test " ++ s))
-                       Prelude.>>
-               ioa
-                       Prelude.>>
-               (putStrLn ("end test " ++ s));
-
-       main :: IO ();
-       main = 
-               (doTest "test_do failure"
-                       (test_do (Prelude.return ()) (Prelude.return Nothing))
-               )
-                       Prelude.>>
-               (doTest "test_do success"
-                       (test_do (Prelude.return ()) (Prelude.return (Just ())))
-               )
-                       Prelude.>>
-               (doTest "test_fromInteger"
-                       (putStrLn (Prelude.show test_fromInteger))
-               )
-                       Prelude.>>
-               (doTest "test_fromRational"
-                       (putStrLn (Prelude.show test_fromRational))
-               )
-                       Prelude.>>
-               (doTest "test_negate"
-                       (putStrLn (Prelude.show (test_negate 3)))
-               )
-                       Prelude.>>
-               (doTest "test_fromInteger_pattern 1"
-                       (putStrLn (test_fromInteger_pattern 1))
-               )
-                       Prelude.>>
-               (doTest "test_fromInteger_pattern (-2)"
-                       (putStrLn (test_fromInteger_pattern (-2)))
-               )
-                       Prelude.>>
-               (doTest "test_fromInteger_pattern 9"
-                       (putStrLn (test_fromInteger_pattern 9))
-               )
-                       Prelude.>>
-               (doTest "test_fromRational_pattern 0.5"
-                       (putStrLn (test_fromRational_pattern 0.5))
-               )
-                       Prelude.>>
-               (doTest "test_fromRational_pattern (-0.7)"
-                       (putStrLn (test_fromRational_pattern (-0.7)))
-               )
-                       Prelude.>>
-               (doTest "test_fromRational_pattern 1.7"
-                       (putStrLn (test_fromRational_pattern 1.7))
-               );
-       }
+        {
+--      import Prelude;
+        import qualified Prelude;
+        import Prelude(String,undefined,Maybe(..),IO,putStrLn,
+                Integer,(++),Rational, (==), (>=) );
+
+        debugFunc :: String -> IO a -> IO a;
+        debugFunc s ioa = (putStrLn ("++ " ++ s)) Prelude.>>
+                (ioa Prelude.>>= (\a ->
+                        (putStrLn ("-- " ++ s)) Prelude.>> (Prelude.return a)
+                ));
+
+        return :: a -> IO a;
+        return a = debugFunc "return" (Prelude.return a);
+
+        infixl 1 >>=;
+        (>>=) :: IO a -> (a -> IO b) -> IO b;
+        (>>=) ma amb = debugFunc ">>=" ((Prelude.>>=) ma amb);
+
+        infixl 1 >>;
+        (>>) :: IO a -> IO b -> IO b;
+        (>>) ma mb = debugFunc ">>" ((Prelude.>>) ma mb);
+
+        fail :: String -> IO a;
+        fail s = debugFunc "fail" (Prelude.return undefined);
+--      fail s = debugFunc "fail" (Prelude.fail s);
+
+        fromInteger :: Integer -> Integer;
+        fromInteger a = a Prelude.+ a Prelude.+ a Prelude.+ a Prelude.+ a; -- five times
+
+        fromRational :: Rational -> Rational;
+        fromRational a = a Prelude.+ a Prelude.+ a; -- three times
+
+        negate :: a -> a;
+        negate a = a; -- don't actually negate
+
+        (-) :: a -> a -> a;
+        (-) x y = y; -- changed function
+
+
+        test_do f g = do
+                {
+                f;                              -- >>
+                Just a <- g;    -- >>= (and fail if g returns Nothing)
+                return a;               -- return
+                };
+
+        test_fromInteger = 27;
+
+        test_fromRational = 31.5;
+
+        test_negate a = - a;
+
+        test_fromInteger_pattern a@1 = "1=" ++ (Prelude.show a);
+        test_fromInteger_pattern a@(-2) = "(-2)=" ++ (Prelude.show a);
+        test_fromInteger_pattern (a + 7) = "(a + 7)=" ++ Prelude.show a;
+
+        test_fromRational_pattern a@0.5 = "0.5=" ++ (Prelude.show a);
+        test_fromRational_pattern a@(-0.7) = "(-0.7)=" ++ (Prelude.show a);
+        test_fromRational_pattern a = "_=" ++ (Prelude.show a);
+
+
+        doTest :: String -> IO a -> IO ();
+        doTest s ioa =
+                (putStrLn ("start test " ++ s))
+                        Prelude.>>
+                ioa
+                        Prelude.>>
+                (putStrLn ("end test " ++ s));
+
+        main :: IO ();
+        main =
+                (doTest "test_do failure"
+                        (test_do (Prelude.return ()) (Prelude.return Nothing))
+                )
+                        Prelude.>>
+                (doTest "test_do success"
+                        (test_do (Prelude.return ()) (Prelude.return (Just ())))
+                )
+                        Prelude.>>
+                (doTest "test_fromInteger"
+                        (putStrLn (Prelude.show test_fromInteger))
+                )
+                        Prelude.>>
+                (doTest "test_fromRational"
+                        (putStrLn (Prelude.show test_fromRational))
+                )
+                        Prelude.>>
+                (doTest "test_negate"
+                        (putStrLn (Prelude.show (test_negate 3)))
+                )
+                        Prelude.>>
+                (doTest "test_fromInteger_pattern 1"
+                        (putStrLn (test_fromInteger_pattern 1))
+                )
+                        Prelude.>>
+                (doTest "test_fromInteger_pattern (-2)"
+                        (putStrLn (test_fromInteger_pattern (-2)))
+                )
+                        Prelude.>>
+                (doTest "test_fromInteger_pattern 9"
+                        (putStrLn (test_fromInteger_pattern 9))
+                )
+                        Prelude.>>
+                (doTest "test_fromRational_pattern 0.5"
+                        (putStrLn (test_fromRational_pattern 0.5))
+                )
+                        Prelude.>>
+                (doTest "test_fromRational_pattern (-0.7)"
+                        (putStrLn (test_fromRational_pattern (-0.7)))
+                )
+                        Prelude.>>
+                (doTest "test_fromRational_pattern 1.7"
+                        (putStrLn (test_fromRational_pattern 1.7))
+                );
+        }
index 2c25c9a..f657683 100644 (file)
 {-# LANGUAGE RebindableSyntax, NPlusKPatterns #-}
 
 module Main where
-       {
---     import Prelude;
-       import qualified Prelude;
-       import Prelude(String,undefined,Maybe(..),IO,putStrLn,
-               Integer,(++),Rational, (==), (>=) );
-
-       debugFunc :: String -> IO a -> IO a;
-       debugFunc s ioa = (putStrLn ("++ " ++ s)) Prelude.>>
-               (ioa Prelude.>>= (\a -> 
-                       (putStrLn ("-- " ++ s)) Prelude.>> (Prelude.return a)
-               ));
-
-       infixl 1 >>=;
-       infixl 1 >>;
-
-       class MyMonad m where
-               {
-               return :: a -> m a;
-               (>>=) :: m a -> (a -> m b) -> m b;
-               (>>) :: m a -> m b -> m b;
-               fail :: String -> m a;
-               };
-
-       instance MyMonad IO where
-               {
-               return a = debugFunc "return" (Prelude.return a);
-       
-               (>>=) ma amb = debugFunc ">>=" ((Prelude.>>=) ma amb);
-               
-               (>>) ma mb = debugFunc ">>" ((Prelude.>>) ma mb);
-       
-               fail s = debugFunc "fail" (Prelude.return undefined);
-       --      fail s = debugFunc "fail" (Prelude.fail s);
-               };
-
-       fromInteger :: Integer -> Integer;
-       fromInteger a = a Prelude.+ a Prelude.+ a Prelude.+ a Prelude.+ a; -- five times
-
-       fromRational :: Rational -> Rational;
-       fromRational a = a Prelude.+ a Prelude.+ a; -- three times
-
-       negate :: a -> a;
-       negate a = a; -- don't actually negate
-
-       (-) :: a -> a -> a;
-       (-) x y = y; -- changed function
-
-
-       test_do f g = do
-               {
-               f;                              -- >>
-               Just a <- g;    -- >>= (and fail if g returns Nothing)
-               return a;               -- return
-               };
-       
-       test_fromInteger = 27;
-       
-       test_fromRational = 31.5;
-
-       test_negate a = - a;
-
-       test_fromInteger_pattern a@1 = "1=" ++ (Prelude.show a);
-       test_fromInteger_pattern a@(-2) = "(-2)=" ++ (Prelude.show a);
-       test_fromInteger_pattern (a + 7) = "(a + 7)=" ++ Prelude.show a;
-
-       test_fromRational_pattern a@0.5 = "0.5=" ++ (Prelude.show a);
-       test_fromRational_pattern a@(-0.7) = "(-0.7)=" ++ (Prelude.show a);
-       test_fromRational_pattern a = "_=" ++ (Prelude.show a);
-
-
-       doTest :: String -> IO a -> IO ();
-       doTest s ioa = 
-               (putStrLn ("start test " ++ s))
-                       Prelude.>>
-               ioa
-                       Prelude.>>
-               (putStrLn ("end test " ++ s));
-
-       main :: IO ();
-       main = 
-               (doTest "test_do failure"
-                       (test_do (Prelude.return ()) (Prelude.return Nothing))
-               )
-                       Prelude.>>
-               (doTest "test_do success"
-                       (test_do (Prelude.return ()) (Prelude.return (Just ())))
-               )
-                       Prelude.>>
-               (doTest "test_fromInteger"
-                       (putStrLn (Prelude.show test_fromInteger))
-               )
-                       Prelude.>>
-               (doTest "test_fromRational"
-                       (putStrLn (Prelude.show test_fromRational))
-               )
-                       Prelude.>>
-               (doTest "test_negate"
-                       (putStrLn (Prelude.show (test_negate 3)))
-               )
-                       Prelude.>>
-               (doTest "test_fromInteger_pattern 1"
-                       (putStrLn (test_fromInteger_pattern 1))
-               )
-                       Prelude.>>
-               (doTest "test_fromInteger_pattern (-2)"
-                       (putStrLn (test_fromInteger_pattern (-2)))
-               )
-                       Prelude.>>
-               (doTest "test_fromInteger_pattern 9"
-                       (putStrLn (test_fromInteger_pattern 9))
-               )
-                       Prelude.>>
-               (doTest "test_fromRational_pattern 0.5"
-                       (putStrLn (test_fromRational_pattern 0.5))
-               )
-                       Prelude.>>
-               (doTest "test_fromRational_pattern (-0.7)"
-                       (putStrLn (test_fromRational_pattern (-0.7)))
-               )
-                       Prelude.>>
-               (doTest "test_fromRational_pattern 1.7"
-                       (putStrLn (test_fromRational_pattern 1.7))
-               );
-       }
+        {
+--      import Prelude;
+        import qualified Prelude;
+        import Prelude(String,undefined,Maybe(..),IO,putStrLn,
+                Integer,(++),Rational, (==), (>=) );
+
+        debugFunc :: String -> IO a -> IO a;
+        debugFunc s ioa = (putStrLn ("++ " ++ s)) Prelude.>>
+                (ioa Prelude.>>= (\a ->
+                        (putStrLn ("-- " ++ s)) Prelude.>> (Prelude.return a)
+                ));
+
+        infixl 1 >>=;
+        infixl 1 >>;
+
+        class MyMonad m where
+                {
+                return :: a -> m a;
+                (>>=) :: m a -> (a -> m b) -> m b;
+                (>>) :: m a -> m b -> m b;
+                fail :: String -> m a;
+                };
+
+        instance MyMonad IO where
+                {
+                return a = debugFunc "return" (Prelude.return a);
+
+                (>>=) ma amb = debugFunc ">>=" ((Prelude.>>=) ma amb);
+
+                (>>) ma mb = debugFunc ">>" ((Prelude.>>) ma mb);
+
+                fail s = debugFunc "fail" (Prelude.return undefined);
+        --      fail s = debugFunc "fail" (Prelude.fail s);
+                };
+
+        fromInteger :: Integer -> Integer;
+        fromInteger a = a Prelude.+ a Prelude.+ a Prelude.+ a Prelude.+ a; -- five times
+
+        fromRational :: Rational -> Rational;
+        fromRational a = a Prelude.+ a Prelude.+ a; -- three times
+
+        negate :: a -> a;
+        negate a = a; -- don't actually negate
+
+        (-) :: a -> a -> a;
+        (-) x y = y; -- changed function
+
+
+        test_do f g = do
+                {
+                f;                              -- >>
+                Just a <- g;    -- >>= (and fail if g returns Nothing)
+                return a;               -- return
+                };
+
+        test_fromInteger = 27;
+
+        test_fromRational = 31.5;
+
+        test_negate a = - a;
+
+        test_fromInteger_pattern a@1 = "1=" ++ (Prelude.show a);
+        test_fromInteger_pattern a@(-2) = "(-2)=" ++ (Prelude.show a);
+        test_fromInteger_pattern (a + 7) = "(a + 7)=" ++ Prelude.show a;
+
+        test_fromRational_pattern a@0.5 = "0.5=" ++ (Prelude.show a);
+        test_fromRational_pattern a@(-0.7) = "(-0.7)=" ++ (Prelude.show a);
+        test_fromRational_pattern a = "_=" ++ (Prelude.show a);
+
+
+        doTest :: String -> IO a -> IO ();
+        doTest s ioa =
+                (putStrLn ("start test " ++ s))
+                        Prelude.>>
+                ioa
+                        Prelude.>>
+                (putStrLn ("end test " ++ s));
+
+        main :: IO ();
+        main =
+                (doTest "test_do failure"
+                        (test_do (Prelude.return ()) (Prelude.return Nothing))
+                )
+                        Prelude.>>
+                (doTest "test_do success"
+                        (test_do (Prelude.return ()) (Prelude.return (Just ())))
+                )
+                        Prelude.>>
+                (doTest "test_fromInteger"
+                        (putStrLn (Prelude.show test_fromInteger))
+                )
+                        Prelude.>>
+                (doTest "test_fromRational"
+                        (putStrLn (Prelude.show test_fromRational))
+                )
+                        Prelude.>>
+                (doTest "test_negate"
+                        (putStrLn (Prelude.show (test_negate 3)))
+                )
+                        Prelude.>>
+                (doTest "test_fromInteger_pattern 1"
+                        (putStrLn (test_fromInteger_pattern 1))
+                )
+                        Prelude.>>
+                (doTest "test_fromInteger_pattern (-2)"
+                        (putStrLn (test_fromInteger_pattern (-2)))
+                )
+                        Prelude.>>
+                (doTest "test_fromInteger_pattern 9"
+                        (putStrLn (test_fromInteger_pattern 9))
+                )
+                        Prelude.>>
+                (doTest "test_fromRational_pattern 0.5"
+                        (putStrLn (test_fromRational_pattern 0.5))
+                )
+                        Prelude.>>
+                (doTest "test_fromRational_pattern (-0.7)"
+                        (putStrLn (test_fromRational_pattern (-0.7)))
+                )
+                        Prelude.>>
+                (doTest "test_fromRational_pattern 1.7"
+                        (putStrLn (test_fromRational_pattern 1.7))
+                );
+        }
index 94b3f4e..3120ea1 100644 (file)
              MultiParamTypeClasses, FunctionalDependencies #-}
 
 module Main where
-       {
---     import Prelude;
-       import qualified Prelude;
-       import Prelude(String,undefined,Maybe(..),IO,putStrLn,
-               Integer,(++),Rational, (==), (>=) );
-
-       debugFunc :: String -> IO a -> IO a;
-       debugFunc s ioa = (putStrLn ("++ " ++ s)) Prelude.>>
-               (ioa Prelude.>>= (\a -> 
-                       (putStrLn ("-- " ++ s)) Prelude.>> (Prelude.return a)
-               ));
-
-       infixl 1 >>=;
-       infixl 1 >>;
-
-       returnIO :: a -> IO a;
+        {
+--      import Prelude;
+        import qualified Prelude;
+        import Prelude(String,undefined,Maybe(..),IO,putStrLn,
+                Integer,(++),Rational, (==), (>=) );
+
+        debugFunc :: String -> IO a -> IO a;
+        debugFunc s ioa = (putStrLn ("++ " ++ s)) Prelude.>>
+                (ioa Prelude.>>= (\a ->
+                        (putStrLn ("-- " ++ s)) Prelude.>> (Prelude.return a)
+                ));
+
+        infixl 1 >>=;
+        infixl 1 >>;
+
+        returnIO :: a -> IO a;
         returnIO = Prelude.return;
-       
-       class HasReturn m where
-               {
-               return :: a -> m a;
-               };
-
-       class HasBind m n mn | m n -> mn, m mn -> n where
-               {
-               (>>=) :: m a -> (a -> n b) -> mn b;
-               };
-
-       class HasSeq m n mn | m n -> mn, m mn -> n where
-               {
-               (>>) :: m a -> n b -> mn b;
-               };
-
-       class HasFail m where
-               {
-               fail :: String -> m a;
-               };
-
-       instance HasReturn IO where
-               {
-               return a = debugFunc "return" (returnIO a);
-               };
-
-       instance HasBind IO IO IO where
-               {
-               (>>=) ma amb = debugFunc ">>=" ((Prelude.>>=) ma amb);
-               };
-
-       instance HasSeq IO IO IO where
-               {
-               (>>) ma mb = debugFunc ">>" ((Prelude.>>) ma mb);
-               };
-
-       instance HasFail IO where
-               {
-               fail s = debugFunc "fail" (returnIO undefined);
-       --      fail s = debugFunc "fail" (Prelude.fail s);
-               };
-
-       class HasFromInteger a where
-               {
-               fromInteger :: a -> a;
-               };
-
-       instance HasFromInteger Integer where
-               {
-               fromInteger a = a Prelude.+ a Prelude.+ a Prelude.+ a Prelude.+ a; -- five times
-               };
-
-       class HasFromRational a where
-               {
-               fromRational :: a -> a;
-               };
-
-       instance HasFromRational Rational where
-               {
-               fromRational a = a Prelude.+ a Prelude.+ a; -- three times
-               };
-
-       class HasNegate a where
-               {
-               negate :: a -> a;
-               };
-
-       instance HasNegate Integer where
-               {
-               negate a = a; -- don't actually negate
-               };
-
-       instance HasNegate Rational where
-               {
-               negate a = a; -- don't actually negate
-               };
-
-       class HasMinus a where
-               {
-               (-) :: a -> a -> a;
-               };
-
-       instance HasMinus Rational where
-               {
-               (-) x y = y; -- changed function
-               };
-
-       instance HasMinus Integer where
-               {
-               (-) x y = y; -- changed function
-               };
-
-
-       test_do f g = do
-               {
-               f;                              -- >>
-               Just a <- g;    -- >>= (and fail if g returns Nothing)
-               return a;               -- return
-               };
-       
-       test_fromInteger :: Integer;
-       test_fromInteger = 27;
-       
-       test_fromRational :: Rational;
-       test_fromRational = 31.5;
-
-       test_negate :: Integer -> Integer;
-       test_negate a = - a;
-
-       test_fromInteger_pattern :: Integer -> String;
-       test_fromInteger_pattern a@1 = "1=" ++ (Prelude.show a);
-       test_fromInteger_pattern a@(-2) = "(-2)=" ++ (Prelude.show a);
-       test_fromInteger_pattern (a + 7) = "(a + 7)=" ++ Prelude.show a;
-
-       test_fromRational_pattern :: Rational -> String;
-       test_fromRational_pattern a@0.5 = "0.5=" ++ (Prelude.show a);
-       test_fromRational_pattern a@(-0.7) = "(-0.7)=" ++ (Prelude.show a);
-       test_fromRational_pattern a = "_=" ++ (Prelude.show a);
-
-
-       doTest :: String -> IO a -> IO ();
-       doTest s ioa = 
-               (putStrLn ("start test " ++ s))
-                       Prelude.>>
-               ioa
-                       Prelude.>>
-               (putStrLn ("end test " ++ s));
-
-       main :: IO ();
-       main = 
-               (doTest "test_do failure"
-                       (test_do (returnIO ()) (returnIO Nothing))
-               )
-                       Prelude.>>
-               (doTest "test_do success"
-                       (test_do (returnIO ()) (returnIO (Just ())))
-               )
-                       Prelude.>>
-               (doTest "test_fromInteger"
-                       (putStrLn (Prelude.show test_fromInteger))
-               )
-                       Prelude.>>
-               (doTest "test_fromRational"
-                       (putStrLn (Prelude.show test_fromRational))
-               )
-                       Prelude.>>
-               (doTest "test_negate"
-                       (putStrLn (Prelude.show (test_negate 3)))
-               )
-                       Prelude.>>
-               (doTest "test_fromInteger_pattern 1"
-                       (putStrLn (test_fromInteger_pattern 1))
-               )
-                       Prelude.>>
-               (doTest "test_fromInteger_pattern (-2)"
-                       (putStrLn (test_fromInteger_pattern (-(2::Integer)::Integer)))
-               )
-                       Prelude.>>
-               (doTest "test_fromInteger_pattern 9"
-                       (putStrLn (test_fromInteger_pattern 9))
-               )
-                       Prelude.>>
-               (doTest "test_fromRational_pattern 0.5"
-                       (putStrLn (test_fromRational_pattern 0.5))
-               )
-                       Prelude.>>
-               (doTest "test_fromRational_pattern (-0.7)"
-                       (putStrLn (test_fromRational_pattern (-(0.7::Rational)::Rational)))
-               )
-                       Prelude.>>
-               (doTest "test_fromRational_pattern 1.7"
-                       (putStrLn (test_fromRational_pattern 1.7))
-               )
-          ;
-       }
+
+        class HasReturn m where
+                {
+                return :: a -> m a;
+                };
+
+        class HasBind m n mn | m n -> mn, m mn -> n where
+                {
+                (>>=) :: m a -> (a -> n b) -> mn b;
+                };
+
+        class HasSeq m n mn | m n -> mn, m mn -> n where
+                {
+                (>>) :: m a -> n b -> mn b;
+                };
+
+        class HasFail m where
+                {
+                fail :: String -> m a;
+                };
+
+        instance HasReturn IO where
+                {
+                return a = debugFunc "return" (returnIO a);
+                };
+
+        instance HasBind IO IO IO where
+                {
+                (>>=) ma amb = debugFunc ">>=" ((Prelude.>>=) ma amb);
+                };
+
+        instance HasSeq IO IO IO where
+                {
+                (>>) ma mb = debugFunc ">>" ((Prelude.>>) ma mb);
+                };
+
+        instance HasFail IO where
+                {
+                fail s = debugFunc "fail" (returnIO undefined);
+        --      fail s = debugFunc "fail" (Prelude.fail s);
+                };
+
+        class HasFromInteger a where
+                {
+                fromInteger :: a -> a;
+                };
+
+        instance HasFromInteger Integer where
+                {
+                fromInteger a = a Prelude.+ a Prelude.+ a Prelude.+ a Prelude.+ a; -- five times
+                };
+
+        class HasFromRational a where
+                {
+                fromRational :: a -> a;
+                };
+
+        instance HasFromRational Rational where
+                {
+                fromRational a = a Prelude.+ a Prelude.+ a; -- three times
+                };
+
+        class HasNegate a where
+                {
+                negate :: a -> a;
+                };
+
+        instance HasNegate Integer where
+                {
+                negate a = a; -- don't actually negate
+                };
+
+        instance HasNegate Rational where
+                {
+                negate a = a; -- don't actually negate
+                };
+
+        class HasMinus a where
+                {
+                (-) :: a -> a -> a;
+                };
+
+        instance HasMinus Rational where
+                {
+                (-) x y = y; -- changed function
+                };
+
+        instance HasMinus Integer where
+                {
+                (-) x y = y; -- changed function
+                };
+
+
+        test_do f g = do
+                {
+                f;                              -- >>
+                Just a <- g;    -- >>= (and fail if g returns Nothing)
+                return a;               -- return
+                };
+
+        test_fromInteger :: Integer;
+        test_fromInteger = 27;
+
+        test_fromRational :: Rational;
+        test_fromRational = 31.5;
+
+        test_negate :: Integer -> Integer;
+        test_negate a = - a;
+
+        test_fromInteger_pattern :: Integer -> String;
+        test_fromInteger_pattern a@1 = "1=" ++ (Prelude.show a);
+        test_fromInteger_pattern a@(-2) = "(-2)=" ++ (Prelude.show a);
+        test_fromInteger_pattern (a + 7) = "(a + 7)=" ++ Prelude.show a;
+
+        test_fromRational_pattern :: Rational -> String;
+        test_fromRational_pattern a@0.5 = "0.5=" ++ (Prelude.show a);
+        test_fromRational_pattern a@(-0.7) = "(-0.7)=" ++ (Prelude.show a);
+        test_fromRational_pattern a = "_=" ++ (Prelude.show a);
+
+
+        doTest :: String -> IO a -> IO ();
+        doTest s ioa =
+                (putStrLn ("start test " ++ s))
+                        Prelude.>>
+                ioa
+                        Prelude.>>
+                (putStrLn ("end test " ++ s));
+
+        main :: IO ();
+        main =
+                (doTest "test_do failure"
+                        (test_do (returnIO ()) (returnIO Nothing))
+                )
+                        Prelude.>>
+                (doTest "test_do success"
+                        (test_do (returnIO ()) (returnIO (Just ())))
+                )
+                        Prelude.>>
+                (doTest "test_fromInteger"
+                        (putStrLn (Prelude.show test_fromInteger))
+                )
+                        Prelude.>>
+                (doTest "test_fromRational"
+                        (putStrLn (Prelude.show test_fromRational))
+                )
+                        Prelude.>>
+                (doTest "test_negate"
+                        (putStrLn (Prelude.show (test_negate 3)))
+                )
+                        Prelude.>>
+                (doTest "test_fromInteger_pattern 1"
+                        (putStrLn (test_fromInteger_pattern 1))
+                )
+                        Prelude.>>
+                (doTest "test_fromInteger_pattern (-2)"
+                        (putStrLn (test_fromInteger_pattern (-(2::Integer)::Integer)))
+                )
+                        Prelude.>>
+                (doTest "test_fromInteger_pattern 9"
+                        (putStrLn (test_fromInteger_pattern 9))
+                )
+                        Prelude.>>
+                (doTest "test_fromRational_pattern 0.5"
+                        (putStrLn (test_fromRational_pattern 0.5))
+                )
+                        Prelude.>>
+                (doTest "test_fromRational_pattern (-0.7)"
+                        (putStrLn (test_fromRational_pattern (-(0.7::Rational)::Rational)))
+                )
+                        Prelude.>>
+                (doTest "test_fromRational_pattern 1.7"
+                        (putStrLn (test_fromRational_pattern 1.7))
+                )
+           ;
+        }
index 3ec0347..6ed8249 100644 (file)
 {-# LANGUAGE TypeFamilies #-}
 
 module Main where
-       {
-       import qualified Prelude;
-       import Prelude(String,undefined,Maybe(..),IO,putStrLn,
-               Integer,(++),Rational, (==), (>=) );
+        {
+        import qualified Prelude;
+        import Prelude(String,undefined,Maybe(..),IO,putStrLn,
+                Integer,(++),Rational, (==), (>=) );
 
-       debugFunc :: String -> IO a -> IO a;
-       debugFunc s ioa = (putStrLn ("++ " ++ s)) Prelude.>>
-               (ioa Prelude.>>= (\a ->
-                       (putStrLn ("-- " ++ s)) Prelude.>> (Prelude.return a)
-               ));
+        debugFunc :: String -> IO a -> IO a;
+        debugFunc s ioa = (putStrLn ("++ " ++ s)) Prelude.>>
+                (ioa Prelude.>>= (\a ->
+                        (putStrLn ("-- " ++ s)) Prelude.>> (Prelude.return a)
+                ));
 
-       infixl 1 >>=;
-       infixl 1 >>;
+        infixl 1 >>=;
+        infixl 1 >>;
 
-       returnIO :: a -> IO a;
+        returnIO :: a -> IO a;
         returnIO = Prelude.return;
 
-       class HasReturn a where
-               {
-               return :: a;
-               };
-
-       class HasBind a where
-               {
-               (>>=) :: a;
-               };
-
-       class HasSeq a where
-               {
-               (>>) :: a;
-               };
-
-       class HasFail a where
-               {
-               fail :: a;
-               };
-
-       instance HasReturn (a -> IO a) where
-               {
-               return a = debugFunc "return" (Prelude.return a);
-               };
-
-       instance HasBind (IO a -> (a -> IO b) -> IO b) where
-               {
-               (>>=) ma amb = debugFunc ">>=" ((Prelude.>>=) ma amb);
-               };
-
-       instance HasSeq (IO a -> IO b -> IO b) where
-               {
-               (>>) ma mb = debugFunc ">>" ((Prelude.>>) ma mb);
-               };
-
-       instance HasFail (String -> IO a) where
-               {
-               fail s = debugFunc "fail" (Prelude.return undefined);
-       --      fail s = debugFunc "fail" (Prelude.fail s);
-               };
-
-       class HasFromInteger a where
-               {
-               fromInteger :: a;
-               };
-
-       instance HasFromInteger (Integer -> Integer) where
-               {
-               fromInteger a = a Prelude.+ a Prelude.+ a Prelude.+ a Prelude.+ a; -- five times
-               };
-
-       class HasFromRational a where
-               {
-               fromRational :: a;
-               };
-
-       instance HasFromRational (Rational -> Rational) where
-               {
-               fromRational a = a Prelude.+ a Prelude.+ a; -- three times
-               };
-
-       class HasNegate a where
-               {
-               negate :: a;
-               };
-
-       instance (b ~ (a -> a)) => HasNegate b where
-               {
-               negate a = a; -- don't actually negate
-               };
-
-       class HasMinus a where
-               {
-               (-) :: a;
-               };
-
-       instance (b ~ (a -> a -> a)) => HasMinus b where
-               {
-               (-) x y = y; -- changed function
-               };
-
-       test_do :: forall a b. IO a -> IO (Maybe b) -> IO b;
-       test_do f g = do
-               {
-               f;                      -- >>
-               Just (b::b) <- g;       -- >>= (and fail if g returns Nothing)
-               return b;               -- return
-               };
-
-       test_fromInteger :: Integer;
-       test_fromInteger = 27;
-
-       test_fromRational :: Rational;
-       test_fromRational = 31.5;
-
-       test_negate :: Integer -> Integer;
-       test_negate a = - a;
-
-       test_fromInteger_pattern :: Integer -> String;
-       test_fromInteger_pattern a@1 = "1=" ++ (Prelude.show a);
-       test_fromInteger_pattern a@(-2) = "(-2)=" ++ (Prelude.show a);
-       test_fromInteger_pattern (a + 7) = "(a + 7)=" ++ Prelude.show a;
-
-       test_fromRational_pattern :: Rational -> String;
-       test_fromRational_pattern a@0.5 = "0.5=" ++ (Prelude.show a);
-       test_fromRational_pattern a@(-0.7) = "(-0.7)=" ++ (Prelude.show a);
-       test_fromRational_pattern a = "_=" ++ (Prelude.show a);
-
-
-       doTest :: String -> IO a -> IO ();
-       doTest s ioa =
-               (putStrLn ("start test " ++ s))
-                       Prelude.>>
-               ioa
-                       Prelude.>>
-               (putStrLn ("end test " ++ s));
-
-       main :: IO ();
-       main =
-               (doTest "test_do failure"
-                       (test_do (Prelude.return ()) (Prelude.return Nothing))
-               )
-                       Prelude.>>
-               (doTest "test_do success"
-                       (test_do (Prelude.return ()) (Prelude.return (Just ())))
-               )
-                       Prelude.>>
-               (doTest "test_fromInteger"
-                       (putStrLn (Prelude.show test_fromInteger))
-               )
-                       Prelude.>>
-               (doTest "test_fromRational"
-                       (putStrLn (Prelude.show test_fromRational))
-               )
-                       Prelude.>>
-               (doTest "test_negate"
-                       (putStrLn (Prelude.show (test_negate 3)))
-               )
-                       Prelude.>>
-               (doTest "test_fromInteger_pattern 1"
-                       (putStrLn (test_fromInteger_pattern 1))
-               )
-                       Prelude.>>
-               (doTest "test_fromInteger_pattern (-2)"
-                       (putStrLn (test_fromInteger_pattern (-(2::Integer)::Integer)))
-               )
-                       Prelude.>>
-               (doTest "test_fromInteger_pattern 9"
-                       (putStrLn (test_fromInteger_pattern 9))
-               )
-                       Prelude.>>
-               (doTest "test_fromRational_pattern 0.5"
-                       (putStrLn (test_fromRational_pattern 0.5))
-               )
-                       Prelude.>>
-               (doTest "test_fromRational_pattern (-0.7)"
-                       (putStrLn (test_fromRational_pattern (-(0.7::Rational)::Rational)))
-               )
-                       Prelude.>>
-               (doTest "test_fromRational_pattern 1.7"
-                       (putStrLn (test_fromRational_pattern 1.7))
-               );
-       }
+        class HasReturn a where
+                {
+                return :: a;
+                };
+
+        class HasBind a where
+                {
+                (>>=) :: a;
+                };
+
+        class HasSeq a where
+                {
+                (>>) :: a;
+                };
+
+        class HasFail a where
+                {
+                fail :: a;
+                };
+
+        instance HasReturn (a -> IO a) where
+                {
+                return a = debugFunc "return" (Prelude.return a);
+                };
+
+        instance HasBind (IO a -> (a -> IO b) -> IO b) where
+                {
+                (>>=) ma amb = debugFunc ">>=" ((Prelude.>>=) ma amb);
+                };
+
+        instance HasSeq (IO a -> IO b -> IO b) where
+                {
+                (>>) ma mb = debugFunc ">>" ((Prelude.>>) ma mb);
+                };
+
+        instance HasFail (String -> IO a) where
+                {
+                fail s = debugFunc "fail" (Prelude.return undefined);
+        --      fail s = debugFunc "fail" (Prelude.fail s);
+                };
+
+        class HasFromInteger a where
+                {
+                fromInteger :: a;
+                };
+
+        instance HasFromInteger (Integer -> Integer) where
+                {
+                fromInteger a = a Prelude.+ a Prelude.+ a Prelude.+ a Prelude.+ a; -- five times
+                };
+
+        class HasFromRational a where
+                {
+                fromRational :: a;
+                };
+
+        instance HasFromRational (Rational -> Rational) where
+                {
+                fromRational a = a Prelude.+ a Prelude.+ a; -- three times
+                };
+
+        class HasNegate a where
+                {
+                negate :: a;
+                };
+
+        instance (b ~ (a -> a)) => HasNegate b where
+                {
+                negate a = a; -- don't actually negate
+                };
+
+        class HasMinus a where
+                {
+                (-) :: a;
+                };
+
+        instance (b ~ (a -> a -> a)) => HasMinus b where
+                {
+                (-) x y = y; -- changed function
+                };
+
+        test_do :: forall a b. IO a -> IO (Maybe b) -> IO b;
+        test_do f g = do
+                {
+                f;                      -- >>
+                Just (b::b) <- g;       -- >>= (and fail if g returns Nothing)
+                return b;               -- return
+                };
+
+        test_fromInteger :: Integer;
+        test_fromInteger = 27;
+
+        test_fromRational :: Rational;
+        test_fromRational = 31.5;
+
+        test_negate :: Integer -> Integer;
+        test_negate a = - a;
+
+        test_fromInteger_pattern :: Integer -> String;
+        test_fromInteger_pattern a@1 = "1=" ++ (Prelude.show a);
+        test_fromInteger_pattern a@(-2) = "(-2)=" ++ (Prelude.show a);
+        test_fromInteger_pattern (a + 7) = "(a + 7)=" ++ Prelude.show a;
+
+        test_fromRational_pattern :: Rational -> String;
+        test_fromRational_pattern a@0.5 = "0.5=" ++ (Prelude.show a);
+        test_fromRational_pattern a@(-0.7) = "(-0.7)=" ++ (Prelude.show a);
+        test_fromRational_pattern a = "_=" ++ (Prelude.show a);
+
+
+        doTest :: String -> IO a -> IO ();
+        doTest s ioa =
+                (putStrLn ("start test " ++ s))
+                        Prelude.>>
+                ioa
+                        Prelude.>>
+                (putStrLn ("end test " ++ s));
+
+        main :: IO ();
+        main =
+                (doTest "test_do failure"
+                        (test_do (Prelude.return ()) (Prelude.return Nothing))
+                )
+                        Prelude.>>
+                (doTest "test_do success"
+                        (test_do (Prelude.return ()) (Prelude.return (Just ())))
+                )
+                        Prelude.>>
+                (doTest "test_fromInteger"
+                        (putStrLn (Prelude.show test_fromInteger))
+                )
+                        Prelude.>>
+                (doTest "test_fromRational"
+                        (putStrLn (Prelude.show test_fromRational))
+                )
+                        Prelude.>>
+                (doTest "test_negate"
+                        (putStrLn (Prelude.show (test_negate 3)))
+                )
+                        Prelude.>>
+                (doTest "test_fromInteger_pattern 1"
+                        (putStrLn (test_fromInteger_pattern 1))
+                )
+                        Prelude.>>
+                (doTest "test_fromInteger_pattern (-2)"
+                        (putStrLn (test_fromInteger_pattern (-(2::Integer)::Integer)))
+                )
+                        Prelude.>>
+                (doTest "test_fromInteger_pattern 9"
+                        (putStrLn (test_fromInteger_pattern 9))
+                )
+                        Prelude.>>
+                (doTest "test_fromRational_pattern 0.5"
+                        (putStrLn (test_fromRational_pattern 0.5))
+                )
+                        Prelude.>>
+                (doTest "test_fromRational_pattern (-0.7)"
+                        (putStrLn (test_fromRational_pattern (-(0.7::Rational)::Rational)))
+                )
+                        Prelude.>>
+                (doTest "test_fromRational_pattern 1.7"
+                        (putStrLn (test_fromRational_pattern 1.7))
+                );
+        }
index 544de2f..23a4cfa 100644 (file)
@@ -2,8 +2,8 @@
 module ShouldCompile where
 
 import Rn037Help hiding( C )
-       -- C is the constructor, but we should
-       -- still be able to hide it
+        -- C is the constructor, but we should
+        -- still be able to hide it
 
 -- we should still be able to refer to the type constructor, though
 type Foo = T
index 0a2935c..6eaa1da 100644 (file)
@@ -2,7 +2,7 @@
 module ShouldCompile where
 
 import Rn037Help hiding( C )
-       -- C is the constructor, but we should
-       -- still be able to hide it
+        -- C is the constructor, but we should
+        -- still be able to hide it
 
 f x = Rn037Help.C
index c14d301..4bb2f66 100644 (file)
@@ -11,8 +11,8 @@ Compiling VersionGraphClient ( ./VersionGraphClient.hs, ./VersionGraphClient.o )
 
 View.hs:14:
      Couldn't match `VersionGraphClient' against `VersionGraphClient'
-       Expected type: VersionGraphClient
-       Inferred type: VersionGraphClient
+        Expected type: VersionGraphClient
+        Inferred type: VersionGraphClient
      In the `graphClient1' field of a record
      In the record construction: View {graphClient1 = graphClient}
 
@@ -23,9 +23,9 @@ However ghc without make has no problems.
 # ghc -c View.hs
 -}
 
--- | This module defines the fundamental structure of the (untyped) 
--- objects in a repository. 
--- 
+-- | This module defines the fundamental structure of the (untyped)
+-- objects in a repository.
+--
 -- We depend circularly on CodedValue.hs.  This module is compiled
 -- first and uses CodedValue.hi-boot.
 module View(
index 5514524..5eb076d 100644 (file)
@@ -1,6 +1,6 @@
 module RnAux017 where
-import Test    -- Import main module so there really is a loop
-               -- (avoid warning message)
+import Test     -- Import main module so there really is a loop
+                -- (avoid warning message)
 data Wibble = Wibble
 data Wobble = Wobble
 
index 5550fd3..970abfb 100644 (file)
@@ -1,7 +1,7 @@
 {-# OPTIONS_GHC -Werror -fwarn-unused-binds #-}
 
 -- Test Trac #3221: the constructors are used by the deriving
---                 clause, even though they are not exported
+--                  clause, even though they are not exported
 
 module T3221( Foo ) where
 
index 76dd993..20439d2 100644 (file)
@@ -3,12 +3,12 @@ module ShouldCompile where
 
 import Data.List ( reverse, sort )
 
-sort :: Int    -- Clashes with Data.List.sort, 
-sort = 4       -- but never used, so OK        
-       
+sort :: Int     -- Clashes with Data.List.sort,
+sort = 4        -- but never used, so OK
 
-reverse :: Int -- Clashes with Data.List.reverse, 
-reverse = 3    -- but the only uses are qualified
+
+reverse :: Int  -- Clashes with Data.List.reverse,
+reverse = 3     -- but the only uses are qualified
 
 x = ShouldCompile.reverse
 
index 454227c..1606e53 100644 (file)
@@ -4,10 +4,10 @@
 
 module ShouldCompile( t ) where
 
-f x = f x      -- Unused
+f x = f x       -- Unused
 
-g x = h x      -- Unused
+g x = h x       -- Unused
 h x = g x
 
-t x = t x      -- Used by export list
+t x = t x       -- Used by export list
 
index e88e842..e1b0113 100644 (file)
@@ -2,5 +2,5 @@
 
 module ShouldCompile (module M) where
 
- import Rn043_A as M   -- x, M.x
- import Rn043_B        -- x, Rn043_A.x
+ import Rn043_A as M    -- x, M.x
+ import Rn043_B         -- x, Rn043_A.x
index 83f6c5c..82c78b7 100644 (file)
@@ -1,7 +1,7 @@
 -- GHC 6.4.1 said
 --  test.hs:1:5:
---     Warning: accepting non-standard pattern guards 
---             (-fglasgow-exts to suppress this message)
+--     Warning: accepting non-standard pattern guards
+--              (-fglasgow-exts to suppress this message)
 --         [x <- ((1 * 2) + 3) * 4, undefined]
 -- Note the wrongly-parenthesised expression
 
@@ -10,4 +10,3 @@
 module ShouldCompile where
 
 main | x <- 1*2+3*4 = x
\ No newline at end of file
index b84b341..af4d9cc 100644 (file)
@@ -504,4 +504,4 @@ a495 = a496
 a496 = a497
 a497 = a498
 a498 = a499
-a499 = []      -- !!! ta-dah!!!
+a499 = []       -- !!! ta-dah!!!
index ab38722..bb65762 100644 (file)
@@ -1,5 +1,5 @@
 -- !!! rn001: super-simple set of bindings,
--- !!! incl wildcard pattern-bindings and *duplicates*
+-- !!!  incl wildcard pattern-bindings and *duplicates*
 
 x = []
 y = []
index 90a97f8..f8f01ee 100644 (file)
@@ -3,6 +3,6 @@ module Foo where
 
 f x = x
   where
-    a          = []
-    (b,c,a)    = ([],[],d)
-    [d,b,_]    = ([],a,[])
+    a           = []
+    (b,c,a)     = ([],[],d)
+    [d,b,_]     = ([],a,[])
index 196214a..f63fab5 100644 (file)
@@ -3,17 +3,17 @@
 module Test where
 
 class K a where
-       op1 :: a -> a -> a
-       op2 :: Int -> a
+        op1 :: a -> a -> a
+        op2 :: Int -> a
 
 instance K Int where
-       op1 a b = a+b
-       op2 x   = x
+        op1 a b = a+b
+        op2 x   = x
 
 instance K Bool where
-       op1 a b = a
-       -- Pick up the default decl for op2
-       
+        op1 a b = a
+        -- Pick up the default decl for op2
+
 instance K [a] where
-       op3 a = a       -- Oops!  Isn't a class op of K
-       
+        op3 a = a       -- Oops!  Isn't a class op of K
+
index 20f9934..1f20a7e 100644 (file)
@@ -11,7 +11,7 @@ data Token
      |  TokIs
      |  TokDeref
      |  TokFind
-     |  TokLiteral             -- Duplicated!
+     |  TokLiteral              -- Duplicated!
      |  TokThe
 
       deriving Show
index 327a9d6..9090e23 100644 (file)
@@ -2,16 +2,16 @@ module ShouldFail where
 
 -- !!! Precedence of unary negation
 
-f1 x y = x + -y        -- Fails
-f2 x y = x * -y                -- Fails
+f1 x y = x + -y         -- Fails
+f2 x y = x * -y         -- Fails
 
 
-f3 x y = -x + y                -- OK: means  (-x) + y
-                       -- since - is left associative
+f3 x y = -x + y         -- OK: means  (-x) + y
+                        -- since - is left associative
 
-f4 x y = - x*y         -- OK: means -(x*y)
-                       -- since - binds less tightly than *
+f4 x y = - x*y          -- OK: means -(x*y)
+                        -- since - binds less tightly than *
 
-f5 x y = x >= -y       -- OK means x >= (-y)
+f5 x y = x >= -y        -- OK means x >= (-y)
 
 
index c6efc4d..c76f892 100644 (file)
@@ -17,6 +17,6 @@ unionSetB (s1 :: Set a) s2 = unionSets s1 s2
 {- In GHC 4.04 this gave the terrible message:
 
     None of the type variable(s) in the constraint `Eq a'
-       appears in the type `Set a -> Set a -> Set a'
+        appears in the type `Set a -> Set a -> Set a'
     In the type signature for `unionSets'
 -}
index bf7c4a2..07f804b 100644 (file)
@@ -1,4 +1,4 @@
--- !!! Check that type signatures and pragmas that 
+-- !!! Check that type signatures and pragmas that
 -- !!! don't have a "parent" are correctly reported
 
 module ShouldFail where
@@ -8,8 +8,8 @@ f :: Int -> Int
 {-# INLINE f #-}
 
 -- Nested test
-h :: Int -> Int        -- This one is ok
+h :: Int -> Int -- This one is ok
 h x = x
     where
-      g :: Int -> Int  -- Bogus
+      g :: Int -> Int   -- Bogus
 
index 2bcc5a8..1f0052d 100644 (file)
@@ -4,13 +4,13 @@ module SafeLang11_B ( Class(..), mkSimpleClass ) where
 import Language.Haskell.TH
 
 class Class a where
-       c :: a
+        c :: a
 
 mkSimpleClass :: Name -> Q [Dec]
 mkSimpleClass name = do
-       TyConI (DataD [] dname [] Nothing cs _) <- reify name
-       ((NormalC conname []):_) <- return cs
-       ClassI (ClassD [] cname [_] [] [SigD mname _]) _ <- reify ''Class
-       return [InstanceD Nothing [] (AppT (ConT cname) (ConT dname)) [FunD mname
+        TyConI (DataD [] dname [] Nothing cs _) <- reify name
+        ((NormalC conname []):_) <- return cs
+        ClassI (ClassD [] cname [_] [] [SigD mname _]) _ <- reify ''Class
+        return [InstanceD Nothing [] (AppT (ConT cname) (ConT dname)) [FunD mname
             [Clause [] (NormalB (ConE conname)) []]]]
 
index 1a483da..7219b7a 100644 (file)
@@ -5,13 +5,13 @@ module SafeLang12_B ( Class(..), mkSimpleClass ) where
 import Language.Haskell.TH
 
 class Class a where
-       c :: a
+        c :: a
 
 mkSimpleClass :: Name -> Q [Dec]
 mkSimpleClass name = do
-       TyConI (DataD [] dname [] Nothing cs _) <- reify name
-       ((NormalC conname []):_) <- return cs
-       ClassI (ClassD [] cname [_] [] [SigD mname _]) _ <- reify ''Class
-       return [InstanceD Nothing [] (AppT (ConT cname) (ConT dname)) [FunD mname
+        TyConI (DataD [] dname [] Nothing cs _) <- reify name
+        ((NormalC conname []):_) <- return cs
+        ClassI (ClassD [] cname [_] [] [SigD mname _]) _ <- reify ''Class
+        return [InstanceD Nothing [] (AppT (ConT cname) (ConT dname)) [FunD mname
             [Clause [] (NormalB (ConE conname)) []]]]