December 2007 - Haskell-Cafe

Announce: PDXFunc: Portland FP Users Group
by Don Stewart 06 Dec '07

06 Dec '07

Who: Portland Functional Programmers Group Web: http://groups.google.com/group/pdxfunc Time and location: Monday, December 10th, 7pm at CubeSpace, 622 SE Grand, Portland, OR 97214. Directions: http://www.cubespacepdx.com/directions Topic Functional concurrency with Haskell Portland isn't going to miss out on the fun!

1 0

Graph theory analysis of Haskell code
by Ivan Miljenovic 06 Dec '07

06 Dec '07

This isn't strictly Haskell related, but anyway. Next year I will be doing my honours in mathematics. One possible topic for my thesis that I've thought of - and my supervisor is quite enthused about - is to use graph theory to analyse various textual sources, starting with source code but leaving the framework open enough to be able to extend it to other sources (e.g. email address books). How I envisage it happening is that a parser would be used to find all "functions" in the given code, treat these as nodes in the graph and then use directed edges to indicate which functions call other functions. This resultant graph can then be analysed in various ways suitable to the context (e.g. find that a library module can be split into two since there are two completely separate trees present in the graph that don't interact at all, or if a function is only ever called by one other function then it can be subsumed into it). So, here is the question I ask of all of you: is this feasible? Do you know if anything like this has ever been attempted before? I know there are some other usages of graph theory related to source code (e.g. McCabes complexity metric [1]), but I couldn't seem to find anything related to what I'm proposing. I intend to code this up in Haskell (possibly using FGL: I know of it, but haven't really looked at it) and use Haskell as my primary target for analysis, so in a sense the resultant graph could be seen as a Haskell equivalent to UML. [1] http://en.wikipedia.org/wiki/Cyclomatic_complexity -- Ivan Lazar Miljenovic

7 10

Hoogle works once more
by Neil Mitchell 06 Dec '07

06 Dec '07

Hi, I've just finished updating Hoogle (http://haskell.org/hoogle/) to work with the latest GHC API, in particular all the base split that has occurred and the few functions that were added. It took rather longer than I would have liked, because of paper deadlines etc, but its now sufficiently automated that it should only take a few seconds next time the libraries move in new directions. So now, if there is a function you are looking for in the core libraries which you can't find, tell me. Equally, if any of the documentation links lead to a 404, please do tell me. Hoogle still doesn't search all the hackage packages (that is the ultimate intention), just a selection of packages. The darcs URL's of the packages it searches are: http://darcs.haskell.org/packages/base/ http://darcs.haskell.org/packages/array/ http://darcs.haskell.org/packages/bytestring/ http://darcs.haskell.org/packages/Cabal/ http://darcs.haskell.org/packages/containers/ http://darcs.haskell.org/packages/directory/ http://darcs.haskell.org/packages/filepath/ http://darcs.haskell.org/packages/mtl/ http://darcs.haskell.org/packages/old-locale/ http://darcs.haskell.org/packages/old-time/ http://darcs.haskell.org/packages/packedstring/ http://darcs.haskell.org/packages/parallel/ http://darcs.haskell.org/packages/parsec/ http://darcs.haskell.org/packages/process/ http://darcs.haskell.org/packages/random/ http://darcs.haskell.org/packages/stm/ http://darcs.haskell.org/packages/template-haskell/ http://darcs.haskell.org/packages/time/ I picked this list based on a couple of critera: 1) The library MUST have documentation under http://haskell.org/ghc/docs/latest/html/libraries 2) The library should have shipped with GHC at some point recently (6.6 or 6.8) 3) The library is generally useful, not task specific (Gtk2hs, OpenGL are task specific) 4) If a library is Core to GHC, it should probably be in that list Quite a few libraries were close decisions, aided by nothing more than my mood at the time. In particular things like packedstring might be worth removing, and things like cgi or html/xhtml might be worth adding. Since this is a tool for the whole community, it makes sense that the whole community has input on what that list should be. Whatever list is decided upon, it will only be for the near future. Once Hoogle 4 is finished, every library on Hackage will be searched as an equal. Thanks Neil

6 7

who are the contributors to the Unix package?
by Galchin Vasili 06 Dec '07

06 Dec '07

Hello, Who started this effort? Who is currently doing work on the Unix package? Kind regards, Vasya

2 1

Pattern matching error
by georg86 06 Dec '07

06 Dec '07

Hello! I need to write a function which should is supposed to merge multiple entries with the same key (out of a sorted key-value-list) into one single entry. However, I keep getting a pattern matching error. (For example, for input [('b',[5]),('b',[4]),('b',[1]),('b',[6])]: "Program error: pattern match failure: kgroup [('b',[5,4]),('b',[1]),('b',[6])]") Thank you very much for your help. kmerge::Eq a => [(a,[b])]->[(a,[b])] kmerge [] = [] kmerge ((x,[y]):[]) = [(x,[y])] kmerge ((x,[y]):(u,[v]):xs) | x == u = kmerge ((x,[y,v]):xs) | otherwise = (x,[y]):(u,[v]):kmerge xs -- View this message in context: http://www.nabble.com/Pattern-matching-error-tf4957268.html#a14196413 Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

4 3

Template Haskell examples?
by Brent Yorgey 06 Dec '07

06 Dec '07

Hi all, I'm looking for good examples of using Template Haskell to evaluate CAFs at compile time, e.g. if I have some expensive-to-calculate lookup table which I'd rather have evaluated at comile time and included in the executable as a constant value, rather than having it computed every time the executable is run. I know I've seen examples of this before, but now that I would actually like to study such an example, I can't seem to find any. Any suggestions? Or can anyone make up a simple example on the spot? =) thanks, -Brent

2 1

Problems building and using ghc-6.9
by Daniel Fischer 06 Dec '07

06 Dec '07

Hi, so today I built ghc-6.9.20071124. First, make died because HsColour version >= 1.8 was needed, couldn't determine the version. I had HsColour 1.6, got myself 1.8, built and installed. make died again, same problem. I added ("v", Version) to the optionTable in HsColour.hs and it worked :) Then I tried to build zlib-0.4.0.1: $ runghc ./Setup.hs configure --user --prefix=$HOME Configuring zlib-0.4.0.1... Setup.hs: At least the following dependencies are missing: base >=2.0&&<2.2 ??? okay, there was something with flag bytestring-in-base, removed that, so that build-depends was base < 2.0 || >= 2.2, bytestring >= 0.9, then $ runghc ./Setup.hs configure --user --prefix=$HOME Configuring zlib-0.4.0.1... Setup.hs: At least the following dependencies are missing: base <2.0||>=2.2, bytestring >=0.9 but: $ ghc-pkg list /home/dafis/lib/ghc-6.9.20071124/package.conf: ALUT-2.1.0.0, Cabal-1.3, GLUT-2.1.1.1, HUnit-1.2.0.0, OpenAL-1.3.1.1, OpenGL-2.2.1.1, QuickCheck-1.1.0.0, array-0.1, base-3.0, bytestring-0.9, cgi-3001.1.5.1, containers-0.1, directory-1.0, fgl-5.4.1.1, filepath-1.1, (ghc-6.9.20071124), haskell-src-1.0.1.1, haskell98-1.0.1, hpc-0.5, html-1.0.1.1, mtl-1.1.0.0, network-2.1.0.0, old-locale-1.0, old-time-1.0, packedstring-0.1, parallel-1.0.0.0, parsec-2.1.0.0, pretty-1.0, process-1.0, random-1.0, readline-1.0.1, regex-base-0.72.0.1, regex-compat-0.71.0.1, regex-posix-0.72.0.2, rts-1.0, stm-2.1.1.0, template-haskell-2.2, time-1.1.2.0, unix-2.2, xhtml-3000.0.2.1 and in stringsearch-0.2: $ runghc ./Setup.lhs configure --user --prefix=$HOME Configuring stringsearch-0.2... Setup.lhs: At least the following dependencies are missing: base -any What's going on?? How can I build packages with ghc-6.9? Or do I have to go back to 6.8.1? Thanks, Daniel

2 1

Clean Dynamics and serializing code to disk
by gwern0＠gmail.com 06 Dec '07

06 Dec '07

Hey everyone; recently I've been toying around with various methods of writing a shell and reading the academic literature on such things. The best prior art on the subject seems to be the ESTHER shell (see <http://citeseer.ist.psu.edu/689593.html>, <http://citeseer.ist.psu.edu/744494.html>, <ftp://ftp.cs.kun.nl/pub/Clean/papers/2003/vWeA2003-Esther.pdf>). Now, ESTHER is a really cool looking shell, but it has two main problems for me: 1) Source doesn't seem to be available anywhere online 2) It's written in Clean and not Haskell No problem. All the hard stuff is done, and there's like a good 50 pages of documentation, so how hard could it be? Clean is practically Haskell anyway. But immediately I ran into a road-block: "The shell is built on top of Clean's hybrid static/dynamic type system and its dynamic I/O run-time support. It allows programmers to save any Clean expression, i.e a graph that can contain data, references to functions, and closures to disk. Clean expressions can be written to disk as a _dynamic_, which contains a representation of their (polymorphic) static type, while preserving sharing. Clean programs can load dynamics from disk and use run-time type pattern matching to reintegrate it into the statically-typed program." The Data.Dynamic library seems to do everything as far as dynamic types and run-time pattern matching goes, but I haven't figured out how one could write Haskell expressions to disk, like Clean's system <http://www.st.cs.ru.nl/papers/2002/verm2002-LazyDynamicIO.ps.gz> apparently allows. Does anyone know if there are any neat or tricky ways this could be done? Projects, extensions, whatever? On #haskell, quicksilver did tell me of one neat way to serialize various stuff through Data.Binary by using ADTs along the lines of the following simple example: -- module Main (main) where import Data.Binary data Math = Add | Subtract | Multiply deriving Show eval :: (Num a) => Math -> a -> a -> a eval f = case f of Add -> (+) Subtract -> (-) Multiply -> (*) instance Binary Math where put Add = putWord8 0 put Subtract = putWord8 1 put Multiply = putWord8 2 get = do tag_ <- getWord8 case tag_ of 0 -> return Add 1 -> return Subtract 2 -> return Multiply main = do encodeFile "tmp.s" [Add, Subtract, Multiply] a <- decodeFile "tmp.s" putStr $ show (a :: [Math]) -- Since from my Lisp days I know that code is data, it strikes me that one could probably somehow smuggle Haskell expressions via this route although I am not sure this is a good way to go or even how one would do it (to turn, say, a list of the chosen ADT back into real functions, you need the 'eval' function, but apparently eval can only produce functions of the same type - so you'd need to either create as many adts and instances as there are varieties of type signatures in Haskell '98 and the libraries, I guess, or somehow encode in a lambda calculus). Is that a route worth pursuing? -- gwern

4 4

HOgg 0.3.0 Released
by Conrad Parker 06 Dec '07

06 Dec '07

HOgg 0.3.0 Released ------------------- The HOgg package provides a commandline tool for manipulating Ogg files, and a corresponding Haskell library. HOgg is in hackage, or on the web at: http://www.kfish.org/~conrad/software/hogg/ This is the second public release. The focus is on correctness of Ogg parsing, production and editing. The capabilities of the hogg commandline tool are roughly on par with those of the oggz* [0] tools. Although hogg does not yet provide an equivalent to oggz-validate, it has subcommands for chopping out a section of a file, and for adding skeleton metadata. HOgg supports chained and multiplexed Ogg bitstreams conformant with RFC3533[1]. HOgg can parse headers for CMML, FLAC, OggPCM, Speex, Theora and Vorbis media codecs, and can read and write Ogg Skeleton bitstreams. [0] Oggz: http://www.annodex.net/software/liboggz/index.html [1] RFC3533: http://www.ietf.org/rfc/rfc3533.txt New in this release ------------------- The hogg tool contains new subcommands: chop, addskel and list-codecs. Additionally, subcommands for inspecting streams (hogg dump, hogg pagedump) can now take start and end time options. $ hogg help chop chop: Extract a section (specify start and/or end time) Usage: hogg chop [options] filename ... Examples: Extract the first minute of file.ogg: hogg chop -e 1:00 file.ogg Extract from the second to the fifth minute of file.ogg: hogg chop -s 2:00 -e 5:00 -o output.ogg file.ogg Extract only the Theora video stream, from 02:00 to 05:00, of file.ogg: hogg chop -c theora -s 2:00 -e 5:00 -o output.ogg file.ogg Extract, specifying SMPTE-25 frame offsets: hogg chop -c theora -s smpte-25:00:02:03::12 -e smpte-25:00:05:02::04 -o output.ogg file.ogg Options: -h, -? --help Display this help and exit -V --version Output version information and exit -c Content-Type --content-type=Content-Type Select the logical bitstreams for a specified content type -s Timestamp --start=Timestamp Specify a start time -e Timestamp --end=Timestamp Specify an end time -o filename --output=filename Specify output filename Additionally, the HOgg package now contains support for building with GHC version 6.8, and the Codec.Container.Ogg library contains various internal improvements. Installation ------------ I am very interested in hearing about problems with building or installing the package, particularly from people who are not yet familiar with building from Haskell source. You need ghc instead of gcc; it compiles to a binary: $ ./Setup.hs configure $ ./Setup.hs build $ sudo ./Setup.hs install Building of this release has been tested with: * GHC versions 6.4, 6.6 and 6.8.1 [2] * The Haskell build system "Cabal" versions 1.1.3, 1.1.4, 1.1.6, and the current development trunk. [3] The GHC and Cabal versions listed above span the packages available in most current distributions. I've tested on Debian unstable and Ubuntu Feisty. I'm particularly interested to hear reports of build success or failure on other distributions or operating systems. [2] GHC: http://www.haskell.org/ghc/ [3] Cabal: http://www.haskell.org/cabal/ Usage ----- $ hogg help Usage: hogg <subcommand> [options] filename ... Commands: help Display help for a specific subcommand (eg. "hogg help chop") Reporting: info Display information about the file and its bitstreams dump Hexdump packets of an Ogg file pagedump Display page structure of an Ogg file dumpraw Dump raw (unparsed) page data Extraction: rip Rip selected logical bistreams from an Ogg file (default: all) reconstruct Reconstruct an Ogg file by doing a full packet demux Editing: chop Extract a section (specify start and/or end time) merge Merge, interleaving pages in order of presentation time addskel Write a Skeleton logical bitstream Miscellaneous: known-codecs List codecs known by this version of hogg Please report bugs to <ogg-dev(a)xiph.org> Source ------ Source code is available from the darcs repository at: darcs get http://www.kfish.org/~conrad/software/hogg/ cheers, Conrad.

1 0

Re: About -Wall option
by Yitzchak Gale 06 Dec '07

06 Dec '07

Luis Cabellos wrote: >> I have a question, what's the best way to program? >> - put all the signatures in the Haskell Code? >> - Only put the type signatures needed to compile (like monomorphism errors >> or ambiguous signature)? Wolfgang Jeltsch wrote: > Inserting all type signatures is definitely best practice. (Moving to the cafe from ghc-users...) My personal style is: o Put signatures on everything at the top-level o Inside let and where, only where necessary, BUT: Inside let and where, I try to make sure that every function I define there is such that I would never want to call it separately in ghci/hugs while debugging, or in a unit test. Besides making testing and debugging easier, that rule forces the overall structure of every function to be simple and easy to read. In that case, type signatures just clutter the code and make it less readable. Conversely, if the relationship between the type of the let/where function and the type of the outer function is complex and not obvious, I will likely need to test that function. So it will go into a separate top-level function with a type signature. (I don't think this style creates any problems in Cabal.) -Yitz

1 0