March 2006 - Libraries

RE: Idea to allow people to comment on Haskell docs
by Simon Peyton-Jones 09 Jan '07

09 Jan '07

| I've had a go at patching Haddock to put a link on the page for each | module. It's controlled by an optional --wiki=URL flag. | | As an example, I used this with the (devel version of the) Gtk2Hs docs: | | http://haskell.org/gtk2hs/docs/devel/ | | For example this page: | | http://haskell.org/gtk2hs/docs/devel/Graphics-Rendering-Cairo-SVG.html It looks great! But I'd never have found the link if you hadn't pointed me at it. Rather than "Wiki" say "User comments". And I think the per-entry [User comment] link is essential. Typically people are going to be looking at a particular thing. For example, here http://haskell.org/gtk2hs/docs/devel/Graphics-Rendering-Cairo-SVG.html#v %3AsvgRenderFromString is where I'd look for the link for svgRenderFromString. Does MediaWiki support anchors in the middle of a page? That's essential here -- we want one Wiki page for one Haddock page. On a closely related matter, Benjamin Pierce told me how often he wished that there was a link from the Haddock documentation to the source code for a function. Especially for Prelude functions, he's dead right. So another really useful Haddock enhancement would be the ability to add links to the source code from the Haddock docs --- again on a per-function basis. Do you feel like adding that too? Where should the code live? I'd suggest snap-shoting it at the moment that the Haddock docs are generated, and putting the files with the Haddock docs. Simon

12 15

Fast Sequences
by Jim Apple 04 Apr '06

04 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 25 Mar '06

25 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 21 Mar '06

21 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

RE: UTF8 (was Re: Hexdump)
by Bayley, Alistair 21 Mar '06

21 Mar '06

> From: libraries-bounces(a)haskell.org > [mailto:libraries-bounces@haskell.org] On Behalf Of Malcolm Wallace > > I was also thinking it would be nice to have pure Haskell > implementations of the various Unicode encodings. Here is my > attempt at > the UTF-8 codec. Like Dominic, I am wondering where such a module > should live in the hierarchy? > > Text.Codec.UTF8 > Codec.Text.UTF8 > Text.UTF8 > Codec.UTF8 > > Regards, > Malcolm My initial instinct is to put the UTF codecs in Foreign.C (Foreign.C.Unicode, say, or Foreign.C.Codec), because I've only used ever used them to marshall between Haskell Strings and CStrings. Also, a bunch o' functions like withUTF8CString{Len}, peekUTF8CString, etc are also useful. OTOH, I can think of uses for non-CString oriented codecs (e.g. converting an HTTP request body from a specific charset to Unicode), so maybe this is a dumb idea. Alistair ***************************************************************** Confidentiality Note: The information contained in this message, and any attachments, may contain confidential and/or privileged material. It is intended solely for the person(s) or entity to which it is addressed. Any review, retransmission, dissemination, or taking of any action in reliance upon this information by persons or entities other than the intended recipient(s) is prohibited. If you received this in error, please contact the sender and delete the material from any computer. *****************************************************************

1 0