[move various things around in the standard libraries to clean things up and make compilation go faster.
John Meacham <john@repetae.net>**20060929234620] hunk ./FrontEnd/HsSyn.hs 349
-tuple_con_name i      = Qual prelude_mod (HsIdent ("("++replicate i ','++")"))
+--tuple_con_name i      = Qual prelude_mod (HsIdent ("("++replicate i ','++")"))
+tuple_con_name i      = Qual (Module "Jhc.Basics") (HsIdent ("("++replicate i ','++")"))
hunk ./FrontEnd/Infix.hs 60
-unqualModule :: Module              -- The module which unqualified operators are associated with.
-unqualModule = Module "Prelude"
hunk ./FrontEnd/Rename.hs 171
-            | Just _ <- V.fromTupname hsName, Module "Prelude" <- mod
+            | Just _ <- V.fromTupname hsName, Module "Jhc.Basics" <- mod
hunk ./FrontEnd/Representation.hs 241
-    fromTupname (Qual (Module "Prelude") (HsIdent xs))  = fromTupname xs
+    fromTupname (Qual (Module "Jhc.Basics") (HsIdent xs))  = fromTupname xs
hunk ./FrontEnd/Representation.hs 245
-    toTuple n = (Qual (Module "Prelude") (HsIdent $ toTuple n))
+    toTuple n = (Qual (Module "Jhc.Basics") (HsIdent $ toTuple n))
hunk ./Name/Names.hs 62
-dc_Cons = toName DataConstructor ("Prelude",":")
-dc_EmptyList = toName DataConstructor ("Prelude","[]")
---dc_False = toName DataConstructor ("Prelude","False")
+dc_Cons = toName DataConstructor ("Jhc.Basics",":")
+dc_EmptyList = toName DataConstructor ("Jhc.Basics","[]")
hunk ./Name/Names.hs 66
---dc_True = toName DataConstructor ("Prelude","True")
hunk ./Name/Names.hs 80
-tc_List = toName TypeConstructor ("Prelude","[]")
+tc_List = toName TypeConstructor ("Jhc.Basics","[]")
hunk ./Name/Names.hs 98
-v_concatMap = toName Val ("Jhc.List","concatMap")
-v_map = toName Val ("Prelude","map")
+v_concatMap = toName Val ("Jhc.Basics","concatMap")
+v_map = toName Val ("Jhc.Basics","map")
hunk ./Name/Names.hs 102
-v_foldr = toName Val ("Jhc.List","foldr")
+v_foldr = toName Val ("Jhc.Basics","foldr")
hunk ./Name/Names.hs 110
-    func_concatMap = toName Val ("Jhc.List","concatMap"),
+    func_concatMap = toName Val ("Jhc.Basics","concatMap"),
hunk ./Name/VConsts.hs 60
-    fromTupname ("Prelude",n) = fromTupname n
+    fromTupname ("Jhc.Basics",n) = fromTupname n
hunk ./Name/VConsts.hs 71
-    toTuple n = ("Prelude",toTuple n)
+    toTuple n = ("Jhc.Basics",toTuple n)
hunk ./data/primitives.txt 5
-Prelude.Char, HsChar, char, UINT32_MAX, 0
-Prelude.Int, int, int, INT_MAX, INT_MIN
+Jhc.Basics.Char, HsChar, char, UINT32_MAX, 0
+Data.Int.Int, int, int, INT_MAX, INT_MIN
hunk ./data/primitives.txt 8
-Prelude.Integer, intmax_t, int, INTMAX_MAX, INTMAX_MIN
+Jhc.Basics.Integer, intmax_t, int, INTMAX_MAX, INTMAX_MIN
hunk ./data/primitives.txt 25
-Prelude.Float, float, float, FLT_MAX, FLT_MIN
-Prelude.Double, double, float, DBL_MAX, DBL_MIN
+Jhc.Float.Float, float, float, FLT_MAX, FLT_MIN
+Jhc.Float.Double, double, float, DBL_MAX, DBL_MIN
hunk ./lib/base/Control/Monad.hs 12
+
+import Jhc.Basics
hunk ./lib/base/Data/Int.hs 1
+{-# OPTIONS_JHC -N #-}
hunk ./lib/base/Data/Int.hs 5
+data Int
hunk ./lib/base/Foreign.hs 1
-{-# OPTIONS_GHC -fno-implicit-prelude #-}
+{-# OPTIONS_JHC -N #-}
hunk ./lib/base/Jhc/Addr.hs 23
+
hunk ./lib/base/Jhc/Addr.hs 25
+plusAddr :: Addr -> Int -> Addr
addfile ./lib/base/Jhc/Basics.hs
hunk ./lib/base/Jhc/Basics.hs 1
+{-# OPTIONS_JHC -N #-}
+module Jhc.Basics where
+
+
+type String = [Char]
+data Integer
+data Char
+
+
+data [] a =  a : ([] a) | []
+    -- odd syntax, so we write instances manually
+
+data (,) a b = (,) a b
+data (,,) a b c = (,,) a b c
+data (,,,) a b c d = (,,,) a b c d
+data (,,,,) a b c d e = (,,,,) a b c d e
+data (,,,,,) a b c d e f = (,,,,,) a b c d e f
+data (,,,,,,) a b c d e f g = (,,,,,,) a b c d e f g
+data (,,,,,,,) a b c d e f g h = (,,,,,,,) a b c d e f g h
+data (,,,,,,,,) a b c d e f g h i = (,,,,,,,,) a b c d e f g h i
+
+
+
+------------------------
+-- the basic combinators
+------------------------
+
+{-# SUPERINLINE id, const, (.), ($), ($!), flip #-}
+
+id x = x
+const x _ = x
+f . g = \x -> f (g x)
+f $ x = f x
+f $! x = x `seq` f x
+flip f x y = f y x
+
+-- asTypeOf is a type-restricted version of const.  It is usually used
+-- as an infix operator, and its typing forces its first argument
+-- (which is usually overloaded) to have the same type as the second.
+
+{-# SUPERINLINE asTypeOf #-}
+asTypeOf         :: a -> a -> a
+asTypeOf         =  const
+
+
+{-# INLINE seq #-}
+foreign import primitive seq :: a -> b -> b
+
+
+--------------------
+-- some tuple things
+--------------------
+
+{-# INLINE fst, snd #-}
+fst (a,b) = a
+snd (a,b) = b
+
+uncurry f (x,y) = f x y
+curry f x y = f (x,y)
+
+
+
+----------------------
+-- Basic list routines
+----------------------
+
+
+-- iterate f x returns an infinite list of repeated applications of f to x:
+-- iterate f x == [x, f x, f (f x), ...]
+
+iterate          :: (a -> a) -> a -> [a]
+iterate f x      =  x : iterate f (f x)
+
+-- repeat x is an infinite list, with x the value of every element.
+
+repeat           :: a -> [a]
+repeat x         =  xs where xs = x:xs
+
+
+
+-- Map and append
+
+map :: (a -> b) -> [a] -> [b]
+map f xs = go xs where
+    go [] = []
+    go (x:xs) = f x : go xs
+
+
+
+infixr 5  ++
+
+(++) :: [a] -> [a] -> [a]
+[]     ++ ys = ys
+(x:xs) ++ ys = x : (xs ++ ys)
+
+
+foldl            :: (a -> b -> a) -> a -> [b] -> a
+foldl f z []     =  z
+foldl f z (x:xs) =  foldl f (f z x) xs
+
+
+scanl            :: (a -> b -> a) -> a -> [b] -> [a]
+scanl f q xs     =  q : (case xs of
+                            []   -> []
+                            x:xs -> scanl f (f q x) xs)
+
+
+
+reverse          :: [a] -> [a]
+--reverse          =  foldl (flip (:)) []
+reverse l =  rev l [] where
+    rev []     a = a
+    rev (x:xs) a = rev xs (x:a)
+
+
+-- zip takes two lists and returns a list of corresponding pairs.  If one
+-- input list is short, excess elements of the longer list are discarded.
+-- zip3 takes three lists and returns a list of triples.  Zips for larger
+-- tuples are in the List library
+
+
+zip              :: [a] -> [b] -> [(a,b)]
+zip              =  zipWith (\a b -> (a,b))
+
+-- The zipWith family generalises the zip family by zipping with the
+-- function given as the first argument, instead of a tupling function.
+-- For example, zipWith (+) is applied to two lists to produce the list
+-- of corresponding sums.
+
+zipWith          :: (a->b->c) -> [a]->[b]->[c]
+zipWith z (a:as) (b:bs)
+                 =  z a b : zipWith z as bs
+zipWith _ _ _    =  []
+
+
+concat :: [[a]] -> [a]
+concat [] = []
+concat (x:xs) = case x of
+    [] -> concat xs
+    (y:ys) -> y:concat (ys:xs)
+
+
+concatMap :: (a -> [b]) -> [a] -> [b]
+concatMap f xs = g xs where
+    g [] = []
+    g (x:xs) = f x ++ g xs
+
+
+foldr :: (a -> b -> b) -> b -> [a] -> b
+foldr k z [] = z
+foldr k z (x:xs) = k x (foldr k z xs)
addfile ./lib/base/Jhc/Float.hs
hunk ./lib/base/Jhc/Float.hs 1
+{-# OPTIONS_JHC -N #-}
+module Jhc.Float where
+
+data Float
+data Double
+
+
hunk ./lib/base/Jhc/List.hs 3
+import Jhc.Basics
+
hunk ./lib/base/Jhc/List.hs 10
-foldr :: (a -> b -> b) -> b -> [a] -> b
-foldr k z [] = z
-foldr k z (x:xs) = k x (foldr k z xs)
hunk ./lib/base/Jhc/List.hs 91
-concat :: [[a]] -> [a]
-concat [] = []
-concat (x:xs) = case x of
-    [] -> concat xs
-    (y:ys) -> y:concat (ys:xs)
-
-
-concatMap :: (a -> [b]) -> [a] -> [b]
-concatMap f xs = g xs where
-    g [] = []
-    g (x:xs) = f x ++ g xs
hunk ./lib/base/Prelude.hs 23
+    module Jhc.Basics,
+    module Jhc.Float,
+    Int(),
+
hunk ./lib/base/Prelude.hs 31
+
+import Jhc.Basics
+import Jhc.Float
+import Data.Int(Int())
+
hunk ./lib/base/Prelude.hs 67
-data [] a =  a : ([] a) | []
-    -- odd syntax, so we write instances manually
hunk ./lib/base/Prelude.hs 72
-data (,) a b = (,) a b
-data (,,) a b c = (,,) a b c
-data (,,,) a b c d = (,,,) a b c d
-data (,,,,) a b c d e = (,,,,) a b c d e
-data (,,,,,) a b c d e f = (,,,,,) a b c d e f
-data (,,,,,,) a b c d e f g = (,,,,,,) a b c d e f g
-data (,,,,,,,) a b c d e f g h = (,,,,,,,) a b c d e f g h
-data (,,,,,,,,) a b c d e f g h i = (,,,,,,,,) a b c d e f g h i
-
-type String = [Char]
-data Integer
-data Int
-data Char
-data Float
-data Double
hunk ./lib/base/Prelude.hs 420
-{-# SUPERINLINE id, const, (.), ($), ($!), flip #-}
-
-id x = x
-const x _ = x
-f . g = \x -> f (g x)
-f $ x = f x
-f $! x = x `seq` f x
-flip f x y = f y x
hunk ./lib/base/Prelude.hs 454
-{-# INLINE fst, snd #-}
-fst (a,b) = a
-snd (a,b) = b
-
-
-
-
hunk ./lib/base/Prelude.hs 461
--- asTypeOf is a type-restricted version of const.  It is usually used
--- as an infix operator, and its typing forces its first argument
--- (which is usually overloaded) to have the same type as the second.
-
-{-# SUPERINLINE asTypeOf #-}
-asTypeOf         :: a -> a -> a
-asTypeOf         =  const
-
hunk ./lib/base/Prelude.hs 479
-infixr 5  ++
hunk ./lib/base/Prelude.hs 481
--- Map and append
-
-map :: (a -> b) -> [a] -> [b]
-map f xs = go xs where
-    go [] = []
-    go (x:xs) = f x : go xs
-
---map f []     = []
---map f (x:xs) = f x : map f xs
-
-
-(++) :: [a] -> [a] -> [a]
-[]     ++ ys = ys
-(x:xs) ++ ys = x : (xs ++ ys)
hunk ./lib/base/Prelude.hs 568
-foldl            :: (a -> b -> a) -> a -> [b] -> a
-foldl f z []     =  z
-foldl f z (x:xs) =  foldl f (f z x) xs
hunk ./lib/base/Prelude.hs 575
-scanl            :: (a -> b -> a) -> a -> [b] -> [a]
-scanl f q xs     =  q : (case xs of
-                            []   -> []
-                            x:xs -> scanl f (f q x) xs)
-
hunk ./lib/base/Prelude.hs 605
--- iterate f x returns an infinite list of repeated applications of f to x:
--- iterate f x == [x, f x, f (f x), ...]
-
-iterate          :: (a -> a) -> a -> [a]
-iterate f x      =  x : iterate f (f x)
-
--- repeat x is an infinite list, with x the value of every element.
-
-repeat           :: a -> [a]
-repeat x         =  xs where xs = x:xs
hunk ./lib/base/Prelude.hs 711
-reverse          :: [a] -> [a]
---reverse          =  foldl (flip (:)) []
-reverse l =  rev l [] where
-    rev []     a = a
-    rev (x:xs) a = rev xs (x:a)
hunk ./lib/base/Prelude.hs 766
--- zip takes two lists and returns a list of corresponding pairs.  If one
--- input list is short, excess elements of the longer list are discarded.
--- zip3 takes three lists and returns a list of triples.  Zips for larger
--- tuples are in the List library
-
-
-zip              :: [a] -> [b] -> [(a,b)]
-zip              =  zipWith (\a b -> (a,b))
-
hunk ./lib/base/Prelude.hs 770
--- The zipWith family generalises the zip family by zipping with the
--- function given as the first argument, instead of a tupling function.
--- For example, zipWith (+) is applied to two lists to produce the list
--- of corresponding sums.
-
-
-zipWith          :: (a->b->c) -> [a]->[b]->[c]
-zipWith z (a:as) (b:bs)
-                 =  z a b : zipWith z as bs
-zipWith _ _ _    =  []
hunk ./lib/base/Prelude.hs 798
-{-# INLINE seq #-}
-
-foreign import primitive seq :: a -> b -> b
hunk ./lib/base/Prelude.hs 875
-uncurry f (x,y) = f x y
-curry f x y = f (x,y)
hunk ./lib/base/System/Info.hs 1
+{-# OPTIONS_JHC -N #-}
hunk ./lib/base/base.cabal 38
+                 Jhc.Basics,
+                 Jhc.Float