- Haskell-Cafe - Haskell.org

(no subject)
by Thomas Hartman 10 Aug '07

10 Aug '07

In the following code which uses template haskell, how can I get back the macro-expanded code generated from $(inferStartState ''MyState) I *can* recover the macro-expanded code for $(cnst 1 "x") using a debugging technique bulat describes on his tutorial at http://www.haskell.org/bz/th3.htm You can see what's going on in the function debugTemplates below. I'm trying to do this actually, to better understand how HAppS deals with state. It's a bit opaque now since the example on the tutorial uses TH. I think I would understand it better if I had code that didn't depend on TH. (MyState is from the happs tutorial at http://www.haskell.org/haskellwiki/HAppS_tutorial ) thanks! thomas. {-# OPTIONS -fglasgow-exts -fth #-} module MyState where import HAppS import HAppS.Protocols.SimpleHTTP2 import Data.Monoid import Data.Typeable import Control.Monad.State (get, put) import Language.Haskell.TH import Language.Haskell.TH.Syntax data MyState = MySt { appVal :: Int } deriving (Read, Show, Typeable) instance Serialize MyState where encodeStringM = defaultEncodeStringM decodeStringM = defaultDecodeStringM instance Monoid MyState where mempty = MySt 0 mappend (MySt x) (MySt y) = MySt (x+y) -- in ghci... -fth, :m + -- ghci... :t (inferStartState ''MyState) :: (Quasi m) => m [Dec] $(inferStartState ''MyState) -- boilerplate that will eventually be SYB -- ghci... :t cnst 1 "x" :: (Monad m) => m Exp cnst n s = return (LamE (replicate n WildP) (LitE (StringL s))) dumpSplice splice = runQ splice >>= putStrLn . pprint debugTemplates = do dumpSplice (cnst 1 "x") dumpSplice (inferStartState ''MyState) {- *MyState> debugTemplates \_ -> "x" Template Haskell error: Can't do `reify' in the IO monad *** Exception: user error (Template Haskell failure) -} --- This e-mail may contain confidential and/or privileged information. If you are not the intended recipient (or have received this e-mail in error) please notify the sender immediately and destroy this e-mail. Any unauthorized copying, disclosure or distribution of the material in this e-mail is strictly forbidden.

2 1

New Eq instance
by rodrigo.bonifacio 09 Aug '07

09 Aug '07

Hello, I had defined the follwing data type: data Step = Step Id Scenario Action State Response How can I define Step as an "Eq Instance", in such way that two steps are equals if they have the same Id (Id is defined as a synonimous for the String type). I tried the following code, but something is wrong.... instance Eq Step where Step id1 scenario1 action1 state1 response1 == Step id2 scenario2 action2 state2 response2 = id == id _ == _ = False ps.: sorry, this kind of basic question can be sent to this list? Thanks in advance. Rodrigo.

4 3

Using haskell with emacs
by Paulo J. Matos 09 Aug '07

09 Aug '07

Hi all, I'm starting to learn haskell by my own, being currently mostly a Common Lisp, Scheme, C++ programmer... I've got the haskell emacs mode but can't find a manual. Moreover, I've found some keybindings on the net but nothing that allows me to start an interpreter in emacs and send definitions, one by one to the interpreter. Is this possible? Is there any good reference of the emacs keybindings for haskell mode? Cheers, -- Paulo Jorge Matos - pocm at soton.ac.uk http://www.personal.soton.ac.uk/pocm PhD Student @ ECS University of Southampton, UK

8 10

Using HList Records
by Rahul Kapoor 09 Aug '07

09 Aug '07

Using The Darcs version of HList (http://darcs.haskell.org/HList/) I can do simple things with (H)lists just fine, so --angus = Key 42 -- .*. Name "Angus" -- .*. Cow -- .*. Price 75.5 -- .*. HNil --main = putStrLn (show angus) works, On the other hand examples from the HList paper for extensible records like --key = firstLabel FootNMouth "key" --name = nextLabel key "name" --breed = nextLabel name "breed" --price = nextLabel breed "price" do not compile with errors --Main.hs:15:8-17: Not in scope: `firstLabel' --Main.hs:16:8-16: Not in scope: `nextLabel' A quick show "ghc-pkg describe HList" shows that --exposed-modules: HList --hidden-modules: Label4 CommonMain Variant GhcSyntax GhcRecord -- Record HZip TIC TIP HTypeIndexed HOccurs HArray GhcExperiments -- HListPrelude TypeEqBoolGeneric TypeEqGeneric1 TypeCastGeneric1 -- FakePrelude So the question is do I need to play around with the cabal file to expose the right stuff? Or has the syntax changed? I get errors running "./setup haddock" (configure, build, install, are fine). Are the HList api docs available anywhere online? Rahul

2 1

Re: default for quotRem in terms of divMod?
by Christian Maeder 09 Aug '07

09 Aug '07

Isaac Dupree wrote: > In class Integral, divMod has a default in terms of quotRem. > (quot,rem,div,mod all have defaults as the both-function they're part > of.) I'm sure divMod is more natural than quotRem to implement for some > types... so why doesn't quotRem have a default in terms of divMod? it > has no default! Then the "minimal to implement" will change from > (toInteger and quotRem) to (toInteger and (quotRem or divMod)). > > Isaac while I don't care if quotRem or divMod should be implemented. I oppose to give both default implementations in terms of the other. Already for the class Eq either == or /= must be defined, with the unpleasant effect that an empty instance like: instance Eq T leads to a loop (when == or /= is called on elements of type T). The empty instance does not even raise a warning about unimplemented methods (since the default definition is used). I'd rather prefer to remove /= as method of Eq. Cheers Christian

2 1

Defining new operators
by rodrigo.bonifacio 09 Aug '07

09 Aug '07

Hello, I have created the following function: dist :: String -> [[String]] -> [[String]] dist x y = [ x:e | e<-y ] eg.: dist "1M" [[], ["2M"], ["2M, 3M"]] = [["1M"],["1M","2M"],["1M","2M, 3M"]] How can I create an operator that perform the same function as dist? I want to write something like: "1M" ++ [[], ["2M"], ["2M", "3M"]] Thanks in advance. Rodrigo.

3 2

Newbie question (again!) about phantom types
by peterv 09 Aug '07

09 Aug '07

I’m having difficulty to understand what phantom types are good for. Is this just for improving runtime performance? I read the wiki, and it says "this is useful if you want to increase the type-safety of your code", but the code below does not give a compiler error for the function test1, I get a runtime error, just like test2. Thanks, Peter -- CODE -- -- With phantom types data T1 a = TI1 Int | TS1 String deriving Show foo1 :: T1 String -> T1 String -> T1 String foo1 (TS1 x) (TS1 y) = TS1 (x++y) test1 = foo1 (TI1 1) (TI1 2) -- Shouldn't this give a compiler error instead of a runtime error? -- Without phantom types data T2 = TI2 Int | TS2 String deriving Show foo2 :: T2 -> T2 -> T2 foo2 (TS2 x) (TS2 y) = TS2 (x++y) test2 = foo2 (TI2 1) (TI2 2) No virus found in this outgoing message. Checked by AVG Free Edition. Version: 7.5.476 / Virus Database: 269.11.8/941 - Release Date: 07/08/2007 16:06

4 4

mutually recursive types
by rodrigo.bonifacio 08 Aug '07

08 Aug '07

Hi, I am learning the haskell programming language and had tried to define the following types: type Scenario = (String, String, [Step]) type Step = (String, Scenario, String, String, String) Notice that Scenario depends on a list of steps and Step has a dependence with scenario. I know that this is a kind of "bad smell".... in Haskell, are there any pattern or language idiom to deal with cyclical dependences? Regards, Rodrigo.

4 3

FW: RE [Haskell-cafe] Monad Description For Imperative Programmer
by peterv 08 Aug '07

08 Aug '07

Kaveh> "A monad is like a loop that can run a new function against its variable in each iteration." I’m an imperative programmer learning Haskell, so I’m a newbie, but I’ll give it a try ☺ Making mistakes is the best way to learn it ;) There are lots of different kinds of monads, but let’s stick to the IO monad first, which you seem to refer to. No *an IO monad is not a loop at all*. Instead, from an imperative programmer’s point of view, the following might be better: “an IO monad is a delayed action that will be executed as soon as that action is needed for further evaluation of the program.” The simple program main = getLine >>= putStrLn can be visually represented as (see attachment) The “world” (=a representation of your computer’s hardware) is passed to the main function, which passes it to all actions that it encounters during its lazy evaluation, causing the executing of the actions as an effect. The red wire through which the “world flows” is a “single thread”, it cannot be split (because the physical world cannot be copied!!!), so no unwanted side effects can ever occur, making IO safe in Haskell. When you write your IO program, this world object is never available (the IO type is a special internal type), so the red wire is erased from the diagram, and the getLine and putStrLn boxes become “delayed actions”. Imperative programmers like myself might initially be confused when they see Haskell’s do notation, because it looks like the actions are strict statements as in C/C++/Pascal/Java/C#/etc, but they are not. For example, try the following program: main = do last [ putStrLn "NOT executed although it is first in the list, as it is not used by the main function!", putStrLn "This action IS executed because it is evaluated by the main function." ] This is of course all due to Haskell’s laziness which only evaluates just those expressions that it needs to evaluate the main function. One thing to note in the diagram above is that the getLine box has TWO outputs, the String and the World. But functions can only have a single output, but this can be tuple. Hence the passing of the world from one box to the other is a bit more complicated. It is this pattern of extracting both values from the output and passing them to the next function and other related combinations that form the generic monad class, which can be used for many more things than IO. See http://haskell.org/haskellwiki/IO_inside for a much deeper and more correct explanation ☺ And for the pros here, did this newbie make any sense? Probably not ;-) Oh no, yet another monad explanation!!! Now the universe will most certainly collapse… No virus found in this outgoing message. Checked by AVG Free Edition. Version: 7.5.476 / Virus Database: 269.11.0/929 - Release Date: 31/07/2007 17:26

15 23

Bug in GHCi?
by Dusan Kolar 08 Aug '07

08 Aug '07

Hello all, Maybe this is a wrong place to report, but I have repeatedly performed "funny" calculation in GHCi with strange time report. The version of GHCi is: ___ ___ _ / _ \ /\ /\/ __(_) / /_\// /_/ / / | | GHC Interactive, version 6.6, for Haskell 98. / /_\\/ __ / /___| | http://www.haskell.org/ghc/ \____/\/ /_/\____/|_| Type :? for help. Loading package base ... linking ... done. Prelude> My machine: OS WinXP Pro SP2, Intel Core 2, 2GB RAM. How to reproduce error: :set +s :set -02 :cd <path to the file in the attachment> :l Primes take 10000 primes1 <provides correct result and shows correct timing, about 636 seconds> take 10000 primes2 <provides correct result, BUT INCORRECT TIMING - about -326 seconds> Yes, that is not a typo. The report of time elapsed is: minus three hundred and twenty six seconds. I'll try the newest version of the GHCi, but it is strange anyway and maybe it should be investigated... Thanks, Dusan module Primes ( primes1 ,primes2 ,primes3 ,primes2' ,primes3' ) where candidates = map (\x -> (True,x)) [2..] candidates' = [2..] skipmap f toSkip list = domap toSkip list where domap n (x:xs) | n > 1 = x : domap (n-1) xs | True = f x : domap toSkip xs domap _ [] = [] primes1 = sieve candidates where sieve (pp@(isp,p):xs) | isp = p : (sieve $ skipmap (\(_,v) -> (False,v)) p xs) | True = sieve xs primes1' = sieve candidates' where sieve (p:xs) | p > 0 = p : (sieve $ skipmap (\n -> if n>0 then (-n) else n) p xs) | True = sieve xs sieve (p:xs) = p : sieve [y | y <- xs, y `mod` p /= 0] sieve' (p:xs) = p : sieve [y | y <- xs, y `mod` p > 0] primes2 = sieve [2..] primes3 = 2 : sieve [3,5..] primes2' = sieve' [2..] primes3' = 2 : sieve' [3,5..]

1 0

OS swapping and haskell data structures
by Alex Jacobson 08 Aug '07

08 Aug '07

If you create a Data.Map or Data.Set larger than fits in physical memory, will OS level swapping enable your app to behave reasonably or will things just die catastrophically as you hit a memory limit? -Alex-

6 7

creating graphics the functional way
by Frank Buss 08 Aug '07

08 Aug '07

I've created a small program to compose images with combinators: http://www.frank-buss.de/haskell/OlympicRings.hs.txt It produces TGA output, but I've converted it to PNG, because this is smaller: http://www.frank-buss.de/haskell/OlympicRings.png This is my first larger Haskell program and I have some questions: Nearly anything works without thinking too much about the types, but I don't like the use of fromInteger in the average and main functions. Is it possible that the integers are automaticly converted to floats? There are many functions like circle1Center, circle2Center, ... Is it possible to rewrite the program that it will be shorter, maybe using lists or an interpreter for a language for this kind of combinator programming style? Is it possible to write functions with an arbitrary number of arguments? Would be nice if the average function would accept any number of pixel values. Is there a PNG writer library for Haskell? I've seen a zlib interface, should be not too difficult to implement it in Haskell itself. Finally, what do you think about using this concept for generating images? It has some advantages, e.g. it is possible to scale the image without quality loss. But it needs some improvement, e.g. the anti-aliasing doesn't look very smooth. And it is very slow, it needs about 40 seconds on my computer to calculate the image. Using parametrized combinators sounds like a good idea for an interactive interface, like it is implemented in this program: http://www.theprodukkt.com/werkkzeug1#28 But this is impossible, if changing one parameter needs so long to update the image. -- Frank Buss, fb(a)frank-buss.de http://www.frank-buss.de, http://www.it4-systems.de

8 13

Type classes: Missing language feature?
by DavidA 07 Aug '07

07 Aug '07

Hi, there's something I'm trying to do with type classes that seems to fit very naturally with my mental model of type classes, but doesn't seem to be supported by the language. I'm wondering whether I'm missing something, or whether there's some language extension that could help me or alternative way of achieving what I'm trying to achieve. I'm trying to define multivariate polynomials, which are sums of monomials - for example x^2y + z^4. In algorithms on multivariate polynomials, one typically wants to support different monomial orders. For example, the lex order is dictionary order - xxy < xy < y < yyy - whereas the graded lex (glex) order also takes into account the degree of the monomials - y < xy < xxy < yyy. Here's some code (based on http://sigfpe.blogspot.com/2007/07/ill-have- buchburger-with-fries.html): import Data.Map as M import Data.List as L newtype Monomial = Monomial (Map String Int) deriving (Eq) x = Monomial $ singleton "x" 1 y = Monomial $ singleton "y" 1 instance Show Monomial where show (Monomial a) = concatMap (\(v,i)-> v ++ "^" ++ show i) $ toList a -- simplified for brevity instance Num Monomial where Monomial a * Monomial b = Monomial $ unionWith (+) a b newtype Lex = Lex Monomial deriving (Eq) newtype Glex = Glex Monomial deriving (Eq) instance Ord Lex where Lex (Monomial m) <= Lex (Monomial m') = toList m <= toList m' instance Ord Glex where Glex (Monomial m) <= Glex (Monomial m') = (sum $ elems m, toList m) <= (sum $ elems m', toList m') Now, what I'd like to do is have Lex and Glex, and any further monomial orderings I define later, automatically derive Show and Num instances from Monomial (because it seems like boilerplate to have to define Show and Num instances by hand). Something like the following (not valid Haskell): class OrdMonomial m where fromRaw :: Monomial -> m toRaw :: m -> Monomial instance OrdMonomial Lex where fromRaw m = Lex m toRaw (Lex m) = m instance OrdMonomial Glex where fromRaw m = Glex m toRaw (Glex m) = m derive OrdMonomial m => Show m where show m = show (toRaw m) derive OrdMonomial m => Num m where m * m' = fromRaw (toRaw m * toRaw m') Is there a way to do what I'm trying to do? (Preferably without resorting to template Haskell, etc) - It seems like a natural thing to want to do.

4 3

Haskell Weekly News: August 07, 2007
by dons＠cse.unsw.edu.au 07 Aug '07

07 Aug '07

--------------------------------------------------------------------------- Haskell Weekly News http://sequence.complete.org/hwn/20070807 Issue 64 - August 07, 2007 --------------------------------------------------------------------------- Welcome to issue 64 of HWN, a weekly newsletter covering developments in the [1]Haskell community. This issue marks the second anniversary of the Haskell (not quite) Weekly News. Thanks to the Haskell community for support, content and for reading over the last two years! 1. http://haskell.org/ Announcements OSCON Haskell Tutorial. Simon Peyton-Jones Appeared at the O'Reilly Open Source Convention (OSCON) in Portland, delivering a range of talks, including [2]A Taste of Haskell, [3]A Keynote on Functional Languages, [4]Nested Data Parallelism and [5]Transactional Memory for Concurrent Programming. Videos are available for most of these talks: [6]A Taste of Haskell: Part 1, [7]A Taste of Haskell: Part 2, [8]slides for A Taste of Haskell, [9]Transactional Memory for Concurrent Programming and [10]the NDP talk at the London Hugs meeting. 2. http://conferences.oreillynet.com/cs/os2007/view/e_sess/14016 3. http://conferences.oreillynet.com/cs/os2007/view/e_sess/14773 4. http://conferences.oreillynet.com/cs/os2007/view/e_sess/14014 5. http://conferences.oreillynet.com/cs/os2007/view/e_sess/14017 6. http://blip.tv/file/324976 7. http://www.blip.tv/file/325646/ 8. http://conferences.oreillynet.com/presentations/os2007/os_peytonjones.pdf 9. http://www.blip.tv/file/317758/ 10. http://video.google.co.uk/videoplay?docid=370317485066035666 hpodder 1.0. John Goerzen [11]announced version 1.0.0 of hpodder, the command-line podcatcher (podcast downloader) that just happens to be written in everyone's favorite language. You can get it [12]here. Version 1.0.0 sports a new mechanism for detecting and disabling feeds or episodes that repeatedly result in errors, updates to the Sqlite database schema, and several bugfixes. 11. http://article.gmane.org/gmane.comp.lang.haskell.general/15452 12. http://software.complete.org/hpodder encoding-0.1. Henning Günther [13]announced the release of 'encoding', a Haskell library to cope with many character encodings found on modern computers. At the moment it supports (much more is planned): ASCII, UTF-8, -16, -32, ISO 8859-* (alias latin-*), CP125* (windows codepages), KOI8-R, Bootstring (base for punycode) 13. http://article.gmane.org/gmane.comp.lang.haskell.general/15481 Dimensional 0.6: Statically checked physical dimensions. Björn Buckwalter [14]announced a library providing data types for performing arithmetic with physical quantities and units. Information about the physical dimensions of the quantities/units is embedded in their types and the validity of operations is verified by the type checker at compile time. The boxing and unboxing of numerical values as quantities is done by multiplication and division with units. 14. http://article.gmane.org/gmane.comp.lang.haskell.cafe/26944 Hackage This week's new libraries in [15]the Hackage library database. * hgal-1.0.1. Jean Philippe Bernardy. [16]Computation automorphism group and canonical labeling of a graph * hpodder-1.0.3. John Goerzen. [17]Podcast Aggregator (downloader) * dlist-0.3.1. Don Stewart. [18]Differences lists: a list-like type supporting O(1) append * pointfree-1.0. Felix Martini. [19]Stand-alone command-line version of the point-less plugin for lambdabot * encoding-0.1. Henning Guenther. [20]A library for various character encodings * AppleScript-0.1.3. Wouter Swierstra. [21]Call AppleScript from Haskell * SDL-ttf-0.4.0. David Himmelstrup. [22]Binding to libSDL_ttf * Finance-Quote-Yahoo-0.2. Brad Clawsie. [23]Obtain quote data from finance.yahoo.com * xmobar-0.7. Andrea Rossato. [24]A Minimalistic Text Based Status Bar 15. http://hackage.haskell.org/ 16. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/hgal-1.0.1 17. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/hpodder-1.0.3 18. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/dlist-0.3.1 19. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/pointfree-1.0 20. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/encoding-0.1 21. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/AppleScript-0.1.3 22. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/SDL-ttf-0.4.0 23. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/Finance-Quote-Ya… 24. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/xmobar-0.7 Conference roundup OSCON. Simon Peyton-Jones gave a series of popular talks about Haskell and functional programming at OSCON, in Portland. Below are collected just some of the posts about Haskell at OSCON. * [25]A brief Haskell-at-OSCON trip report * [26]Wow! OSCON video viewing statistics * [27]OSCon Wednesday Part 2 * [28]A Taste of Haskell, A Taste of C * [29]OSCON Day 1 * [30]A Taste of Haskell * [31]OSCON 2007 * [32]Threading Building Blocks and C++ * [33]OSCON: Wednesday Morning * [34]OSCON: Wednesday Afternoon * [35]OSCON 2007 (July 25) * [36]Nested Data Parallelism in Haskell * [37]OSCON 2007: Wednesday Morning Keynotes * [38]A Taste of Haskell 25. http://www.realworldhaskell.org/blog/2007/08/03/a-brief-haskell-at-oscon-tr… 26. http://www.realworldhaskell.org/blog/2007/08/07/wow-oscon-video-viewing-sta… 27. http://changelog.complete.org/posts/632-OSCon-Wednesday-Part-2.html 28. http://www.oreillynet.com/onlamp/blog/2007/07/a_taste_of_haskell_a_taste_of… 29. http://brycebaril.vox.com/library/post/oscon-2007-day-1.html 30. http://jaortega.wordpress.com/2007/08/04/a-taste-of-haskell/ 31. http://www.sauria.com/blog/2007/08/03/oscon-2007/ 32. http://softwareblogs.intel.com/2007/07/26/threading-building-blocks-and-c/ 33. http://znark.com/blog/2007/07/25/oscon-wednesday-morning 34. http://znark.com/blog/2007/07/25/oscon-wednesday-afternoon 35. http://panela.blog-city.com/oscon_2007_july_25.htm 36. http://ihack.us/2007/07/25/nested-data-parallelism-in-haskell/ 37. http://www.canspice.org/2007/07/25/oscon-2007-wednesday-morning-keynotes/ 38. http://butlerpress.com/2007/07/24/a-taste-of-haskell/ Blog noise [39]Haskell news from the [40]blogosphere. * [41]Ord, Countable Ordinals, and an Idea of sigfpe * [42]Word numbers, Part 1: Billion approaches * [43]Implementing SmallTalk in Haskell * [44]From walking to zipping, Part 1: Moving right * [45]From walking to zipping, Part 2: Down and up * [46]Irrefutable patterns for the ignorant * [47]Making Haskell nicer for game programming * [48]Nested Data Parallelism in Haskell * [49]Compiling Haskell to Erlang * [50]Peano's Axioms IV: Advanced Functions and Integers * [51]37 Reasons to Love Haskell * [52]On the value of strong static typing * [53]Parsec Parser Testing with QuickCheck * [54]Fallacies in the Great Dynamic vs Static Debate * [55]Implementing a dictionary using first class functions * [56]Strong specifications in Coq: the type says everything * [57]Run length encoding in Haskell * [58]Run length encoding and arrows * [59]Playing with Arrows * [60]Monads! (and Why Monad Tutorials Are All Awful) * [61]Haskell: Explaining Arrows through XML Transformations * [62]Monads as computation * [63]Closed Categories * [64]Good Haskell Style * [65]Monads are hard to teach * [66]Parsec * [67]First attempt at using GTK with Haskell * [68]Introduction to Haskell, Part 3: Monads * [69]Programming in Haskell * [70]Haskell Fun * [71]Algebraic Data Types again * [72]DFAs, Categories, and Typecheckers * [73]Haskell State Accessors (second attempt: Composability) * [74]Developing Programs and Proofs Spontaneously using GADT * [75]Encoding Inductive and Coinductive Types in Polymorphic Lambda Calculus * [76]Polymorphic Types in Haskell without Constructors? * [77]Subtraction not Definable in Simply Typed Lambda Calculus * [78]Imperative programming is a special type of functional programming * [79]Binding Haskell to C structs 39. http://planet.haskell.org/ 40. http://haskell.org/haskellwiki/Blog_articles 41. http://blog.jbapple.com/2007/07/ord-countable-ordinals-and-idea-of.html 42. http://conway.rutgers.edu/~ccshan/wiki/blog/posts/WordNumbers1/ 43. http://lstephen.wordpress.com/2007/07/23/completing-the-spike/ 44. http://conway.rutgers.edu/~ccshan/wiki/blog/posts/WalkZip1/ 45. http://conway.rutgers.edu/~ccshan/wiki/blog/posts/WalkZip2/ 46. http://therning.org/magnus/archives/311 47. http://luqui.org/blog/archives/2007/07/26/making-haskell-nicer-for-game-pro… 48. http://ihack.us/2007/07/25/nested-data-parallelism-in-haskell/ 49. http://blog.tornkvist.org/?id=1185571582964040 50. http://disparatemathematician.blogspot.com/2007/07/peanos-axioms-iv-advance… 51. http://cdsmith.wordpress.com/2007/07/29/37-reasons-to-love-haskell-playing-… 52. http://www.serpentine.com/blog/2007/07/29/on-the-value-of-strong-static-typ… 53. http://lstephen.wordpress.com/2007/07/29/parsec-parser-testing-with-quickch… 54. http://neilbartlett.name/blog/2007/07/30/fallacies-in-the-great-dynamic-vs-… 55. http://lukeplant.me.uk/blog.php?id=1107301671 56. http://www.rubrication.net/2007/04/24/strong-specifications/ 57. http://cgi.cse.unsw.edu.au/~dons/blog/2007/07/31#rle 58. http://community.livejournal.com/evan_tech/229752.html 59. http://unenterprise.blogspot.com/2007/08/playing-with-arrows.html 60. http://ahamsandwich.wordpress.com/2007/07/26/monads-and-why-monad-tutorials… 61. http://neilbartlett.name/blog/2007/08/01/haskell-explaining-arrows-through-… 62. http://www.haskell.org/haskellwiki/Monads_as_computation 63. http://unapologetic.wordpress.com/2007/08/01/closed-categories/ 64. http://urchin.earth.li/~ian/style/haskell.html 65. http://davblog48.blogspot.com/2007/08/monads-are-hard-to-teach.html 66. http://davblog48.blogspot.com/2007/05/parsec.html 67. http://davblog48.blogspot.com/2007/05/first-attempt-at-using-gtk-with-haske… 68. http://www.onlamp.com/pub/a/onlamp/2007/08/02/introduction-to-haskell-pure-… 69. http://www.cs.chalmers.se/Cs/Grundutb/Kurser/d1pt/d1pta/external.html 70. http://changelog.complete.org/posts/640-guid.html 71. http://blog.tmorris.net/algebraic-data-types-again/ 72. http://disparatemathematician.blogspot.com/2007/08/dfas-categories-and-type… 73. http://luqui.org/blog/archives/2007/08/05/haskell-state-accessors-second-at… 74. http://www.iis.sinica.edu.tw/~scm/?p=32 75. http://www.iis.sinica.edu.tw/~scm/?p=31 76. http://www.iis.sinica.edu.tw/~scm/?p=28 77. http://www.iis.sinica.edu.tw/~scm/?p=27 78. http://blog.tmorris.net/imperative-programming-is-a-special-type-of-functio… 79. http://therning.org/magnus/archives/315 Quotes of the Week * schluehk: ... Haskell taking over the world and troubled parents ask why their kids have turned into math hippies talking about nothing but love and abstract algebra... * JohnGoerzen: Haskell manipulates functions with the same ease that Perl manipulates strings * (anonymous Russian blogger): Glory to Simons! Glory to Swedish professors! * Laurent Sansonetti: I appreciated so much the Haskell talks that I am now learning the language. * dcoutts: Apparently that's only 200x faster than the faster of two common python serialisation libs, so we've got some way to go yet. * slava: [on Isabelle for web frameworks] IM IN UR WEB SITEZ, CODING PROVABLY-CORRECT BLINK TAG!! * gimboland: At present i'd say 'tinkering with a nuclear bomb' is approximately where i am with monads... * jcreigh: Could not find instance Ord for type ProgrammingLanguage * kowey: i suspect we're one of the rare wikibooks to use higher order templates * monochrom: 'm a -> (a -> m b) -> m b' is much more to the point than 'mumble computation mumble computation mumble computation mumble' * roconnor: damn it, Haskell pseudo code is indistinguishable from actual code * slava: Because top enterprise industry analysts recommend Because top enterprise industry analysts recommend that managers need to focus on Agile methodologies, SOA, B2B and Yoneda's lemma in today's rich internet application-driven environment. Don't get left behind by the AJAX craze by missing out on call center outsourcing and Yoneda's lemma! Code Watch Notable new features and bug fixes to the Haskell compilers. Fri Jul 27 03:41:57 PDT 2007. Simon Marlow. Pointer Tagging. This patch implements pointer tagging as per our ICFP'07 paper 'Faster laziness using dynamic pointer tagging'. It improves performance by 10-15% for most workloads, including GHC itself. The original patches were by Alexey Rodriguez Yakushev, with additions and improvements by me. I've re-recorded the development as a single patch. The basic idea is this: we use the low 2 bits of a pointer to a heap object (3 bits on a 64-bit architecture) to encode some information about the object pointed to. For a constructor, we encode the 'tag' of the constructor (e.g. True vs. False), for a function closure its arity. This enables some decisions to be made without dereferencing the pointer, which speeds up some common operations. In particular it enables us to avoid costly indirect jumps in many cases. More information [80]in the commentary. 80. http://hackage.haskell.org/trac/ghc/wiki/Commentary/Rts/HaskellExecution/Po… About the Haskell Weekly News Each week, new editions are posted to [81]the Haskell mailing list as well as to [82]the Haskell Sequence and [83]Planet Haskell. [84]RSS is also available, and headlines appear on [85]haskell.org. Headlines are available as [86]PDF. To help create new editions of this newsletter, please see the [87]contributing information. Send stories to dons at cse.unsw.edu.au. The darcs repository is available at darcs get [88]http://www.cse.unsw.edu.au/~dons/code/hwn 81. http://www.haskell.org/mailman/listinfo/haskell 82. http://sequence.complete.org/ 83. http://planet.haskell.org/ 84. http://sequence.complete.org/node/feed 85. http://haskell.org/ 86. http://www.cse.unsw.edu.au/~dons/code/hwn/archives/20070807.pdf 87. http://haskell.org/haskellwiki/HWN 88. http://www.cse.unsw.edu.au/~dons/code/hwn

1 0

Monad for Set?
by Ronald Guida 07 Aug '07

07 Aug '07

Hi, I'm pondering, is it possible to define a Set monad analogous to the List monad? My thinking is as follows: * "fmap f x" would apply f to each element in a set x * "return x" would create a singleton set {x} * "join x", where x is a set of sets: x = {x1, x2, ... xn}, would form their union (x1 U x2 U ... U xn) The advantage of Set over List is that duplicate elements would be removed automatically. There is just one /slight/ problem: In order to implement set operations, I need to be able to test elements for equality; that is, I need to impose the restriction (Eq a) => Set a. This is a problem because return really needs to work for any type; I have no way to guarantee (Eq a). In my search for answers, I came across "restricted monads". I don't like the idea of restricting the types I can return, and here's why. Suppose I had a way to impose (Eq a). Then I start to wonder: * What happens when I use a monad transformer like "StateT s Set a" or "ContT r Set a", but the types s and r are not equatable? * What happens when I want to define the monad transformer SetT because I need to put the IO monad inside it? In both cases, I feel I'm screwed if I really have to impose the constraint (Eq a) => Set a. This leads me think of a different solution: What if I could define a Set monad that's smart enough to "know", for any type a, whether or not (Eq a) holds, and degenerate to a blind list if the elements can't be equated. Ultimately, what I would need is a way to overload "join" (or "bind") with two different implementations, one for types that satisfy (Eq a), and another implementation for all other types. In my searching so far, I found ways to overload a function when all overloads share a common typeclass, and I have found ways to overload a function for disjoint types, provided that every type to be overload is an instance of some typeclass. All of the methods I have found so far are deficient in the sense that there is no way to provide a default implementation for types that don't fit into any typeclass. I have not been able to find a way to overload a function such that one implementation works for a special class of types, and another implementation works for *all* other types. Question: Is it possible to define join :: [[a]] -> [a], with (1) a special implementation that requires (Eq a) and removes duplicate elements, and (2) a general implementation to fall back on for *any* type that fails the constraint, and (3) a way to make "f" fully generic, such that the correct implementation is chosen automatically from the type variable a? If I had a way to do this, then I could define a Set monad that performs set operations when it can (i.e. when the elements are equatable), but which automatically degenerates to a simple List when it has to (i.e. when there's no equality test). I almost suspect that I might need to use Haskell Templates (I currently know nothing about Haskell Templates). Even better, if this problem is solvable, then the next step would be to overload again to use an efficient implementation when set elements are comparable (Ord a). Any ideas? -- Ron

3 2

Any ideas how to go about doing a phd in threading?
by Hugh Perkins 07 Aug '07

07 Aug '07

Hi, Really interested in doing a phd on threading. Any ideas how I'd go about doing/applying for that? Basically, threading seems to be the cutting-edge right out (for a while) as processor frequencies top out, and multicores increase. I dont have any formal CS training, but I do have a degree in natsci from Cambridge, quite a few years experience in industry, and anyone who knows me can attest that I'm highly motivated; a string of opensource work shows that I'm more interested in having fun than earning money, for a geek's definition of having fun :-) No particular preference for language, whatever it takes ;-) The Haskell group seems to have a high percentage of phds, and Haskell is a candidate language for automatic thread management, so seems an appropriate group to ask about this? Here's my cv in case it's useful: http://manageddreams.com/CV_PERKINS.pdf

1 0

Newbie question: "multi-methods" in Haskell
by peterv 07 Aug '07

07 Aug '07

In de book Modern C++ design, Andrei Alexandrescu writes that Haskell supports “multi-methods” http://books.google.com/books?id=aJ1av7UFBPwC&pg=PA3&ots=YPiJ_nWi6Y&dq=moder n+C%2B%2B&sig=FWO6SVfIrgtCWifj9yYHj3bnplQ#PPA263,M1 How is this actually done in Haskell? Maybe this is just a basic feature of Haskell which I don't grasp yet because of my object-oriented background? A good example is collision between pairs of objects of type (a,b). In object oriented languages this cannot be handled in a nice way, because neither a.Collide(b) or b.Collide(a) is the correct approach; one would like to write (a,b).Collide() A specific example might be better here. Assume the following class hierarchy: Solid | +-- Asteroid | +-- Planet | + -- Earth | + -- Jupiter Using multi-methods, I could write (in pseudo code) collide (Asteroid, Planet) = "an asteroid hit a planet" collide (Asteroid, Earth) = "the end of the dinos" collide (Solid,Solid) = " solids collided" collide (Planet, Asteroid) = collide (Asteroid, Planet) collide (Earth, Asteroid) = collide (Earth, Asteroid) So basically, the "best" collide function is picked, depending on the type of the arguments. How should I write Haskell code for something like this in general, in the sense that this hierarchy is typically huge and the matrix (of collide functions for each pair of types) is very sparse. Thanks, Peter No virus found in this outgoing message. Checked by AVG Free Edition. Version: 7.5.476 / Virus Database: 269.11.6/938 - Release Date: 05/08/2007 16:16

5 7

combinators for a simple grammar
by Rahul Kapoor 07 Aug '07

07 Aug '07

I am having problems coming up with nice combinators for a simple DSEL. The abstract syntax is simply given by the types: data SearchCondition = SearchCondition BoolTerm | OpOr SearchCondition BoolTerm data BoolTerm = BoolTerm BoolFactor | OpAnd BoolTerm BoolFactor data BoolFactor = Constant Bool My current combinators are (.||.) :: SearchCondition -> BoolTerm -> SearchCondition (.||.) sc term = OpOr sc term (.&&.) :: BoolTerm -> BoolFactor -> BoolTerm (.&&.) term fact = OpAnd term fact which allow you to write expression of the form factTrue = Constant True termTrue = BoolTerm factTrue scTrue = SearchCondition termTrue sc = scTrue .||. termTrue .||. termTrue .&&. factTrue I am wondering it it is possible to define combinators to hide the structure of the grammar from the user to some extent, so that the user can simply write things like sc = True .||.True .||. True .&&. False or sc = const True .||. const True .||. const True .&&. const False That is the user does not have to worry about the distinction between terms and factors (which exists solely for precedence in this case). Or is it a better idea to just remove the precedence rules from the types and move it the part of the code that evaluates the expressions? Rahul

3 2

Java 1.5 parser in Haskell
by tim.b 07 Aug '07

07 Aug '07

Does anyone know of a fairly complete Java 1.5 parser and abstract syntax in Haskell? I've looked around quite a bit to no avail. Thanks, - Tim -- View this message in context: http://www.nabble.com/Java-1.5-parser-in-Haskell-tf4227017.html#a12025365 Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

2 1

Type without a data constructor?
by Rahul Kapoor 07 Aug '07

07 Aug '07

Most examples for defining algebraic types include data constructors like so: data Tree a = Tip | Node a (Tree a) (Tree a) I by mistake defined a type which did not specify a data constructor : data SearchCondition = Term Bool | SearchCondition :||: (Term Bool) data Term a = Constant a sc :: SearchCondition sc = Term True is ok, but sc :: SearchCondition sc = Constant True is not (though this is what I intended to capture!). So the question is what are types with no constructors good for? A simple example would be appreciated. Rahul

5 5

[Fwd: PADL 2008: Call for Papers]
by Paul Hudak 07 Aug '07

07 Aug '07

-------- Original Message -------- Subject: PADL 2008: Call for Papers Date: Sat, 4 Aug 2007 19:25:58 -0500 (CDT) From: Gopal Gupta <gupta(a)utdallas.edu> [ Colleagues, note that this will be the 10th PADL; We strongly urge you to submit papers, the deadline is only 3 weeks way] CALL FOR PAPERS!!! Tenth International Symposium on Practical Aspects of Declarative Languages 2008 (PADL '08) http://www.ist.unomaha.edu/padl2008/ San Francisco, USA January 7-8, 2008 Co-located with ACM POPL'08 Declarative languages build on sound theoretical bases to provide attractive frameworks for application development. These languages have been successfully applied to vastly different real-world situations, ranging from data base management to active networks to software engineering to decision support systems. New developments in theory and implementation have opened up new application areas. At the same time, applications of declarative languages to novel problems raises numerous interesting research issues. Well-known questions include designing for scalability, language extensions for application deployment, and programming environments. Thus, applications drive the progress in the theory and implementation of declarative systems, and benefit from this progress as well. PADL is a forum for researchers and practitioners to present original work emphasizing novel applications and implementation techniques for all forms of declarative concepts, including, functional, logic, constraints, etc. Topics of interest include: * innovative applications of declarative languages; * declarative domain-specific languages and applications; * practical applications of theoretical results; * new language developments & their impact on applications; * evaluation of implementation techniques on practical applications; * novel uses of declarative languages in the classroom; and * practical experiences PADL 08 welcomes new ideas and approaches pertaining to applications and implementation of declarative languages. PADL 08 will be co-located with the ACM POPL. IMPORTANT DATES AND SUBMISSION GUIDELINES Paper Submission: August 24, 2007 Notification: September 27, 2007 Camera-ready: October 23, 2007 Symposium: January 7-8, 2008 Authors should submit an electronic copy of the full paper (written in English) in Postscript (Level 2) or PDF. Papers must be no longer than 15 pages, written in 11-point font and with single spacing. Since the final proceedings will be published as Lecture Notes in Computer Science by Springer Verlag, authors are strongly encouraged to use the LNCS paper formatting guidelines for their submission. Each submission must include on its first page the paper title; authors and their affiliations; contact author's email and postal addresses, telephone and fax numbers, abstract, and three to four keywords. The keywords will be used to assist us in selecting appropriate reviewers for the paper. If electronic submission is impossible, please contact the program chair for information on how to submit hard copies. MOST PRACTICAL PAPER AWARD The Most Practical Paper award will be given to the submission that is judged by the program committee to be the best in terms of practicality, originality, and clarity of presentation. The program committee may choose not to make an award, or to make multiple awards. Contacts: For information about papers and submissions, please contact the Program Chair: Paul Hudak PC co-Chair - PADL 2008 Department of Computer Science Yale University P.O. Box 208285 New Haven, CT 06520 - 8285 Email: hudak(a)cs.yale.edu David S. Warren PC co-Chair - PADL 2008 Department of Computer Science Stony Brook University Stony Brook, NY Email: warren(a)cs.sunysb.edu For other information about the conference, please contact: Hai-Feng Guo General Chair - PADL 2008 Department of Computer Science College of Information Science & Technology University of Nebraska at Omaha Omaha, NE, U.S.A. Email: haifengguo(a)mail.unomaha.edu Sponsored by: COMPULOG Americas (http://www.cs.nmsu.edu/~complog) and University of Nebraska at Omaha

1 0

ICFP07 Call for Participation
by Matthew Fluet (ICFP Publicity Chair) 06 Aug '07

06 Aug '07

===================================================================== Call for Participation The 12th ACM SIGPLAN International Conference on Functional Programming (ICFP 2007) http://www.informatik.uni-bonn.de/~ralf/icfp07.html Freiburg, Germany, 1-3 October 2007 ===================================================================== ICFP 2007 provides a forum for researchers and developers to hear about the latest work on the design, implementations, principles, and uses of functional programming. The conference covers the entire spectrum of work, from practice to theory, including its peripheries. Preliminary program: * http://www.informatik.uni-bonn.de/~ralf/schedule.html * Invited speakers: + John Hughes (Chalmers University of Technology) + Frank Pfenning (Carnegie Mellon University) + John Lloyd (Australian National University) * The Program committee has *deliberately* created extra breaks so as to give participants more time to talk with colleagues. Schedule including related workshops: * 30 Sep: ACM SIGPLAN Haskell Workshop * 30 Sep: ACM SIGPLAN Workshop on Scheme and Functional Programming * 1-3 Oct: ICFP07 * 4 Oct: ACM SIGPLAN Commercial Users of Functional Programming * 4 Oct: ACM SIGPLAN Workshop on Mechanizing Metatheory * 5 Oct: ACM SIGPLAN Erlang Workshop * 5 Oct: ACM SIGPLAN Workshop on ML * 5 Oct: ACM SIGPLAN Programming Languages meets Program Verification Registration information: * http://proglang.informatik.uni-freiburg.de/ICFP2007/registration.shtml * Early registration deadline: September 7, 2007 Accommodations information: * http://proglang.informatik.uni-freiburg.de/ICFP2007/accommodation.shtml * Conference reservation/rate deadline: September 1, 2007 * September/October is Freiburg's main tourist season; participants are advised to book rooms as early as possible. Conference organizers: * General Chair: Ralf Hinze (Universität Bonn) * Program Chair: Norman Ramsey (Harvard University) * Local Arrangements Chair: Peter Thiemann (Universität Freiburg) * Workshop Co-Chairs: Graham Hutton (University of Nottingham) and Matthias Blume (Toyota Technological Institute at Chicago) * Programming Contest Chair: Johan Jeuring (Universiteit Utrecht) * Publicity Chair: Matthew Fluet (Toyota Technological Institute at Chicago)

1 0

Zippers, Random Numbers & Terrain
by Thomas Conway 06 Aug '07

06 Aug '07

Hi All, To amuse myself while waiting for test-runs to complete, I was thinking about random terrain generation. I came across a bunch of nice posts by Torben Mogensen, where he describes a neat way of constructing random terrains by recursively subdividing right angled isosceles triangles. It got me thinking - it's all well and good subdividing to give more detail as you zoom in, but what about when you zoom out? This got me thinking that it would be cool to make an infinite terrain generator using a zipper, so you can zoom in/out infinitely, and by implication, infinitely in any direction. One of the key components that seems to be necessary is a random number generator zipper. In Mogensen's scheme, you have a number associated with each point, and when you subdivide, you create a new RNG seed from the numbers at each end of the hypotenuse which you are bisecting. These numbers are used to generate height variation. The trick, is to make the combination order independent (e.g. xor). This is easy for zooming in, but it's not clear how to do this for zooming out. It's probably sufficient to assume a (parameterizable) hashing/mixing scheme, and to simply number the nodes in some deterministic fashion. The subdivision is binary, so we could number the children deterministically. If we use "decimals", from some arbitrary starting point, we can extend in the "fractional" direction when we zoom in, and extend in the "whole number" direction. I'm only just discovering zippers, so my question to the learned members of this forum is: Am I on the right track? Is a scheme like this going to work? cheers, Tom -- Dr Thomas Conway drtomc(a)gmail.com Silence is the perfectest herald of joy: I were but little happy, if I could say how much.

6 8

how to make haskell faster than python at finding primes?
by Alex Jacobson 06 Aug '07

06 Aug '07

This implementation of calculating 10000 primes (compiled with GHC -O2) is 25% slower than the naive python implementation. Shouldn't it be faster? Am I doing something obviously stupid? primes = map (\(x,_,_)->x) $ filter (\(_,isP,_)->isP) candidates candidates = (2,True,[]):(3,True,[]): map next (tail candidates) next (candidate,isP,modCounts) = let newCounts = map incrMod2 modCounts in -- accumulate mods (candidate+2 -- we only need to bother with odd numbers ,(isPrime newCounts) -- track whether this one is prime ,if isP then (candidate,2):newCounts else newCounts) -- add if prime isPrime = and . map ((/=0).snd) incrMod2 (p,mc) = let mc' = mc+2 in if mc'<p then (p,mc') else if mc'>p then (p,1) else (p,0) Note: It is shorter than the python, but I would have assumed that GHC could deliver faster as well. -Alex-

6 10

Navigating Haddock
by David Pollak 06 Aug '07

06 Aug '07

Howdy, As I'm starting to learn the Haskell libraries, I'm having a less than fun time trying to figure out what functions operate on what types. For example, in the documentation for HaXml, there's a description of Document: http://www.cs.york.ac.uk/fp/HaXml/HaXml/Text-XML-HaXml-Types.html#4 However, I can't find any links to what functions accept document as a parameter. Am I missing some magic? A couple of other questions... Can ByteStrings be substituted anywhere that takes a String (e.g., HaXml xmlParse)? Is there a way to deal with UTF-8 encoded byte arrays converting them to Strings other than http://www.gatago.org/fa/haskell/52409638.html ? Thanks, David -- lift, the fast, powerful, easy web framework http://liftweb.net

4 3

c2hs and structs?
by Magnus Therning 06 Aug '07

06 Aug '07

I can't seem to find any information on how to deal with C functions that return a (pointer to a) struct. C2hs tells me there's no automatic support for marshalling structs (I'm using version 0.14.5). If I'm to do it by hand, is there a preferred way? (E.g. make the type adhere to the type Storable.) /M -- Magnus Therning (OpenPGP: 0xAB4DFBA4) magnus(a)therning.org Jabber: magnus.therning(a)gmail.com http://therning.org/magnus Unreadable code, Why would anyone use it? Learn a better way. -- Geoff Kuenning's contribution to the 2004 Perl Haiku Contest, Haikus about Perl - 'Dishonerable Mention' winner

2 1

Perfect example
by Jon Harrop 06 Aug '07

06 Aug '07

Any suggestions for a perfect example that uniquely demonstrates the benefits of the Haskell language compared to other languages? -- Dr Jon D Harrop, Flying Frog Consultancy Ltd. OCaml for Scientists http://www.ffconsultancy.com/products/ocaml_for_scientists/?e

7 6

Re: creating graphics the functional way
by Shin-Cheng Mu 06 Aug '07

06 Aug '07

On 05/08/07, Frank Buss <fb(a)frank-buss.de> wrote: > Is it possible to write functions with an arbitrary number of > arguments? > Would be nice if the average function would accept any number of pixel > values. You may be interested to see Oleg Kiselyov's discussion on polyvariadic functions in Haskell: http://okmij.org/ftp/Haskell/types.html#polyvar-fn sincerely, Shin

1 0

Re: [Haskell-cafe] how to make haskell faster than python at finding primes?
by dons＠cse.unsw.edu.au 06 Aug '07

06 Aug '07

ptanimoto: > I haven't tried any of those codes, but Don did you notice you're > calculating 1,000 primes while Alex was talking about 10,000? Yeah, I tested both with 1k and 10k :)

1 0

Re: [Haskell-cafe] How odd...
by Andrew Coppin 06 Aug '07

06 Aug '07

> >> Um... why would infinity * 0 be NaN? That doesn't make sense... > Infinity times anything is Infinity. Zero times anything is zero. So > what should Infinity * zero be? There isn't one right answer. In > this case the "morally correct" answer is zero, but in other contexts > it might be Infinity or even some finite number other than zero. I don't follow. Infinity times any positive quantity gives positive infinity. Infinity times any negative quantity gives negative infinity. Infinity times zero gives zero. What's the problem? > Consider 0.0 / 0.0, which also evaluates to NaN. Division by zero is *definitely* undefined. (The equation 0 * k = v has no solutions.)

3 2

Re: Developing Programs and Proofs Spontaneously using GADT
by Shin-Cheng Mu 06 Aug '07

06 Aug '07

Thanks for the comments. I will take a look at the type family extension. The definition of plusFn proposed by Jim Apple worked nicely. The solution from apfelmus works after fixing a small typo: > newtype Equal a b = Proof (forall f . f a -> f b ) > > newtype Succ f a = InSucc { outSucc :: f (S a) } > > equalZ :: Equal Z Z > equalZ = Proof id > > equalS :: Equal m n -> Equal (S m) (S n) -- was (S n) (S m) > equalS (Proof eq) = Proof (outSucc . eq . InSucc) > > plusFn :: Plus m n i -> Plus m n k -> Equal i k > plusFn PlusZ PlusZ = Proof id > plusFn (PlusS x) (PlusS y) = equalS (plusFn x y) Also thanks to Derek Elkins and Dan Licata for interesting discussions about dependent sum/product. :) sincerely, Shin

1 0

Re: monad subexpressions
by Brian Hulley 06 Aug '07

06 Aug '07

On Fri Aug 3 06:06:31 EDT Neil Mitchell wrote: > What are the semantics of > do b >> f (<- a) > where does the evaluation of a get lifted to? I suggest the execution of (a) should be done immediately before the action obtained by applying the monadic function whose argument it is part of: do b >> ( a >>= \ra -> f ra) Similarly, I'd desugar if (<- a) then f (<- b) else g (<- c) to a >>= \ra -> if ra then (b >>= \rb -> f rb) else (c >>= \rc -> g rc) I think it would just be confusing to have to think about lines in the "do" block since "do" blocks are just syntactic sugar. The only possible thing that might be needed by the "do" block is to define what monad the action should be evaluated in. Perhaps the rule could be that if (<- a) occurs in some expression the compiler should search for the nearest enclosing "do" block to identify which monad (a) should be evaluated in, then should again search outwards from the expression (<- a) to find the nearest enclosing expression (mexp) which yields a result in that same monad, then desugar to (a >>= \ra -> mexp') where mexp' is obtained from mexp by replacing that occurrence of (<- a) by (ra). (Evaluations would be done in the same order as depth first traversal of their occurrences in mexp) Regarding objections by others about (<- a) being confused with a section, (<-) is not a valid operator therefore it can't be part of a section so no confusion should arise imho... Best regards, Brian.

1 0

Knuth Morris Pratt for Lazy Bytestrings implementation
by Justin Bailey 05 Aug '07

05 Aug '07

I've implemented KMP string searching for lazy bytestrings, and I'd like some help improving the performance of the code. I'd also like to know if it doesn't look correct - I've tested it pretty extensively but you never know ... I've been testing on a 7 MB file, where the search sequence is not found. Using strict byestrings, lazy bytestrings, and regular strings, I've found my algorithm is about twice as slow as the strict version. Surprisingly, the strict version is a little bit *slower* than the regular strings version. Thanks for any comments or help! Justin

7 14

Haskell FCGI server.
by George Moschovitis 05 Aug '07

05 Aug '07

Dear devs, is it possible to create a FCGI server that listens to a specific port using the Haskell FCGI library? The front end web server would then communicate with this back end FCGI server through this port. A small example would be really appreciated. thanks, George. -- http://nitroproject.org http://phidz.com http://blog.gmosx.com http://cull.gr http://www.joy.gr http://www.me.gr

2 1

FreeBSD/amd64 support?
by Tim Newsham 05 Aug '07

05 Aug '07

I noticed that there is no official FreeBSD/amd64 port yet, although there's a binary with a working "ghc" but non-working "ghci." Has there been any progress on the amd64 port? Any estimate on when it will be available? Any known workarounds (is it possible to install and run an x86 ghc in FreeBSD/amd64)? Is hardware access holding anyone up? Tim Newsham http://www.thenewsh.com/~newsham/

1 0

Developing Programs and Proofs Spontaneously using GADT
by Shin-Cheng Mu 05 Aug '07

05 Aug '07

I am curious about the possibility of developing Haskell programs spontaneously with proofs about their properties and have the type checker verify the proofs for us, in a way one would do in a dependently typed language. In the exercise below, I tried to redo part of the merge-sort example in Altenkirch, McBride, and McKinna's introduction to Epigram [1]: deal the input list into a binary tree, and fold the tree by the function merging two sorted lists into one. The property I am going to show is merely that the length of the input list is preserved. Given that dependent types and GADTs are such popular topics, I believe the same must have been done before, and there may be better ways to do it. If so, please give me some comments or references. Any comments are welcomed. > {-# OPTIONS_GHC -fglasgow-exts #-} To begin with, we define the usual type-level representation of natural numbers and lists indexed by their lengths. > data Z = Z deriving Show > data S a = S a deriving Show > data List a n where > Nil :: List a Z > Cons :: a -> List a n -> List a (S n) 1. Append To warm up, let us see the familiar "append" example. Unfortunately, unlike Omega, Haskell does not provide type functions. I am not sure which is the best way to emulate type functions. One possibility is to introduce the following GADT: > data Plus m n k where --- m + n = k > PlusZ :: Plus Z n n > PlusS :: Plus m n k -> Plus (S m) n (S k) such that Plus m n k represents a proof that m + n = k. Not having type functions, one of the possible ways to do append is to have the function, given two lists of lengths m and n, return a list of length k and a proof that m + n = k. Thus, the type of append would be: append :: List a m -> List a n -> exists k. (List a k, Plus m n k) In Haskell, the existential quantifier is mimicked by forall. We define: > data DepSum a p = forall i . DepSum (a i) (p i) The term "dependent sum" is borrowed from the Omega tutorial of Sheard, Hook, and Linger [2] (why is it called a sum, not a product?). The function append can thus be defined as: > append :: List a m -> List a n -> DepSum (List a) (Plus m n) > append Nil ys = DepSum ys PlusZ > append (Cons x xs) ys = > case (append xs ys) of > DepSum zs p -> DepSum (Cons x zs) (PlusS p) Another possibility is to provide append a proof that m + n = k. The type and definition of of append would be: < append :: Plus m n k -> List a m -> List a n -> List a k < append PlusZ Nil ys = ys < append (PlusS pf) (Cons x xs) ys = Cons x (append pf xs ys) I thought the second append would be more difficult to use: to append two lists, I have to provide a proof about their lengths! It turns out that this append actually composes easier with other parts of the program. We will come to this later. 2. Some Lemmas Here are some lemmas represented as functions on terms. The function, for example, converts a proof of m + (1+n) = k to a proof of (1+m) + n = k. > incAssocL :: Plus m (S n) k -> Plus (S m) n k > incAssocL PlusZ = PlusS PlusZ > incAssocL (PlusS p) = PlusS (incAssocL p) > incAssocR :: Plus (S m) n k -> Plus m (S n) k > incAssocR (PlusS p) = plusMono p > plusMono :: Plus m n k -> Plus m (S n) (S k) > plusMono PlusZ = PlusZ > plusMono (PlusS p) = PlusS (plusMono p) For example, the following function revcat performs list reversal by an accumulating parameter. The invariant we maintain is m + n = k. To prove that the invariant holds, we have to use incAssocL. > revcat :: List a m -> List a n -> DepSum (List a) (Plus m n) > revcat Nil ys = DepSum ys PlusZ > revcat (Cons x xs) ys = > case revcat xs (Cons x ys) of > DepSum zs p -> DepSum zs (incAssocL p) 3. Merge Apart from the proof manipulations, the function merge is not very different from what one would expect: > merge :: Ord a => List a m -> List a n -> DepSum (List a) (Plus m n) > merge Nil ys = DepSum ys PlusZ > merge (Cons x xs) Nil = append (Cons x xs) Nil > merge (Cons x xs) (Cons y ys) > | x <= y = case merge xs (Cons y ys) of > DepSum zs p -> DepSum (Cons x zs) (PlusS p) > | otherwise = case merge (Cons x xs) ys of > DepSum zs p -> DepSum (Cons y zs) (plusMono p) The lemma plusMono is used to convert a proof of m + n = k to a proof of m + (1+n) = 1+k. 4. Sized Trees We also index binary trees by their sizes: > data Tree a n where > Nul :: Tree a Z > Tip :: a -> Tree a (S Z) > Bin :: Tree a n1 -> Tree a n -> > (Plus p n n1, Plus n1 n k) -> Tree a k The two trees given to the constructor Bin have sizes n1 and n respectively. The resulting tree, of size k, comes with a proof that n1 + n = k. Furthermore, we want to maintain an invariant that n1 either equals n, or is bigger than n by one. This is represented by the proof Plus p n n1. In the definition of insertT later, p is either PlusZ or PlusS PlusZ. 5. Lists to Trees The function insertT inserts an element into a tree: > insertT :: a -> Tree a n -> Tree a (S n) > insertT x Nul = Tip x > insertT x (Tip y) = Bin (Tip x) (Tip y) (PlusZ, PlusS PlusZ) > insertT x (Bin t u (PlusZ, p)) = > Bin (insertT x t) u (PlusS PlusZ, PlusS p) > insertT x (Bin t u (PlusS PlusZ, p)) = > Bin t (insertT x u) (PlusZ, PlusS (incAssocR p)) Note that whenever we construct a tree using Bin, the first proof, corresponding to the difference in size of the two subtrees, is either PlusZ or PlusS PlusZ. The counterpart of foldr on indexed list is defined by: > foldrd :: (forall k . (a -> b k -> b (S k))) -> b Z > -> List a n -> b n > foldrd f e Nil = e > foldrd f e (Cons x xs) = f x (foldrd f e xs) The result is also an indexed type (b n). The function deal :: List a n -> Tree a n, building a tree out of a list, can be defined as a fold: > deal :: List a n -> Tree a n > deal = foldrd insertT Nul 6. Trees to Lists, and Merge Sort The next step is to fold through the tree by the function merge. The first two clauses are simple: > mergeT :: Ord a => Tree a n -> List a n > mergeT Nul = Nil > mergeT (Tip x) = Cons x Nil For the third clause, one would wish that we could write something as simple as: mergeT (Bin t u (_,p1)) = case merge (mergeT t) (mergeT u) of DepSum xs p -> xs However, this does not type check. Assume that t has size n1, and u has size n. The DepSum returned by merge consists of a list of size i, and a proof p of type Plus m n i, for some i. The proof p1, on the other hand, is of type P m n k for some k. Haskell does not know that Plus m n is actually a function and cannot conclude that i=k. To explicitly state the equality, we assume that there is a function plusFn which, given a proof of m + n = i and a proof of m + n = k, yields a function converting an i in any context to a k. That is: plusFn :: Plus m n i -> Plus m n k -> (forall f . f i -> f k) The last clause of mergeT can be written as: > mergeT (Bin t u (_,p1)) = > case merge (mergeT t) (mergeT u) of > DepSum xs p -> plusFn p p1 xs How do I define plusFn? I would like to employ the techniques related to equality types [3,4,5], but currently I have not yet figured out how. I've merely produced a version of plusFn specialised to List a: > plusFn :: Plus m n h -> Plus m n k -> List a h -> List a k > plusFn PlusZ PlusZ xs = xs > plusFn (PlusS p1) (PlusS p2) (Cons x xs) = > Cons x (plusFn p1 p2 xs) Needless to say this is not satisfactory. Now that we have both deal and mergeT, merge sort is simply their composition: > msort :: Ord a => List a n -> List a n > msort = mergeT . deal The function mergeT can be defined using a fold on trees as well. Such a fold might probably look like this: > foldTd :: (forall m n k . Plus m n k -> b m -> b n -> b k) > -> (a -> b (S Z)) -> b Z > -> Tree a n -> b n > foldTd f g e Nul = e > foldTd f g e (Tip x) = g x > foldTd f g e (Bin t u (_,p)) = > f p (foldTd f g e t) (foldTd f g e u) mergeT :: Ord a => Tree a n -> List a n mergeT = foldTd merge' (\x -> Cons x Nil) Nil where merge' p1 xs ys = case merge xs ys of DepSum xs p -> plusFn p p1 xs I am not sure whether this is a "reasonable" type for foldTd. 7. Passing in the Proof as an Argument Previously I thought the second definition of append would be more difficult to use, because we will have to construct a proof about the lengths before calling append. In the context above, however, it may actually be more appropriate to use this style of definitions. An alternative definition of merge taking a proof as an argument can be defined by: < merge :: Ord a => Plus m n k -> List a m -> < List a n -> List a k < merge PlusZ Nil ys = ys < merge pf (Cons x xs) Nil = append pf (Cons x xs) Nil < merge (PlusS p) (Cons x xs) (Cons y ys) < | x <= y = Cons x (merge p xs (Cons y ys)) < | otherwise = Cons y (merge (incAssocL p) (Cons x xs) ys) A definition of mergeT using this definition of merge follows immediately because we can simply use the proof coming with the tree: < mergeT :: Ord a => Tree a n -> List a n < mergeT Nul = Nil < mergeT (Tip x) = Cons x Nil < mergeT (Bin t u (_,p1)) = < merge p1 (mergeT t) (mergeT u) I don't know which approach can be called more "natural". References [1] Thorsten Altenkirch, Conor McBride, and James McKinna. Why Dependent Types Matter. http://www.e-pig.org/downloads/ydtm.pdf [2] Tim Sheard, James Hook, and Nathan Linger. GADTs + Extensible Kinds = Dependent Programming. http://web.cecs.pdx.edu/~sheard/papers/GADT+ExtKinds.ps [3] James Cheney, Ralf Hinze. A lightweight implementation of generics and dynamics. [4] Stephanie Weirich, Type-safe cast: (functional pearl), ICFP 2000. [5] Arthur I. Baars , S. Doaitse Swierstra, Typing dynamic typing, ACM SIGPLAN Notices, v.37 n.9, p.157-166, September 2002 Appendix. Auxiliary Functions > instance Show a => Show (List a n) where > showsPrec _ Nil = ("[]"++) > showsPrec _ (Cons x xs) = shows x . (':':) . shows xs > instance Show (Plus m n k) where > showsPrec _ PlusZ = ("pZ"++) > showsPrec p (PlusS pf) = showParen (p>=10) (("pS " ++) . > showsPrec 10 pf) > instance Show a => Show (Tree a n) where > showsPrec _ Nul = ("Nul"++) > showsPrec p (Tip x) = showParen (p >= 10) (("Tip " ++) . shows x) > showsPrec p (Bin t u pf) = > showParen (p>=10) > (("Bin "++) . showsPrec 10 t . (' ':) . showsPrec 10 u . > (' ':) . showsPrec 10 pf)

5 4

Question about arrows
by Lewis-Sandy, Darrell 04 Aug '07

04 Aug '07

Is there a class property of the Control.Arrow class that represents the evaluatation of an arrow: eval :: (Arrow a)=>a b c->b->c I am writing some higher order code that I would like to work with either functions or partial functions (implemented as balanced binary search trees) and don't want to write separate instances for each concrete arrow type. For example, consider the example below: divideAndConquer::( Arrow a, Bifunctor m)=>(m c y->y)->a b c->(x->m b x)->x->y divideAndConquer combine solve divide = combine.(bimap (eval solve) (divideAndConquer combine solve divide)).divide that implements datatype generic divide and conquer. divide encodes how to decompose a problem of type x into subproblems, solve encodes how to solve indivisible sub-problems, and combine encodes how to put the sub-solutions together. The branching strategy is encoded in the bifunctor, and the use of eval faciliatates either evaluating a function or looking up solutions in a table.

3 2

Re: [Haskell-cafe] Re: Re: monad subexpressions
by david48 04 Aug '07

04 Aug '07

Sorry for the double post, I posted with the wrong email address and haskell-cafe rejected it. On 8/3/07, Neil Mitchell <ndmitchell(a)gmail.com> wrote: > > Right. In effect, as a matter of fact, the notation > > > > x <- a > > > > would become equivalent to > > > > let x = (<- a) > > Hmm, interesting. Consider: > > let x = 12 > let x = (<- x) Wouldn't that be forbidden ? I'd expect the x in ( <- x ) have to be of type m a. If you meant : x <- return 12 let x = ( <- x ) Then I imagine it would turn into x <- return 12 x >>= \tx -> let x = tx in .... Isn't that correct ?

4 3

When is waitForProcess not necessary?
by Dave Bayer 04 Aug '07

04 Aug '07

If one is calling runInteractiveCommand for a "sure-thing" returning a small amount of output (say, "ls" for a modest directory"), is it necessary to call waitForProcess? My waitForProcess calls came under scrutiny when I tried to GHC profile a threaded process, which isn't possible. It turns out that my programs run faster if they don't call waitForProcess, and it sure seems empirically that they never fail to run correctly. It would seem to me that in a lazy language, later code wouldn't presume it was looking at an entire string until the actual EOF came through, completing the string. So at the end of a program, with nothing else to do but wait, why not wait "implicitly" rather than via an explicit call to waitForProcess? What am I missing? (I've searched this forum; an interesting example is runCommand in http://happs.org/HAppS/src/HAppS/Util/Common.hs but I'm asking why this isn't overkill in my scenario. I'm actually calling Markdown.pl on tiny files (source code of lengths a human would read), and it is certainly sluggish enough to be a fair test.)

6 8

Re: RE [Haskell-cafe] Monad Description For Imperative
by Greg Meredith 04 Aug '07

04 Aug '07

Haskellians, i am delighted to see vigorous exchange that actually resulted in change of positions. i confess i was going to give up, but glad others stepped into the breach. This is yet another indication of what an unusual community this is. Best wishes, --greg Date: Fri, 3 Aug 2007 13:43:32 +1200 From: ok <ok(a)cs.otago.ac.nz> Subject: Re: RE [Haskell-cafe] Monad Description For Imperative To: haskell-cafe Cafe <haskell-cafe(a)haskell.org> Message-ID: <8575BD1C-2113-4D48-A3D4-BDFF41238BB9(a)cs.otago.ac.nz> Content-Type: text/plain; charset=US-ASCII; delsp=yes; format=flowed I asked "How is IO a functor"? On 3 Aug 2007, at 11:50 am, Dan Piponi wrote: > IO is a fully paid up Monad in the categorical sense. The category is > the category whose objects are types and whose arrows are functions > between those types. IO is a functor. The object a maps to IO a. An > arrow f::a->b maps to (>>= return . f)::IO a -> IO b and that can be > used to make IO an instance of Functor. The natural transforms eta and > mu are called return and join. Please go over this again, but slowly this time. You have convinced me, but I'd like to understand the details a little better. I see that any type constructor TC :: * -> * is halfway to being a functor on this category of types. It acts on the objects in the obvious way, so the next step is to see about the arrows. If f :: a -> b then we want TC f :: TC a -> TC b such that TC (f . g) = TC f . TC g and TC (id::a->a) = id :: TC a -> TC a Now this is precisely the Haskell Functor class, so TC is the object part and fmap is the arrow part. You say that (>>= return . f) can be used to make [a Monad] an instance of Functor. Try it... by golly it's true. I see: fmap f = (>>= return . f). So why *aren't* Monads already set up using the type class machinery to always *be* Functors in Haskell? Isn't it bound to confuse people if monads are functors but Monads are not Functors? This is especially puzzling because Maybe, [], and IO already *are* Functors, but the way this is done makes it look accidental, not like the fundamental property of Monads it apparently is. (By the way, I note that the on-line documentation for Control.Monad glosses >>= as "Sequentially composes two actions...".) -- L.G. Meredith Managing Partner Biosimilarity LLC 505 N 72nd St Seattle, WA 98103 +1 206.650.3740 http://biosimilarity.blogspot.com

1 0

Re: [Haskell-cafe] Re: monad subexpressions
by Mirko Rahn 03 Aug '07

03 Aug '07

>>> rewrite *p++=*q++ in haskell? >> *p = *(p+1) ; *q = *(q+1) > If that's true then GCC has gone insane, because they are completely different. Of course you are right, I just observed at the wrong place..., sorry for that. > Though, as any C programmer knows, you really should be using > memcpy() I like to hear that you would reject it either. /BR -- -- Mirko Rahn -- Tel +49-721 608 7504 -- --- http://liinwww.ira.uka.de/~rahn/ ---

1 0

GHC, GLUT and OS X
by Paul L 03 Aug '07

03 Aug '07

I'm trying to get cross platform GLUT/OpenGL program to run, but even the simplest code hang on OS X with GHC 6.6 or GHC 6.6.1 import Graphics.UI.GLUT import Graphics.Rendering.OpenGL main = do getArgsAndInitialize createAWindow "Hello window" mainLoop createAWindow windowName = do createWindow windowName displayCallback $= clear [ColorBuffer] Has anyone been successful at getting GLUT to work on OS X? Regards, Paul L

3 5

Re: RE [Haskell-cafe] Monad Description For Imperative
by Greg Meredith 03 Aug '07

03 Aug '07

Ok, You wrote But please, let's keep one foot in the real world if possible. > Monads were invented to solve the "how do I do imperative programming > in a pure functional language" problem. > This is more than a little revisionist. Monads have been the subject of mathematical study before people had an inkling that they might apply to problems in computer science. Moggi didn't invent them, but noticed that they might have an application to issues of composition in computation. It is really intriguing that they do such a remarkable job of organizing notions of update and were not invented with this application in mind. So, revising history thus would be a real loss. Best wishes, --greg -- L.G. Meredith Managing Partner Biosimilarity LLC 505 N 72nd St Seattle, WA 98103 +1 206.650.3740 http://biosimilarity.blogspot.com

4 5

positive Int
by brad clawsie 03 Aug '07

03 Aug '07

as far as i know, the haskell standard does not define a basic Int type that is limited to positive numbers. would a type of this kind not potentially allow us to make stronger verification statements about certain functions? for example, 'length' returns an Int, but in reality it must always return a value 0 or greater. a potential counter-argument would be the need to possibly redefine Ord etc for this more narrow type...

8 9

Re: [Haskell-cafe] ANNOUNCE: Dimensional 0.6 -- Statically checked physical dimensions
by Björn Buckwalter 03 Aug '07

03 Aug '07

David Roundy wrote: > On Thu, Aug 02, 2007 at 10:27:47PM +0200, Björn Buckwalter wrote: > > I am also assuming that the CGS system would not be employed when > > working with temperature, amount or luminosity. This is evident in > > the below type signatures where I have assumed zero extent in the > > temperature, amount and luminosity dimensions. If this is incorrect > > I would appreciate pointers to the CGS representation of these > > dimensions. > > > > Please correct and inform me if my assumptions are wrong! > > The temperature units are the same in CGS as in MKS (Kelvin). Which implies that CGS is applicable to temperatures... what is the (conventional) dimension of temperature in CGS? Is it the same as for Energy (L^2 M^1 T^-2)? > > This is a very rudimentary implementation. To make it more practical > > a significant number of quantities and units, in particularly those > > commonly used with the CGS, would need to be added. In the mean > > time all units defined for the SI can be used with the CGS by > > applying 'fromSI' to quantities defined from the SI units. > > > > If anyone is willing to add quantities/units (or other enhancements) > > I will happily to accept patches. Personally I do not expect to use > > this module and therefore do not intend to invest much more time > > in it. If the module has other users I might reconsider. > > > > And of course, another direction of future work is to define > > additional systems (e.g. natural, relativistic) using this module > > as a template. I imagine this should be fairly straight forward. > > When atomic units are implemented, this could be useful for me... but alas > I very seldom use Haskell for physics, and the effort to learn these > modules seems unlikely to pay off soon. :( Learning to use the modules should require little effort. Learning enough to implement the atomic system of units would require significant effort though. Unfortunately I don't see myself implementing atomic units, at lease not anytime soon. Thanks, Bjorn

1 0

ANNOUNCE: Dimensional 0.6 -- Statically checked physical dimensions
by Björn Buckwalter 03 Aug '07

03 Aug '07

Dear all, I am pleased to announce version 0.6 of the Dimensional library. Dimensional is a library providing data types for performing arithmetic with physical quantities and units. Information about the physical dimensions of the quantities/units is embedded in their types and the validity of operations is verified by the type checker at compile time. The boxing and unboxing of numerical values as quantities is done by multiplication and division with units. The library is designed to, as far as is practical, enforce/encourage best practices [1] of unit usage. Noteworthy changes/additions since the previous formal announcement (version 0.4) are: - All quantities and SI units from [1] have been added. - A Prelude replacement with the SI units and dimensional operators (+, *, ^...) is provided for convenience. - Interface to Data.Time using 'fromDiffTime' and 'toDiffTime'. - Phantom type tags make extended dimensions safer. - Experimental CGS units with type safe conversions to/from SI. See appended literate Haskell module for details. Additional information and code is available from the project web site [3]. Thank you, Bjorn Buckwalter [1] http://physics.nist.gov/Pubs/SP811/ [2] http://www.haskell.org/pipermail/haskell/2007-May/019496.html [3] http://code.google.com/p/dimensional/ ~~~~~~~~~~ BEGIN 'Buckwalter/Dimensional/CGS.lhs' ~~~~~~~~~~ Buckwalter.Dimensional.CGS -- CGS system of units Bjorn Buckwalter, bjorn.buckwalter(a)gmail.com License: BSD3 *** EXPERIMENTAL *** = Introduction = This module was prompted by an email from Chuck Blake[1]. He asked if the Dimensional library could support other systems of units than SI, in particular systems such as the centimeter-gram-second (CGS) system where fractional exponents of dimensions occur. He also wondered whether it was possible to convert quantities between different systems while statically ensuring that a given conversion was valid. In this module we show that we can in a straight forward manner support systems with rational exponents, provided that the rationals that may be encountered are known a priori. As an example we provide a rudimentary implementation of the CGS system. We also show that we can indeed statically prohibit invalid conversions between different systems. = Caveats = I'm ignorantly assuming that when working with the CGS (or MKS) system you will only (meaningfully?) encounter half-exponents and only of the length and mass dimensions. Of course, in other systems other rational exponents may be encountered. I am also assuming that the CGS system would not be employed when working with temperature, amount or luminosity. This is evident in the below type signatures where I have assumed zero extent in the temperature, amount and luminosity dimensions. If this is incorrect I would appreciate pointers to the CGS representation of these dimensions. Please correct and inform me if my assumptions are wrong! = Preliminaries = > {-# OPTIONS_GHC -fglasgow-exts -fallow-undecidable-instances #-} > module Buckwalter.Dimensional.CGS where > import Prelude ( undefined, Num, Fractional, Floating, Show, recip, Double ) > import qualified Prelude > import Buckwalter.Dimensional hiding ( DLength, DMass, DTime, DElectricCurrent ) > import Buckwalter.Dimensional.Quantities as SIQ > import qualified Buckwalter.Dimensional.SIUnits as SI > import qualified Buckwalter.NumType as N > import Buckwalter.NumType ( Neg2, Neg1, Zero, Pos, Pos1, Pos2, Pos3, NumType ) > import Buckwalter.NumType ( neg2, neg1, zero, pos1, pos2, pos3 ) > import Data.Maybe (catMaybes) = Dimensions = Analogously with the SI we collect the base dimensions of the CGS system in the data type 'CGSDim'. > data CGSDim lh mh t In the above 'lh' and 'mh' represent the number of half-exponents of length and mass respectively while 't' represents the number of whole-exponents. The base dimensions illustrate this. > type DLength = CGSDim Pos2 Zero Zero > type DMass = CGSDim Zero Pos2 Zero > type DTime = CGSDim Zero Zero Pos1 We add a few non-base dimensions for the sake of example. Charge is particularly interesting as it illustrates the need for half-exponents as described in [2]. > type DElectricCurrent = CGSDim Pos3 Pos1 Neg2 > type DCharge = CGSDim Pos3 Pos1 Neg1 = 'Mul', 'Div', 'Pow' and 'Root' instances = The 'Mul', 'Div', 'Pow' and 'Root' instances are strictly analogous with the SI. > instance ( N.Sum lh lh' lh'' > , N.Sum mh mh' mh'' > , N.Sum t t' t'' ) => Mul (CGSDim lh mh t) > (CGSDim lh' mh' t') > (CGSDim lh'' mh'' t'') > instance ( N.Sum lh lh' lh'' > , N.Sum mh mh' mh'' > , N.Sum t t' t'' ) => Div (CGSDim lh'' mh'' t'') > (CGSDim lh' mh' t') > (CGSDim lh mh t) > instance ( N.Mul lh x lh' > , N.Mul mh x mh' > , N.Mul t x t' ) => Pow (CGSDim lh mh t) x > (CGSDim lh' mh' t') > instance ( N.Div lh x lh' > , N.Div mh x mh' > , N.Div t x t' ) => Root (CGSDim lh mh t) x > (CGSDim lh' mh' t') = Units = We define the base units of the system. By defining 'meter' with a "scale" of 100 we get a scale of one for 'centi meter'. > meter :: Num a => Unit DLength a > meter = Dimensional 100 > gram :: Num a => Unit DMass a > gram = Dimensional 1 > second :: Num a => Unit DTime a > second = Dimensional 1 We continue by defining the CGS equivalents of the other base SI units. Actually we limit ourselves to 'ampere' since I am not sure if or how the SI base dimensions other than current are expressed in CGS. > ampere :: Floating a => Unit DElectricCurrent a > ampere = prefix (recip 3.33564e-10) ((SI.centi meter ^ pos3) ^/ pos2 * gram ^/ pos2 * second ^ neg2) We also define the preferred CGS unit for charge. > franklin :: Floating a => Unit DCharge a -- Also known as "esu". > franklin = gram ^/ pos2 * (SI.centi meter ^ pos3) ^/ pos2 / second = Conversion from SI = At some point we may wish to convert an SI quantity to a CGS quantity or vice versa. In order to convert a 'Quantity' from the SI system to the CGS system we use the strategy of dividing the quantity by the SI base unit and multiplying the resulting number (sans dimension) by the equivalent CGS unit. To realize this strategy we must be able to obtain the SI base unit and the equivalent CGS unit for a given quantity. We start with the SI unit since it is trivial. > unit_SI :: Num a => Quantity (Dim l m t i th n j) a -> Unit (Dim l m t i th n j) a > unit_SI _ = Dimensional 1 (Perhaps the above function would be better defined in another module.) Obtaining the CGS unit corresponding to the SI base unit of a Quantity isn't quite as trivial. The function body itself is straight-forward enough, the hairy part is the type signature. > unit_CGS :: forall a l m t i l2 m2 il it l' m' t'. > ( Floating a > , N.Mul Zero l Zero, N.Mul Pos2 l l2 > , N.Mul Zero m Zero, N.Mul Pos2 m m2 > , N.Mul Zero t Zero, N.Mul Pos1 t t > , N.Sum l2 Zero l2 > , N.Sum Zero m2 m2, N.Sum m2 Zero m2 > , N.Sum Zero t t > , N.Mul Pos3 i il > , N.Mul Pos1 i i > , N.Mul Neg2 i it > , N.Sum l2 il l' > , N.Sum m2 i m' > , N.Sum t it t' > ) => Quantity (Dim l m t i Zero Zero Zero) a -> Unit (CGSDim l' m' t') a > unit_CGS _ = meter ^ (undefined :: l) > * SI.kilo gram ^ (undefined :: m) > * second ^ (undefined :: t) > * ampere ^ (undefined :: i) Note that since the base dimensions of the CGS are a subset of those of the SI the mapping of types from SI to CGS is unambiguous. Also note that complex as the type signature may be producing it is a mostly mechanical process. With the above two functions we can define the function that converts a unit from the SI. We omit the type signature since it is hairy but can be readily inferred. > fromSI x = x /~ unit_SI x *~ unit_CGS x = Conversion to SI = We use the same strategy to convert from CGS to SI. However, when converting from CGS to SI there may be several valid SI dimensionalities for any given CGS dimensionality. We will handle this ambiguity by requiring the user to specify the desired type (except when it is inferable) of the resulting quantity. For example: ] toSI (3.2 *~ centi meter) :: Length Double In order to do this we must employ lexically scoped type variables and provide the hairy type signature for the 'toSI' function. > toSI :: forall a l m t i l2 m2 il it l' m' t'. > ( Floating a > , N.Mul Zero l Zero, N.Mul Pos2 l l2 > , N.Mul Zero m Zero, N.Mul Pos2 m m2 > , N.Mul Zero t Zero, N.Mul Pos1 t t > , N.Sum l2 Zero l2 > , N.Sum Zero m2 m2, N.Sum m2 Zero m2 > , N.Sum Zero t t > , N.Mul Pos3 i il > , N.Mul Pos1 i i > , N.Mul Neg2 i it > , N.Sum l2 il l' > , N.Sum m2 i m' > , N.Sum t it t' > ) => Quantity (CGSDim l' m' t') a -> Quantity (Dim l m t i Zero Zero Zero) a > toSI x = x /~ unit_CGS (undefined :: Quantity (Dim l m t i Zero Zero Zero) a) > *~ unit_SI (undefined :: Quantity (Dim l m t i Zero Zero Zero) a) Again, the type signature is complex but deriving it is a mechanical process. = 'Show' instance = We round off by writing 'Show' instance for 'CGSDim' analogous to that of 'Dim'. Out of laziness we use the notation "sqrt(cm)" to represent halves of integral dimensions. Nothing is technically keeping us from doing a better job here. > instance forall lh mh t. > ( NumType lh > , NumType mh > , NumType t > ) => Show (CGSDim lh mh t) where > show _ = (Prelude.unwords Prelude.. catMaybes) > [ dimUnit "sqrt(cm)" (undefined :: lh) > , dimUnit "sqrt(g)" (undefined :: mh) > , dimUnit "s" (undefined :: t) > ] = Examples = Let us try the Coulomb attraction example from [2]. We start by performing the calculation in the SI. > q_si = 1.6021773e-19 *~ SI.coulomb -- Elementary charge in SI. > r_si = 0.1 *~ SI.nano SI.meter -- Distance in SI > f_si = q_si ^ pos2 / (_4 * pi * e0 * r_si ^ pos2) > where > e0 = 8.8541878e-12 *~ (SI.ampere * SI.second / (SI.volt * SI.meter)) The same calculation in the CGS system. > q_cgs = fromSI q_si -- Elementary charge in CGS. > r_cgs = fromSI r_si -- Distance in CGS > f_cgs = q_cgs ^ pos2 / r_cgs ^ pos2 Inspecting the values in GHCi shows us that the results are consistent (within reasonable accuracy) with [2]. *Buckwalter.Dimensional.CGS> f_si 2.3070794737101255e-8 m kg s^-2 *Buckwalter.Dimensional.CGS> f_cgs 2.30708078598602e-3 sqrt(cm)^2 sqrt(g)^2 s^-2 To convert from CGS to SI we must specify the type of the SI 'Quantity'. > f_si' = toSI f_cgs :: SIQ.Force Double *Buckwalter.Dimensional.CGS> f_si' 2.3070807859860202e-8 m kg s^-2 We follow up with another conversion example demonstrating the ambiguity in the conversion from CGS to SI. > c = 1 *~ SI.farad -- A SI capacitance. > c_cgs = fromSI c -- Capacitance has dimensionality L in CGS. > c' = toSI c_cgs :: SIQ.Capacitance Double > c'' = toSI c_cgs :: Length Double *Buckwalter.Dimensional.CGS> c 1.0 m^-2 kg^-1 s^4 A^2 *Buckwalter.Dimensional.CGS> c_cgs 8.98755691740885e11 sqrt(cm)^2 *Buckwalter.Dimensional.CGS> c' 1.0 m^-2 kg^-1 s^4 A^2 *Buckwalter.Dimensional.CGS> c'' 8.98755691740885e9 m = Future work = This is a very rudimentary implementation. To make it more practical a significant number of quantities and units, in particularly those commonly used with the CGS, would need to be added. In the mean time all units defined for the SI can be used with the CGS by applying 'fromSI' to quantities defined from the SI units. If anyone is willing to add quantities/units (or other enhancements) I will happily to accept patches. Personally I do not expect to use this module and therefore do not intend to invest much more time in it. If the module has other users I might reconsider. And of course, another direction of future work is to define additional systems (e.g. natural, relativistic) using this module as a template. I imagine this should be fairly straight forward. = References = [1] http://code.google.com/p/dimensional/wiki/ChuckBlake20070611 [2] http://www.tf.uni-kiel.de/matwis/amat/mw1_ge/kap_2/basics/b2_1_14.html ~~~~~~~~~~ END 'Buckwalter/Dimensional/CGS.lhs' ~~~~~~~~~~

2 1

Primitive Recursive Algebraic Types
by Alexteslin 03 Aug '07

03 Aug '07

Hi, I am doing some simple exercises about recursive algebraic types and this particular exercise asks to define a function which counts the number of operators in an expression. I defined the function below, but i am not sure if on the second line changing from "evalLength (Lit n) = n" to "(Lit n) = 0" is the right solution. although the function produces correct result. data Expr = Lit Int | Add Expr Expr | Sub Expr Expr deriving (Eq, Show) evalLength :: Expr -> Int evalLength (Lit n) = 0 evalLength (Add e1 e2) = 1 + (evalLength e1) + (evalLength e2) evalLength (Sub e1 e2) = 1 + (evalLength e1) - (evalLength e2) Thank you -- View this message in context: http://www.nabble.com/Primitive-Recursive-Algebraic-Types-tf4207521.html#a1… Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

2 2

Re: [Haskell] ANN: encoding-0.1 release
by Duncan Coutts 03 Aug '07

03 Aug '07

On Thu, 2007-08-02 at 18:44 +0200, Wolfgang Jeltsch wrote: > Am Donnerstag, 2. August 2007 12:22 schrieb Henning Günther: > > […] > > > ISO 8859-* (alias latin-*) > > Not every ISO-8859-* encoding is a Latin-* encoding. > > > […] > > Wouldn’t it be good to use some already existing library like iconv or do you > think, this is not feasible (because you want to support lazyness, for > example)? Yes, I was talking to Henning about this. I've got an iconv binding[1] that use lazy bytestrings (so it does support lazyness of course) and is pretty quick. Henning has been thinking much more about what the appropriate api should be, I've just got: type Encoding = String convert :: Encoding -> Encoding -> Lazy.ByteString -> Lazy.ByteString so we might be able to use iconv underneath (if it's available). Duncan [1] darcs get http://haskell.org/~duncan/iconv/

1 0

how to see operators precedence in GHCi
by Bulat Ziganshin 03 Aug '07

03 Aug '07

Hello , from http://community.livejournal.com/ru_declarative/54566.html Q: how to see operators precedence in GHCi? A: Prelude> let showParen = (undefined::[[[[()]]]]->()) Prelude> showParen $ 2+3*4 <interactive>:1:12: No instance for (Num [[[[()]]]]) arising from use of `+' at <interactive>:1:12 Probable fix: add an instance declaration for (Num [[[[()]]]]) In the second argument of `($)', namely `2 + (3 * 4)' In the definition of `it': it = showParen $ (2 + (3 * 4)) Prelude> -- Best regards, Bulat mailto:Bulat.Ziganshin@gmail.com

4 7

Exiting GLUT application
by Dave Tapley 02 Aug '07

02 Aug '07

Hi everyone, I have the following skeleton GLUT code: > import Graphics.UI.GLUT > main = do > getArgsAndInitialize > createWindow "" > mainLoop It loads into both hugs and ghci fine and when 'main' is evaluated an empty window opens as expected. However when closing the window (clicking the window manager's x button) both hugs and ghci exit with the window, as opposed to returning to the the 'Main>' prompt. I suspect I need some callback to exit the GUI cleanly? Cheers, Dave

3 4