This project is mirrored from https://gitlab.haskell.org/ghc/ghc.git.
Pull mirroring failed .
Repository mirroring has been paused due to too many failed attempts. It can be resumed by a project maintainer.
Last successful update .
Repository mirroring has been paused due to too many failed attempts. It can be resumed by a project maintainer.
Last successful update .
 10 Nov, 2006 1 commit


simonpj@microsoft.com authored

 24 Oct, 2006 1 commit


andy@galois.com authored
This large checkin is the new ghc version of Haskell Program Coverage, an expressionlevel coverage tool for Haskell. Parts:  Hpc.[ch]  small runtime support for Hpc; reading/writing *.tix files.  Coverage.lhs  Annotates the HsSyn with coverage tickboxes.  New Note's in Core,  TickBox  ticked on entry to subexpression  BinaryTickBox  ticked on exit to subexpression, depending  on the boolean result.  New Stg level TickBox (no BinaryTickBoxes, though) You can run the coverage tool with fhpc at compile time. Main must be compiled with fhpc.

 11 Oct, 2006 1 commit


Simon Marlow authored

 10 Oct, 2006 1 commit


Simon Marlow authored
See test rn003

 05 Oct, 2006 1 commit


davve@dtek.chalmers.se authored

 29 Sep, 2006 1 commit


simonpj@microsoft.com authored

 20 Sep, 2006 1 commit


chak@cse.unsw.edu.au. authored
Mon Sep 18 14:43:22 EDT 2006 Manuel M T Chakravarty <chak@cse.unsw.edu.au> * Complete the evidence generation for GADTs Sat Aug 5 21:39:51 EDT 2006 Manuel M T Chakravarty <chak@cse.unsw.edu.au> * Complete the evidence generation for GADTs Thu Jul 13 17:18:07 EDT 2006 simonpj@microsoft.com This patch completes FC evidence generation for GADTs. It doesn't work properly yet, because part of the compiler thinks (t1 :=: t2) => t3 is represented with FunTy/PredTy, while the rest thinks it's represented using ForAllTy. Once that's done things should start to work.

 15 Sep, 2006 1 commit


chak@cse.unsw.edu.au. authored
Fri Aug 4 15:59:09 EDT 2006 Manuel M T Chakravarty <chak@cse.unsw.edu.au> * Massive patch for the first months work adding System FC to GHC #14 Broken up massive patch =chak Original log message: This is (sadly) all done in one patch to avoid Darcs bugs. It's not complete work... more FC stuff to come. A compiler using just this patch will fail dismally.

 06 Aug, 2006 1 commit


chak@cse.unsw.edu.au. authored
Wed Jul 26 06:00:53 EDT 2006 kevind@bu.edu

 07 Apr, 2006 1 commit


Simon Marlow authored
Most of the other users of the fptools build system have migrated to Cabal, and with the move to darcs we can now flatten the source tree without losing history, so here goes. The main change is that the ghc/ subdir is gone, and most of what it contained is now at the top level. The build system now makes no pretense at being multiproject, it is just the GHC build system. No doubt this will break many things, and there will be a period of instability while we fix the dependencies. A straightforward build should work, but I haven't yet fixed binary/source distributions. Changes to the Building Guide will follow, too.

 03 Feb, 2006 1 commit


simonpj@microsoft.com authored
This commit adds bangpatterns, enabled by fglasgowexts or fbangpatterns diabled by fnobangpatterns The idea is described here http://haskell.galois.com/cgibin/haskellprime/trac.cgi/wiki/BangPatterns

 02 Feb, 2006 1 commit


simonpj@microsoft.com authored
We must record the type of a TuplePat after typechecking, just like a ConPatOut, so that desugaring works correctly for GADTs. See comments with the declaration of HsPat.TuplePat, and test gadt15

 30 Jan, 2006 1 commit


simonpj@microsoft.com authored
Avoiding identity coercions is a Good Thing generally, but it turns out that the desugarer has trouble recognising 'otherwise' and 'True' guards if they are wrapped in an identity coercion; and that leads to bogus overlap warnings.

 25 Jan, 2006 1 commit


simonpj@microsoft.com authored
This very large commit adds impredicativity to GHC, plus numerous other small things. *** WARNING: I have compiled all the libraries, and *** a stage2 compiler, and everything seems *** fine. But don't grab this patch if you *** can't tolerate a hiccup if something is *** broken. The big picture is this: a) GHC handles impredicative polymorphism, as described in the "Boxy types: type inference for higherrank types and impredicativity" paper b) GHC handles GADTs in the new simplified (and very sligtly less epxrssive) way described in the "Simple unificationbased type inference for GADTs" paper But there are lots of smaller changes, and since it was preDarcs they are not individually recorded. Some things to watch out for: c) The story on lexicallyscoped type variables has changed, as per my email. I append the story below for completeness, but I am still not happy with it, and it may change again. In particular, the new story does not allow a patternbound scoped type variable to be wobbly, so (\(x::[a]) > ...) is usually rejected. This is more restrictive than before, and we might loosen up again. d) A consequence of adding impredicativity is that GHC is a bit less gung ho about converting automatically between (ty1 > forall a. ty2) and (forall a. ty1 > ty2) In particular, you may need to etaexpand some functions to make typechecking work again. Furthermore, functions are now invariant in their argument types, rather than being contravariant. Again, the main consequence is that you may occasionally need to etaexpand function arguments when using higherrank polymorphism. Please test, and let me know of any hiccups Scoped type variables in GHC ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ January 2006 0) Terminology. A *pattern binding* is of the form pat = rhs A *function binding* is of the form f pat1 .. patn = rhs A binding of the formm var = rhs is treated as a (degenerate) *function binding*. A *declaration type signature* is a separate type signature for a letbound or wherebound variable: f :: Int > Int A *pattern type signature* is a signature in a pattern: \(x::a) > x f (x::a) = x A *result type signature* is a signature on the result of a function definition: f :: forall a. [a] > a head (x:xs) :: a = x The form x :: a = rhs is treated as a (degnerate) function binding with a result type signature, not as a pattern binding. 1) The main invariants: A) A lexicallyscoped type variable always names a (rigid) type variable (not an arbitrary type). THIS IS A CHANGE. Previously, a scoped type variable named an arbitrary *type*. B) A type signature always describes a rigid type (since its free (scoped) type variables name rigid type variables). This is also a change, a consequence of (A). C) Distinct lexicallyscoped type variables name distinct rigid type variables. This choice is open; 2) Scoping 2(a) If a declaration type signature has an explicit forall, those type variables are brought into scope in the right hand side of the corresponding binding (plus, for function bindings, the patterns on the LHS). f :: forall a. a > [a] f (x::a) = [x :: a, x] Both occurences of 'a' in the second line are bound by the 'forall a' in the first line A declaration type signature *without* an explicit toplevel forall is implicitly quantified over all the type variables that are mentioned in the type but not already in scope. GHC's current rule is that this implicit quantification does *not* bring into scope any new scoped type variables. f :: a > a f x = ...('a' is not in scope here)... This gives compatibility with Haskell 98 2(b) A pattern type signature implicitly brings into scope any type variables mentioned in the type that are not already into scope. These are called *patternbound type variables*. g :: a > a > [a] g (x::a) (y::a) = [y :: a, x] The pattern type signature (x::a) brings 'a' into scope. The 'a' in the pattern (y::a) is bound, as is the occurrence on the RHS. A pattern type siganture is the only way you can bring existentials into scope. data T where MkT :: forall a. a > (a>Int) > T f x = case x of MkT (x::a) f > f (x::a) 2a) QUESTION class C a where op :: forall b. b>a>a instance C (T p q) where op = <rhs> Clearly p,q are in scope in <rhs>, but is 'b'? Not at the moment. Nor can you add a type signature for op in the instance decl. You'd have to say this: instance C (T p q) where op = let op' :: forall b. ... op' = <rhs> in op' 3) A patternbound type variable is allowed only if the pattern's expected type is rigid. Otherwise we don't know exactly *which* skolem the scoped type variable should be bound to, and that means we can't do GADT refinement. This is invariant (A), and it is a big change from the current situation. f (x::a) = x  NO; pattern type is wobbly g1 :: b > b g1 (x::b) = x  YES, because the pattern type is rigid g2 :: b > b g2 (x::c) = x  YES, same reason h :: forall b. b > b h (x::b) = x  YES, but the inner b is bound k :: forall b. b > b k (x::c) = x  NO, it can't be both b and c 3a) You cannot give different names for the same type variable in the same scope (Invariant (C)): f1 :: p > p > p  NO; because 'a' and 'b' would be f1 (x::a) (y::b) = (x::a)  bound to the same type variable f2 :: p > p > p  OK; 'a' is bound to the type variable f2 (x::a) (y::a) = (x::a)  over which f2 is quantified  NB: 'p' is not lexically scoped f3 :: forall p. p > p > p  NO: 'p' is now scoped, and is bound to f3 (x::a) (y::a) = (x::a)  to the same type varialble as 'a' f4 :: forall p. p > p > p  OK: 'p' is now scoped, and its occurences f4 (x::p) (y::p) = (x::p)  in the patterns are bound by the forall 3b) You can give a different name to the same type variable in different disjoint scopes, just as you can (if you want) give diferent names to the same value parameter g :: a > Bool > Maybe a g (x::p) True = Just x :: Maybe p g (y::q) False = Nothing :: Maybe q 3c) Scoped type variables respect alpha renaming. For example, function f2 from (3a) above could also be written: f2' :: p > p > p f2' (x::b) (y::b) = x::b where the scoped type variable is called 'b' instead of 'a'. 4) Result type signatures obey the same rules as pattern types signatures. In particular, they can bind a type variable only if the result type is rigid f x :: a = x  NO g :: b > b g x :: b = x  YES; binds b in rhs 5) A *pattern type signature* in a *pattern binding* cannot bind a scoped type variable (x::a, y) = ...  Legal only if 'a' is already in scope Reason: in type checking, the "expected type" of the LHS pattern is always wobbly, so we can't bind a rigid type variable. (The exception would be for an existential type variable, but existentials are not allowed in pattern bindings either.) Even this is illegal f :: forall a. a > a f x = let ((y::b)::a, z) = ... in Here it looks as if 'b' might get a rigid binding; but you can't bind it to the same skolem as a. 6) Explicitlyforall'd type variables in the *declaration type signature(s)* for a *pattern binding* do not scope AT ALL. x :: forall a. a>a  NO; the forall a does Just (x::a>a) = Just id  not scope at all y :: forall a. a>a Just y = Just (id :: a>a)  NO; same reason THIS IS A CHANGE, but one I bet that very few people will notice. Here's why: strange :: forall b. (b>b,b>b) strange = (id,id) x1 :: forall a. a>a y1 :: forall b. b>b (x1,y1) = strange This is legal Haskell 98 (modulo the forall). If both 'a' and 'b' both scoped over the RHS, they'd get unified and so cannot stand for distinct type variables. One could *imagine* allowing this: x2 :: forall a. a>a y2 :: forall a. a>a (x2,y2) = strange using the very same type variable 'a' in both signatures, so that a single 'a' scopes over the RHS. That seems defensible, but odd, because though there are two type signatures, they introduce just *one* scoped type variable, a. 7) Possible extension. We might consider allowing \(x :: [ _ ]) > <expr> where "_" is a wild card, to mean "x has type list of something", without naming the something.

 06 Jan, 2006 1 commit


simonmar authored
Add support for UTF8 source files GHC finally has support for full Unicode in source files. Source files are now assumed to be UTF8 encoded, and the full range of Unicode characters can be used, with classifications recognised using the implementation from Data.Char. This incedentally means that only the stage2 compiler will recognise Unicode in source files, because I was too lazy to port the unicode classifier code into libcompat. Additionally, the following synonyms for keywords are now recognised: forall symbol (U+2200) forall right arrow (U+2192) > left arrow (U+2190) < horizontal ellipsis (U+22EF) .. there are probably more things we could add here. This will break some source files if Latin1 characters are being used. In most cases this should result in a UTF8 decoding error. Later on if we want to support more encodings (perhaps with a pragma to specify the encoding), I plan to do it by recoding into UTF8 before parsing. Internally, there were some pretty big changes:  FastStrings are now stored in UTF8  Zencoding has been moved right to the back end. Previously we used to Zencode every identifier on the way in for simplicity, and only decode when we needed to show something to the user. Instead, we now keep every string in its UTF8 encoding, and Zencode right before printing it out. To avoid Zencoding the same string multiple times, the Zencoding is cached inside the FastString the first time it is requested. This speeds up the compiler  I've measured some definite improvement in parsing at least, and I expect compilations overall to be faster too. It also cleans up a lot of cruft from the OccName interface. Zencoding is nicely hidden inside the Outputable instance for Names & OccNames now.  StringBuffers are UTF8 too, and are now represented as ForeignPtrs.  I've put together some test cases, not by any means exhaustive, but there are some interesting UTF8 decoding error cases that aren't obvious. Also, take a look at unicode001.hs for a demo.

 14 Oct, 2005 1 commit


simonpj authored
Add record syntax for GADTs ~~~~~~~~~~~~~~~~~~~~~~~~~~~ Atrijus Tang wanted to add record syntax for GADTs and existential types, so he and I worked on it a bit at ICFP. This commit is the result. Now you can say data T a where T1 { x :: a } :: T [a] T2 { x :: a, y :: Int } :: T [a] forall b. Show b => T3 { naughty :: b, ok :: Int } :: T Int T4 :: Eq a => a > b > T (a,b) Here the constructors are declared using record syntax. Still to come after this commit:  User manual documentation  More regression tests  Some missing cases in the parser (e.g. T3 won't parse) Autrijus is going to do these. Here's a quick summary of the rules. (Atrijus is going to write proper documentation shortly.) Defnition: a 'vanilla' constructor has a type of the form forall a1..an. t1 > ... > tm > T a1 ... an No existentials, no context, nothing. A constructor declared with Haskell98 syntax is vanilla by construction. A constructor declared with GADTstyle syntax is vanilla iff its type looks like the above. (In the latter case, the order of the type variables does not matter.) * You can mix record syntax and nonrecord syntax in a single decl * All constructors that share a common field 'x' must have the same result type (T [a] in the example). * You can use field names without restriction in record construction and record pattern matching. * Record *update* only works for data types that only have 'vanilla' constructors. * Consider the field 'naughty', which uses a type variable that does not appear in the result type ('b' in the example). You can use the field 'naughty' in pattern matching and construction, but NO SELECTOR function is generated for 'naughty'. [An attempt to use 'naughty' as a selector function will elicit a helpful error message.] * Data types declared in GADT syntax cannot have a context. So this is illegal: data (Monad m) => T a where .... * Constructors in GADT syntax can have a context (t.g. T3, T4 above) and that context is stored in the constructor and made available when the constructor is patternmatched on. WARNING: not competely implemented yet, but that's the plan. Implementation notes ~~~~~~~~~~~~~~~~~~~~  Data constructors (even vanilla ones) no longer share the type variables of their parent type constructor.  HsDecls.ConDecl has changed quite a bit  TyCons don't record the field labels and type any more (doesn't make sense for existential fields)  GlobalIdDetails records which selectors are 'naughty', and hence don't have real code.

 10 Aug, 2005 1 commit


simonpj authored
It turned out that doing all binding dependency analysis in the typechecker meant that the renamer's unusedbinding error messages got worse. So now I've put the first dep anal back into the renamer, while the second (which is specific to type checking) remains in the type checker. I've also made the pretty printer sort the decls back into source order before printing them (except with dpprdebug). Fixes rn041.

 25 Jul, 2005 1 commit


simonpj authored
Wibbles to the big HsBinds reorg

 19 Jul, 2005 1 commit


simonpj authored
WARNING: this is a big commit. You might want to wait a few days before updating, in case I've broken something. However, if any of the changes are what you wanted, please check it out and test! This commit does three main things: 1. A reorganisation of the way that GHC handles bindings in HsSyn. This has been a bit of a mess for quite a while. The key new types are  Bindings for a let or where clause data HsLocalBinds id = HsValBinds (HsValBinds id)  HsIPBinds (HsIPBinds id)  EmptyLocalBinds  Value bindings (not implicit parameters) data HsValBinds id = ValBindsIn  Before typechecking (LHsBinds id) [LSig id]  Not dependency analysed  Recursive by default  ValBindsOut  After typechecking [(RecFlag, LHsBinds id)] Dependency analysed 2. Implement Mark Jones's idea of increasing polymoprhism by using type signatures to cut the stronglyconnected components of a recursive group. As a consequence, GHC no longer insists on the contexts of the type signatures of a recursive group being identical. This drove a significant change: the renamer no longer does dependency analysis. Instead, it attaches a freevariable set to each binding, so that the type checker can do the dep anal. Reason: the typechecker needs to do *two* analyses: one to find the true mutuallyrecursive groups (which we need so we can build the right CoreSyn) one to find the groups in which to typecheck, taking account of type signatures 3. Implement nonground SPECIALISE pragmas, as promised, and as requested by Remi and Ross. Certainly, this should fix the current problem with GHC, namely that if you have g :: Eq a => a > b > b then you can now specialise thus SPECIALISE g :: Int > b > b (This didn't use to work.) However, it goes further than that. For example: f :: (Eq a, Ix b) => a > b > b then you can make a partial specialisation SPECIALISE f :: (Eq a) => a > Int > Int In principle, you can specialise f to *any* type that is "less polymorphic" (in the sense of subsumption) than f's actual type. Such as SPECIALISE f :: Eq a => [a] > Int > Int But I haven't tested that. I implemented this by doing the specialisation in the typechecker and desugarer, rather than leaving around the strange SpecPragmaIds, for the specialiser to find. Indeed, SpecPragmaIds have vanished altogether (hooray). Pragmas in general are handled more tidily. There's a new data type HsBinds.Prag, which lives in an AbsBinds, and carries pragma info from the typechecker to the desugarer. Smaller things  The loop in the renamer goes via RnExpr, instead of RnSource. (That makes it more like the type checker.)  I fixed the thing that was causing 'check_tc' warnings to be emitted.

 20 May, 2005 1 commit


simonpj authored
Improve the GHCi interaction Merge to STABLE? This fix addresses Sourceforge #1156554 "GHCi: No instance for (Show (IO ()))", and simultaneously improves the toplevel interaction in two other ways:  Only one error can show up (previously there could be two)  If an I/O action gives a Showable result, the result is printed (provided it isn't ()). So prompt> return 4 prints 4, rather than nothing  For commandline 'let' and 'x<e' forms, if exactly one variable is bound, we print its value if it is Showable and not () prompt> let x = 4 4 prompt> x < return 5 5

 04 Apr, 2005 1 commit


simonpj authored
This commit combines three overlapping things: 1. Make rebindable syntax work for donotation. The idea here is that, in particular, (>>=) can have a type that has class constraints on its argument types, e.g. (>>=) :: (Foo m, Baz a) => m a > (a > m b) > m b The consequence is that a BindStmt and ExprStmt must have individual evidence attached  previously it was one batch of evidence for the entire Do Sadly, we can't do this for MDo, because we use bind at a polymorphic type (to tie the knot), so we still use one blob of evidence (now in the HsStmtContext) for MDo. For arrow syntax, the evidence is in the HsCmd. For list comprehensions, it's all builtin anyway. So the evidence on a BindStmt is only used for ordinary donotation. 2. Tidy up HsSyn. In particular:  Eliminate a few "Out" forms, which we can manage without (e.g.  It ought to be the case that the type checker only decorates the syntax tree, but doesn't change one construct into another. That wasn't true for NPat, LitPat, NPlusKPat, so I've fixed that.  Eliminate ResultStmts from Stmt. They always had to be the last Stmt, which led to awkward pattern matching in some places; and the benefits didn't seem to outweigh the costs. Now each construct that uses [Stmt] has a result expression too (e.g. GRHS). 3. Make 'deriving( Ix )' generate a binding for unsafeIndex, rather than for index. This is loads more efficient. (This item only affects TcGenDeriv, but some of point (2) also affects TcGenDeriv, so it has to be in one commit.)

 30 Sep, 2004 1 commit


simonpj authored
 Add Generalised Algebraic Data Types  This rather big commit adds support for GADTs. For example, data Term a where Lit :: Int > Term Int App :: Term (a>b) > Term a > Term b If :: Term Bool > Term a > Term a ..etc.. eval :: Term a > a eval (Lit i) = i eval (App a b) = eval a (eval b) eval (If p q r)  eval p = eval q  otherwise = eval r Lots and lots of of related changes throughout the compiler to make this fit nicely. One important change, only loosely related to GADTs, is that skolem constants in the typechecker are genuinely immutable and constant, so we often get better error messages from the type checker. See TcType.TcTyVarDetails. There's a new module types/Unify.lhs, which has purelyfunctional unification and matching for Type. This is used both in the typechecker (for type refinement of GADTs) and in Core Lint (also for type refinement).

 06 May, 2004 1 commit


simonpj authored
Fix (head []) value for src span in mkSimpleMatch

 05 Apr, 2004 1 commit


simonpj authored
In the derived code for gunfold, use a wildcard for the final case, to avoid a redundant test, and to eliminate the annoying warning about unmatched cases. While I'm at it, rename HsUtils.wildPat to nlWildPat, for consistency.

 10 Dec, 2003 2 commits


simonmar authored
Cleanups:  Move the collect* functions from HsSyn into HsUtils. Check that we have a clean separation of utilties over HsSyn, with the generic versions in HsUtils, and the specific versions in RdrHsSyn, RnHsSyn and TcHsSyn as appropriate.  Remove the RdrBinding data type, which was really just a nested list with O(1) append, and use OrdList instead. This makes it much clearer that there's nothing strange going on.  Various other minor cleanups.

simonmar authored
New file of miscellaneous utility functions over HsSyn.
