Commit e27d450b authored by simonpj's avatar simonpj
Browse files

[project @ 2005-01-27 10:45:47 by simonpj]

          Replace hi-boot files with hs-boot files

This major commit completely re-organises the way that recursive modules
are dealt with.

  * It should have NO EFFECT if you do not use recursive modules

  * It is a BREAKING CHANGE if you do

====== Warning: .hi-file format has changed, so if you are
======		updating into an existing HEAD build, you'll
======		need to make clean and re-make

The details:  [documentation still to be done]

* Recursive loops are now broken with Foo.hs-boot (or Foo.lhs-boot),
  not Foo.hi-boot

* An hs-boot files is a proper source file.  It is compiled just like
  a regular Haskell source file:
	ghc Foo.hs		generates Foo.hi, Foo.o
	ghc Foo.hs-boot		generates Foo.hi-boot, Foo.o-boot

* hs-boot files are precisely a subset of Haskell. In particular:
	- they have the same import, export, and scoping rules
	- errors (such as kind errors) in hs-boot files are checked
  You do *not* need to mention the "original" name of something in
  an hs-boot file, any more than you do in any other Haskell module.

* The Foo.hi-boot file generated by compiling Foo.hs-boot is a machine-
  generated interface file, in precisely the same format as Foo.hi

* When compiling Foo.hs, its exports are checked for compatibility with
  Foo.hi-boot (previously generated by compiling Foo.hs-boot)

* The dependency analyser (ghc -M) knows about Foo.hs-boot files, and
  generates appropriate dependencies.  For regular source files it
	Foo.o : Foo.hs
	Foo.o : Baz.hi		-- Foo.hs imports Baz
	Foo.o : Bog.hi-boot	-- Foo.hs source-imports Bog

  For a hs-boot file it generates similar dependencies
	Bog.o-boot : Bog.hs-boot
	Bog.o-boot : Nib.hi	-- Bog.hs-boto imports Nib

* ghc -M is also enhanced to use the compilation manager dependency
  chasing, so that
	ghc -M Main
  will usually do the job.  No need to enumerate all the source files.

* The -c flag is no longer a "compiler mode". It simply means "omit the
  link step", and synonymous with -no-link.
parent a65cba78
{-# OPTIONS -fno-implicit-prelude #-}
module Data.Dynamic where
data Dynamic
......@@ -42,7 +42,6 @@ module Foreign.Ptr (
import GHC.Ptr
import GHC.IOBase
import GHC.Err
import GHC.Base
import GHC.Num
import GHC.List
{-# OPTIONS -fno-implicit-prelude #-}
-- PrelErr.hi-boot
-- This hand-written interface file is the initial bootstrap version
-- for PrelErr.hi.
-- It doesn't need to give "error" a type signature,
-- because it's wired into the compiler
-- Ghc.Err.hs-boot
module GHC.Err where
module GHC.Err( error, divZeroError ) where
-- We can't give an accurate type for error, because it mentions an open
-- type variable, but fortunately it doesn't matter what type we
-- give here because the compiler will use its wired-in version. But we have
-- The type signature for 'error' is a gross hack.
-- First, we can't give an accurate type for error, because it mentions
-- an open type variable.
-- Second, we can't even say error :: [Char] -> a, because Char is defined
-- in GHC.Base, and that would make Err.lhs-boot mutually recursive
-- with GHC.Base.
-- Fortunately it doesn't matter what type we give here because the
-- compiler will use its wired-in version. But we have
-- to mention 'error' so that it gets exported from this .hi-boot
-- file.
error :: GHC.Base.String -> a
error :: a
-- divide by zero is needed quite early
divZeroError :: a
......@@ -27,7 +27,6 @@ module GHC.Num where
import {-# SOURCE #-} GHC.Err
import GHC.Base
import GHC.List
import GHC.Enum
import GHC.Show
module GHC.Unicode where
isAscii :: GHC.Base.Char -> GHC.Base.Bool
isLatin1 :: GHC.Base.Char -> GHC.Base.Bool
isControl :: GHC.Base.Char -> GHC.Base.Bool
isPrint :: GHC.Base.Char -> GHC.Base.Bool
isSpace :: GHC.Base.Char -> GHC.Base.Bool
isUpper :: GHC.Base.Char -> GHC.Base.Bool
isLower :: GHC.Base.Char -> GHC.Base.Bool
isAlpha :: GHC.Base.Char -> GHC.Base.Bool
isDigit :: GHC.Base.Char -> GHC.Base.Bool
isOctDigit :: GHC.Base.Char -> GHC.Base.Bool
isHexDigit :: GHC.Base.Char -> GHC.Base.Bool
isAlphaNum :: GHC.Base.Char -> GHC.Base.Bool
{-# OPTIONS -fno-implicit-prelude #-}
module GHC.Unicode where
import GHC.Base( Char, Bool )
isAscii :: Char -> Bool
isLatin1 :: Char -> Bool
isControl :: Char -> Bool
isPrint :: Char -> Bool
isSpace :: Char -> Bool
isUpper :: Char -> Bool
isLower :: Char -> Bool
isAlpha :: Char -> Bool
isDigit :: Char -> Bool
isOctDigit :: Char -> Bool
isHexDigit :: Char -> Bool
isAlphaNum :: Char -> Bool
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment