- Libraries - Haskell.org

windows cabal bug?
by Isaac Jones 09 Apr '06

09 Apr '06

Can anyone with windows please take a look at this cabal bug report and provide a patch? This is reportedly a new problem in 6.5: http://hackage.haskell.org/trac/hackage/ticket/68 peace, isaac

1 0

Edison RC3
by Robert Dockins 06 Apr '06

06 Apr '06

Fellow Haskellers, The 3rd release candidate for Edison 1.2 is now avaliable. URLs to the project will appear at the end of this message. As with previous pre-releases, I am requesting comments on the API in particular. I believe I am approaching the point where I will feel comfortable freezing the 1.2 API, and I hope this will be the last release candidate before a 1.2 final. Major changes in 1.2rc3 are: * introduce the ambiguous/unambiguous concept and document all API operations * factor out methods which "mirror" superclass methods and make them alises instead * add lookupAndDelete* methods to associated collections * change the type of adjustOrDelete* in associated collections * rename subset/subsetEq to properSubset/subset * add matching Read and Show instances for all concrete datastructures * add properSubmap{By} submap{By} and sameMap{By} to the associated collection API * add Eq instances for concrete associated collections * break out the test suite into a separate sub-package The major remaining API issues I wish to request comments about have to do with class instances: 1) RC3 introduces Read and Show instances for all native Edison datastructures. However, StandardMap and StandardSet are just type aliases for Data.Map and Data.Set -- thus I can't provide Read and Show instances that are similar. So the question is, should I instead newtype these implementations so I can provide class instances which are consistent (as well as any other class instances I end up providing)? 2) Regarding Typeable and Data, what are your thoughts about the best way to provide Typeable and Data instances over abstract data types? I've considered playing the same trick that I do for Read/Show (which is internal conversions to/from lists). What do you think? 3) Are there any other class instances that are important to supply? And one final meta-API question; what are your thoughts about portability in general? I would like to support as many implementations as possible, but I'm already relying on MPTC, fundeps and undecidable instances (which may or may not be in H'), and I'm considering the following: -- instances of Typeable/Data (listed as non-portable) -- assertions (for checking preconditions) -- newtype deriving Anyway, I'm interested in your thoughts about how important portability is. ---------------------------------------- How to get Edison: Project page: http://www.eecs.tufts.edu/~rdocki01/edison.html Docs: http://www.eecs.tufts.edu/~rdocki01/docs/edison/index.html Source tarball: http://www.eecs.tufts.edu/~rdocki01/projects/edison-1.2rc3-source.tar.gz Darcs repo: http://www.eecs.tufts.edu/~rdocki01/edison/ Thanks! Rob Dockins

4 10

Fast Sequences
by Jim Apple 05 Apr '06

05 Apr '06

The proposed Data.Sequence ( http://www.soi.city.ac.uk/~ross/software/html/Data.Sequence.html ) has O(n) reverse. Section 6 of http://citeseer.ist.psu.edu/560336.html claims that it can be faster. Also, according to http://citeseer.ist.psu.edu/kaplan96purely.html , there is a sequence type with (><) of O(log log n). The latter one of these doesn't support the stated time bounds for different versions of the same structure. Do 2-3 finger trees support that? Jim

3 10

Reflection API for Haskell.
by Krasimir Angelov 30 Mar '06

30 Mar '06

Hello Guys, I am interested in having better Reflection API for Haskell. Currently we have Typeable and Data classes which provide some pieces of information about the data types at runtime. The (typeOf :: Typeable a => a -> TypeRep) method provides runtime information about the type of a given variable. The (dataTypeOf :: Data a => a -> DataType) provides almost the same information but with some extras. There is some overlap between the TypeRep and DataType types. Some pieces of information you can get from the TypeRep, other from the DataType and some other from both of them. There is also an information which is inaccessible from either TypeRep and DataType. Here is a list of the differences: - TypeRep contains both the TyCon and the arguments given to it. DataType contains only the name of the TyCon. The TyCon name is duplicated in TypeRep and in DataType. - DataType contains the DataRep structure which gives us an information about the available data structures. This is the only way to access them. - The Constr type represents data constructors at runtime. It has information about the constructor name, the record selectors and the fixity (prefix/infix). Unfortunately there isn't any information about the types of its arguments. What I would like to see is a better Reflection API with clear interface. My proposal is: -- * Type representations TypeRep -- abstract, instance of: Eq, Show, Typeable TyCon -- abstract, instance of: Eq, Show, Typeable DataCon -- abstract, instance of: Eq, Show, Typeable -- * Construction of type representations mkTyCon :: String -> Arity -> [DataCon] -> Fixity -> TyCon mkTyConVar :: Int -> Arity -> TyCon mkTyVar :: Int -> TypeRep mkTyConApp :: TyCon -> [TypeRep] -> TypeRep mkDataCon :: String -> [TypeRep] -> TypeRep -> [String] -> Fixity -> DataCon -- * Fixity representation Fixity(..) -- instance of: Eq, Show, Typeable defaultFixity :: Fixity -- * Observation of type representations typeRepTyCon :: TypeRep -> TyCon typeRepArgs :: TypeRep -> [TypeRep] -- * Observation of type constructors tyConString :: TyCon -> String tyConArity :: TyCon -> Int tyConDataCons :: TypeCon -> [DataCon] tyConFixity :: TyCon -> Fixity -- * Observation of data constructors dataConString :: DataCon -> String dataConArgs :: DataCon -> [TypeRep] dataConResult :: DataCon -> TypeRep dataConFields :: DataCon -> [String] dataConFixity :: DataCon -> Fixity The above API is just a reorganization of the existing API but with some extensions: - In the existing API there is no way to get the TyCon fixity and arity. In the new one there are the tyConFixity and tyConArity functions. - The data constructors are available from the tyConDataCons function. There isn't need for the separated DataType and DataRep types. - The DataCon arguments and the result type are available from the dataConArgs and dataConResult functions. - Since the type can be polymorphic we need to have representation for type variables. For that reason there are the mkTyVar and mkTyConVar functions. The new API can be used for both the Dynamic data type implementation and for the generic programming API. The additional information can be used for many kinds of serialization libraries where you would like to be sure that you are deserialising data with the same structure as those used in your program. In addition if you have stored the data type meta information you can have many kinds of generic tools that can read/write the data without need to have the same types defined in the application. What do you think about this kind of generalization of the existing API in the standard package? Cheers, Krasimir

1 0

Hexdump
by Dominic Steinitz 29 Mar '06

29 Mar '06

All, I finally got around to putting a "hexdump" function into a module. Any suggestions as to where it should live in the hierarchy? Dominic. module Hex( ppHex ) where import Data.List import Codec.Utils import Numeric import Text.PrettyPrint split :: Int -> [a] -> [[a]] split n xs = unfoldr (g n) xs g :: Int -> [a] -> Maybe ([a],[a]) g n [] = Nothing g n y = Just (splitAt n y) sh x | x < 16 = '0':(showHex x "") | otherwise = showHex x "" type OctetsPerLine = Int ppHex :: OctetsPerLine -> [Octet] -> Doc ppHex n = vcat . map hcat . map (intersperse colon) . map (map (text . sh)) . split n

5 6

Lists in haskell
by iliali16 26 Mar '06

26 Mar '06

people pls help me i have this weekend to finish my assignment on haskell.thats questuion1 of my assignment if somebody can help pls do so 10x in advance The aim of this assignment is to build a simulator of a programming language. The programming language contains variables (referred to by their name, given as a string), which can store an integer value: type Data = Integer type Variable = String The variable values are to be stored in a lookup table relating variable names and values, using the data synonym Store: type Store = [(Variable, Data)] (a) Define the empty Store, which contains no information about variables. (b) Define a function getVal, which takes a Store and a variable name, and returns its value. You may assume that the variable is defined in the Store. getVal :: Store -> Variable -> Data (c) Define a function setVar, which takes a Store, a variable name and a value, and returns an updated Store with the variable value updated. setVal :: Store -> (Variable, Data) -> Store -- View this message in context: http://www.nabble.com/Lists-in-haskell-t1341747.html#a3588096 Sent from the Haskell - Libraries forum at Nabble.com.

3 2

ANN: monadLib 2.0
by Iavor Diatchki 24 Mar '06

24 Mar '06

Hello everyone, There is now a new version of 'monadLib': a library of monad transformers for Haskell. 'monadLib' is a descendent of 'mtl', the monad template library that is distributed with most Haskell implementations. The library web page is at: http://www.csee.ogi.edu/~diatchki/monadLib Comments and feedback are very welcome! -Iavor

6 14

haskell.org libraries and tools page needs some fixing
by Björn Bringert 23 Mar '06

23 Mar '06

Hi all, I recently wanted to add some libraries to http://www.haskell.org/haskellwiki/Libraries_and_tools and noticed a number of problems. Problems: - The page is very large. - Many sections are large. - Many of the libraries linked to are obsolete. - Many of the links are dead [1]. - Many of the libraries have been moved into the standard libraries. - Some libraries are listed in multiple sections (at least some CGI libraries, there might be more). - Small and large, new and old libraries are mixed, and it's difficult for the reader to asses which things are relevant. - The page is not valid XHTML, the W3C Validator finds 433 errors [2]. * The pages uses <dt> tags everywhere, even though there is Wiki markup for definition lists. This seems to be causing most of the problems. Some possible remedies: - Replace dead links with Internet Archive links - Create an "obsolete" subsection of each section, and move old stuff there. Of course it can be difficult to figure out which things are obsolete, but I guess a first approximation would be everything for which the link is dead. - For libraries which are part of the standard libraries, provide links to the haddock page for the relevant module. - Replace HTML tags with Wiki markup. I'm willing to start working on this, but I want to check with you guys first. Any comments, ideas, or flames? I guess that if I start doing major stuff like chaning the mark-up, I'll put a note at the top asking people to hold off editing for a short while. /Björn [1] http://www.cs.chalmers.se/~bringert/misc/hslibs-checklink/checklink.html [2] http://validator.w3.org/check?uri=http%3A%2F%2Fwww.haskell.org%2Fhaskellwik…

8 10

external core
by John Meacham 22 Mar '06

22 Mar '06

Now, the external core feature of ghc is great, but it is not utilized very much. The main reason I think is that there is a large barrier to entry in writing something that uses it since you need to parse/generate it. It would be nice if there were a standard library that came with ghc (or cabalized and portable even better) that could parse and pretty print external core. ideally, one could write a simple pass-through core processor that interacts with ghc in a single line and someone working on a new optimization need only worry about that. Also, it would make it very easy for jhc to generate and parse ghc core files (always an ulterior motive). I wanted to use jhcs front end to generate ghc core so I could get a true measure of the difference in just their back-end performance without taking into account ghc's superior high-level optimizations. In any case. I think all the code is out there in ghc and it just needs to be separated and cabalized. I know there was talk of creating a ghc internals library, but it would be nice if this code were portable and independent. John -- John Meacham - ⑆repetae.net⑆john⑈

3 4

Announcing Text.Regex.Lazy (0.33)
by Chris Kuklewicz 22 Mar '06

22 Mar '06

Announcing : Text.Regex.Lazy (0.33) Where : http://sourceforge.net/projects/lazy-regex Who : Chris Kuklewicz <haskell(a)list.mightyreason.com> License : BSD, except for DFAEngine.hs which is LGPL (derived from CTK light) What: This is an alternative to Text.Regex along with some enhancements. GHC's Text.Regex marshals the data back and forth to c-arrays to call libc and this is far too slow (and strict). This module understands regular expression Strings via a Parsec parser and creates an internal data structure (Text.Regex.Lazy.Pattern). This is then transformed into a Parsec parser to process the input String, or into a DFA table for matching against the input String or FastPackedString. The input string is consumed lazily, so it may be an arbitrarily long or infinite source. The main modules of interest are: (*) Text.Regex.Lazy.Compat is supposed to be a drop in replacement for Text.Regex which uses Parsec and lazy matching. (*) Text.Regex.Lazy.Full allows for different strategies and for expanded syntax . This uses Parsec and a choice of lazy or strict matching. (*) Text.Regex.Lazy.CompatDFA uses a fast lazy DFAEngine for regex matching. (*) And an early version of Text.Regex.Lazy.DFAEngineFPS applies the DFAEngine to a Data.FastPackedString (untested). Why might you use this? (+) You would rather not translate a regular expression into a hard coded predicate for matching or filtering a string. (+) You can parse something via parenthesized subgroup capture of a regular expression and not have to write all the parsec manually. (+) You need to filter a large input (from stdin, for example) with a regex and want to do it lazily instead of all at once. (+) You want to build your own extensions to regex syntax for your project and would rather not have to rewrite one of the c-libraries to do it. What might you contribute? (.) Use it and report rough edges, incompatibilities, and bugs. (.) You can think of clever analysis and optimizations (e.g. taking the Pattern data as input). (.) Your favorite extended syntax (e.g. giving meaning to various backslashed letters, etc.). (.) You have a sinister regular expression & input to contribute as an evil test case.

1 0