- Haskell-Cafe - Haskell.org

ghc api printing of types
by Phyx 01 Jul '10

01 Jul '10

I was wondering how given a Type I can get a pretty printed type out of it. I'm currently using showSDocUnqual . pprType . snd . tidyOpenType emptyTidyEnv But this has the problem that predicates don't get printed, anyone know how GHCi does this? Thanks, Phyx

1 0

Inferring the most general type
by Job Vranish 01 Jul '10

01 Jul '10

Esteemed fellow haskellers, I recently ran into a very simple real life case where Haskell's rules for inferring the types for mutually recursive definitions resulted in a type that was less general than it could be. It took me a while to realize that the type error I was getting wasn't actually a problem with my code. I understand why Haskell does this (it infers the strongly connected mutually recursive definitions monomorphically), but I think it _could_ infer the more general type even with recursive definitions like this. Here is a simplified example that illustrates the problem: > import Data.Maybe > -- The fixed point datatype > data Y f = Y (f (Y f)) > -- silly dummy function > maybeToInt :: Maybe a -> Int > maybeToInt = length . maybeToList > -- f :: Y Maybe -> Int > f (Y x) = g maybeToInt x > g h x = h $ fmap f x This is the type it wants to infer for g g :: (Maybe Int -> Int) -> Maybe (Y Maybe) -> Int This is the type I think it should have, note you can't force the type with a typesig without -XRelaxedPolyRec g :: (Functor f) => (f Int -> b) -> f (Y Maybe) -> b If I use -XRelaxedPolyRec I can manually specify the more general type, but then I have to convince myself that there isn't a more general type that I'm missing. Are there other known algorithms that yield a more general type? and if so, what was the rational for Haskell keeping the current method? I worked out an alternative algorithm that would give a more general type (perhaps the most general type) but it has factorial complexity and probably wouldn't be good for strongly connected groups with 7 or more members. Even so, I would much rather have the inferred types always be the most general ones and be required to add type signatures for mutually recursive groups with 7 or more members (which probably need to be redesigned anyway) than be always required to manually figure out the more general signatures. What do you think? - Job

2 1

RE: [Haskell-cafe] checking types with type families
by Simon Peyton-Jones 01 Jul '10

01 Jul '10

| Here's a concrete case I recently ran into: | | type family SomeOtherTypeFamily a | class SomeClass a where type SomeType a | instance a ~ SomeOtherTypeFamily b => SomeClass a where | type SomeType a = (b,Int) | -- (error) Not in scope: type variable `b' | | The same thing with fundeps: | | class SomeClass a b | a -> b | instance a ~ SomeOtherTypeFamily b => SomeClass a (b,Int) | -- works fine It's not the same thing at all! The code you give certainly should fail. Suppose you use fundeps thus: class C a b | a->b where op :: a -> b -> b The idiomatic way to replace this with type functions is to remove the 'b' parameter, thus: class C a where type B a op :: a -> B a -> B a Sometimes you don't want to do this. For example, you might have a bidirectional fundep. Then you can (or rather will be able to) use a superclass thus: class (B a ~ b) => C a b where type B a The superclass says that you can only instantiate this class with a second argument b that is equal to (B a). Thus you might have an instance instance C Int Bool where type B Int = Bool Meanwhile we are working hard on the new type inference engine, which will allow superclass equalities like these. Simon

1 0

dirs in Emacs/Vim in Cabal
by Chris BROWN 01 Jul '10

01 Jul '10

Dear Haskellers, I am in the process of creating a cabal HaRe and I have run into a minor problem. I have an emacs and a vim script that HaRe uses to invoke the refactorer from the two editors. In those scripts, I point HaRe to a directory containing some libraries it needs to chase the imports of the modules. Cabal installs these libraries as data files into whatever prefix the user requests at install time. However, the problem I have is that it then requires a manual user intervention to manually configure emacs/vim to point to this new directory in the 'customizable' panel of HaRe. My question is: Is it possible to allow the emacs/vim scripts that I have know where this directory is automatically? I hope someone can help, Kindest regards, Chris Brown.

2 1

functional dependencies question
by Patrick Browne 01 Jul '10

01 Jul '10

Hi, My understanding of functional dependencies is that they can be used to ensure that one type depends on another type. For example, the type of location depends could on the type of the object at that location. Consider two models 1) The location of an aircraft landing should have location of the type AirportCode, 2) The location of a car's destination should have a type CartesianCoordinate. AirportCodes should not be used as locations in 2) and CartesianCoordinates should not be used as locations in 1). Haskell class, instances, and fundeps were used to represent the above requirements. I generalized the requirement a bit, testing on a variety of types (below). Obviously, some cases are ambigous and/or conflicting and the Haskell compiler correctly flags this. Why do some cases such as 1) fail to run even if they are the only instantiation. Regards, Pat {- C:\GHC\ghc-6.8.3\bin\ghci.exe -XMultiParamTypeClasses -XFunctionalDependencies -fglasgow-exts -fallow-undecidable-instances -} class LocatedAt object location | object -> location where spatialLocation :: object -> location -- 1) Compiles but does not run instance LocatedAt Int String where spatialLocation(1)="home" -- 2) Compiles and runs OK instance LocatedAt String Int where spatialLocation("home")=1 -- 3) Compiles and runs OK, but obviously not in conjunction with 2 instance LocatedAt String String where spatialLocation("home")="home" -- 4) Compiles and runs OK instance LocatedAt Bool String where spatialLocation(True)="home" -- 5) Compiles and runs OK, but obviously not in conjunction with 2 instance LocatedAt String Bool where spatialLocation("home") = True -- 6) Not OK instance LocatedAt Float String where spatialLocation(2.3)="home" -- 7) Compiles but does not run instance LocatedAt Int Char where spatialLocation(1)='1' -- 8) Compiles and runs OK instance LocatedAt Char Int where spatialLocation('1')=1 This message has been scanned for content and viruses by the DIT Information Services E-Mail Scanning Service, and is believed to be clean. http://www.dit.ie

4 5

Newbie question about using WinGHCi
by Christopher Tauss 01 Jul '10

01 Jul '10

Hello - I just a day or so ago downloaded Hakell and am playing around with it, and I came upon this problem with WinGHCi: I am able to enter a multi-line "do" statement that works if I use brackets and semi-colon like so: Prelude> :{ Prelude| let main2 = do { Prelude| putStrLn "Please enter your name: "; Prelude| name <- getLine; Prelude| putStrLn ("Hello, " ++ name ++ ", how are you?") } Prelude| :} Prelude> main2 Please enter your name: CT Hello, CT, how are you? Prelude> Note there is no indentation. This makes sense to me because the :{ :} just take all the lines in between and make it one line. But it seems to me to be IMPOSSIBLE to input this into WinGHCi using indentation like most of the code samples seem to do. Should I just be satisfied that it works using brackets/ semi-colons? Or is there something obvious that I am missing that allows for indentation? Thanks in advance. It's issues lik this that keep me up into the depths of night. Best Regards, Chris

2 1

ANNOUNCE: HaRe, the Haskell Refactorer 0.6
by Chris BROWN 30 Jun '10

30 Jun '10

Dear Haskellers, As part of our project on Refactoring Functional Programs http://www.cs.kent.ac.uk/projects/refactor-fp/ we are pleased to announce the availability of HaRe 0.6 (also known as HaRe 28/06/2010), a snapshot of our Haskell Refactorer prototype. Apart from bug-fixes, there are major changes since HaRe 0.5 and HaRe 0.4: A number of new refactorings have been added to HaRe. Some of these include: Adding and removing fields and constructors to data-type definitions, folding and unfolding against as-patterns, merging and splitting, converting between let and where constructs, introduce pattern matching, generative folding, and a clone detection and elimination tool. We have evolved the ongoing architecture of HaRe and derived an API (documented using Haddock) for program analysis and transformation. This allows HaRe to serve as a framework for end-users to build their own refactorings or just program transformations (or analyses). HaRe is available to download directly from here: http://www.cs.kent.ac.uk/projects/refactor-fp/hare/HaRe_28062010.tar.gz You can get HaRe 0.6 and the documentation about how to build your own refactorings via: http://www.cs.kent.ac.uk/projects/refactor-fp/hare.html Please see the README.txt for build/use instructions and known issues, and let us know about any problems, bugs, suggestions or additional platforms you can confirm as working. You will need: 1. ghc-6.12.1 2. hint-0.3.2.3 (available from cabal) 3. unix/gnu tools (or cygwin tools, if on windows) 4. vim or emacs (we've tested with gvim 6.2 and with emacs 21.4) 5. If you intend on running the test suite, HUnit-1.0. Happy Refactoring! The HaRe Team (Chris Brown, Huiqing Li, Simon Thompson) Project email: refactor-fp at kent.ac.uk<http://www.haskell.org/mailman/listinfo/haskell> Background: Refactoring is the process of changing the structure of programs without changing their functionality, i.e., refactorings are meaning-preserving program transformations that implement design changes. For more details about refactoring, about our project and for background on HaRe, see our project pages. HaRe - the Haskell Refactorer: HaRe is our prototype tool supporting a collection of refactorings for Haskell 98 (see README.txt for known issues and limitations). It is implemented as a separate refactoring engine (on top of Programatica's Haskell frontend and Strafunski's generic traversal strategy library), with small scripting frontends that call this engine from either Vim or Emacs. Currently supported refactorings: Introduce Pattern Match : place cursor over pattern variable Introduce Sub pattern : place cursor over pattern variable Introduce Case Expression : place cursor over pattern variable Generative Fold : highlight expression to fold. Must have equation in comment directly before definition of highlighted expression. Clone Analysis : select from menu Clone Extraction : highlight clone from the clone class to extract, follow step-by-step instructions. Converting Let to Where : place cursor at start of identifier whose definition is to be moved Converting Where to Let : place cursor at start of identifier whose definition is to be moved. create type signatures : select from menu remove redundant declarations : highlight definition to clean up add constructor to data type : place cursor at start of data type, you'll be prompted to add the new Constructor name, followed by any Type parameters as a complete string Split a tuple : place cursor at start of top level definition that returns a tuple. Slicing based on a subexpression : highlight sub-expression to extract. Instantiate a general pattern : select a function equation and enter the new instances for each pattern in the argument set. Extract an expression : highlight an expression within a definition Convert data type to newtype : place cursor at start of data type add definition to merge : place cursor at start of definition that is to be merged merge definitions : use "add definition for merge" for each definition to be merged. then choose merge definitions from menu. fold function definition : highlight function equation to fold against. fold constant definition : highlight constant equation to fold against. convert pattern to an as pattern : highlight pattern to convert. unfold references to as patterns : place cursor over as pattern name. remove field from a data type : place cursor at start of field to remove. add field to data type : place cursor over start of constructor. enter new field name. add debug information : add trace calls to function by placing cursor at the start of the function to trace rename : place cursor at start of identifier to be renamed, you'll be prompted for a new name Lift def to top level : place cursor at start of identifier whose definition is to be moved Lift def one level : place cursor at start of identifier whose definition is to be moved Demote : place cursor at start of identifier whose definition is to be moved Introduce new def : highlight expression to be named, you'll be prompted for a new name Unfold def : place cursor at start of identifier where its definition is to be unfolded Generalise def : place cursor at start of identifier where its definition is to be unfolded Remove def : place cursor at start of identifier whose definition is to be removed Duplicate def : place cursor at start of identifier whose definition is to be duplicated, you'll be prompted for a new name Add one parameter : place cursor at start of identifier whose definition is to be modified, you'll be prompted for a new name rm one parameter : place cursor in formal parameter which is to be removed Move def to another module : place cursor at start of the identifier whose definition is to be moved, you'll be prompted for the module name Clean imports : cursor position does not matter, just choose the command from the refactor menu Make import explicit : place cursor at the start of the module name in the import declaration Add to export : place cursor at start of the identifier which is to be added to the export Remove from export : place cursor at start of the entry to be removed in the export list From concrete to abstract data type: place cursor at start of the data type name Add field names : place cursor at start of the data type name Add discriminators : place cursor at start of the data type name Add constructors : place cursor at start of the data type name Eliminate nested patterns : place cursor at start of the data type name Eliminate patterns : place cursor at start of the data type name Create an ADT module : place cursor at start of the data type name Eliminate intermediate list: cursor position does not matter, just choose the command from the menu. Caveats (see also README.txt): Please keep in mind that this is a prototype, so we do not recommend to use it on your productions sources just yet. Just play with it to get an idea of tool-supported refactoring in Haskell, and send us your feedback and bug-reports. Our goal is to develop this into a tool that many of you will find indispensable for Haskell development. Regards, The HaRe team.

4 11

zlib or digest package installation
by Daniel Kahlenberg 30 Jun '10

30 Jun '10

Hi, when installing pandoc package, which has digest somewhere in dependencies the usual cabal install stucks because zlib.h is missing, so I explicitly installed zlib package first, then installing digest (can also replace that directly with pandoc here) with the --extra-include-dirs parameter set: Prelude System.Cmd> > rawSystem "cabal" ["install", "digest", "-v3", "--user", "-- > build-log=d:/temp/log/build-$$pkgid-$$compiler-msys.log", "--reinstall", "--data > dir=$$prefix/haskell-pkgdata", "--extra-include-dirs=C:\\Users\\daniel\\AppData\ > \Roaming\\cabal\\zlib-0.5.2.0\\ghc-6.12.1\\include"] Is there something to improve in one of the packages cabal file to overcome the need to explicitly specify the header file locations of already installed packages or is that a consequence of not installing them as developer packages simply, so i. e. to have the header file zlib.h at the specified location is more a bonus to have in that situation? Greetz Daniel

3 2

Haskell Bangalore
by C K Kashyap 30 Jun '10

30 Jun '10

Hi, I was wondering if it would be a good idea for the folks interested in Haskell in Bangalore to get together. Especially if there are folks at EGL, perhaps we could just meet up at pyramid. I've been trying to learn Haskell for a while and currently am trying to work through SPJ's "implementation of Functional Programming languages". It would be good to bounce off ideas (in person) with like minded folks. -- Regards, Kashyap

4 3

Kate: Haskell and Literate Haskell syntax files
by Nicolas Wu 30 Jun '10

30 Jun '10

Dear all, I've just finished implementing a complete rewrite of the Haskell and Literate Haskell files for Kate. This improves the previous version in many ways: * Operators are now supported (++, !, >>=, and any other combination of legal operator characters) * Special symbols are recognised (=>, <-, ->, ::, ..) * Unicode support for →, ←, ∷, ‥,⇒, ∀, ∃ * Support for qualified module functions (List.sort, etc) * Support for qualified module types * Refactored Literate Haskell using IncludeRules * Support for literate code (using > and \begin{code} \end{code}) * Support for literate specifications (using < and \begin{spec} \end{spec}) You can find the most recent snapshot in my github repository [1], and examples of highlighted syntax using these files at my website [2]. Please let me know if there are any further improvements you can think of, Nick [1] http://github.com/zenzike/kate-haskell [2] http://zenzike.com

1 0