- Haskell - Haskell.org

Generic combination of generic types
by Rob Myers 24 Aug '07

24 Aug '07

Hi there, This is a question about combining data types in a generic way. I am using Haskell to write a first implementation of a new generic algorithm to decide a fairly large class of modal logics. Type classes provide an excellent way to generically define a modal language. In particular you only need to define the data type of the modal operator (e.g. it could be indexed by rationals) and also a special matching rule, which is used in the proof checker. However I also want to combine different modal languages to create new ones *in a generic fashion*. The "modal language" I'm talking about is just a data-type with a single type variable: data L a = F | T | Atom Int | Neg (L a) | And (L a) (L a) | Or (L a) (L a) | M a (L a) deriving (Eq,Show) // convention: clause([positive literals,negative literals]) newtype Clause a = Clause ([L a],[L a]) deriving (Eq,Show) with a type class like this: class (Eq a) => Logic a where match :: Clause a -> [[L a]] and instances like: data K = K deriving (Eq,Show) instance Logic K where match (Clause (pls,nls)) = ... data G = G Int deriving (Eq,Show) instance Logic G where match (Clause(pls,nls)) = ... data KD = KD deriving (Eq,Show) instance Logic KD where match (Clause (pl,nl)) = ... I have various such instances of logics and I want to combine them in particular ways. For example I might want to interlace three instances in a new language such as: data L1 = F1 | T1 | Atom1 Int | Neg1 L1 | And1 L1 L1 | Or1 L1 L1 | MCP L2 L3 deriving (Eq,Show) data L2 = F2 | T2 | Atom2 Int | Neg2 L2 | And2 L2 L2 | Or2 L2 L2 | MK L1 deriving (Eq,Show) data L3 = F3 | T3 | Atom3 Int | Neg3 L3 | And3 L3 L3 | Or3 L3 L3 | MKD L1 deriving (Eq,Show) or data L1 = F1 | T1 | Atom1 Int | Neg1 L1 | And1 L1 L1 | Or1 L1 L1 | MK L2 deriving (Eq,Show) data L2 = F2 | T2 | Atom2 Int | Neg2 L2 | And2 L2 L2 | Or2 L2 L2 | MKD L1 deriving (Eq,Show) ... the idea being that a different language(s) appear after the modalities (MCP, MK, MKD above). Put simply I want to take some data types and construct a new (specifically ordered) data type(s) defined in terms of these. I also want to be able to define recursive functions over this language, with which I'm having a problem (see below). I originally tried this by defining a language: data L a = F | T | Atom Int | Neg (L a) | And (L a) (L a) | Or (L a) (L a) | M a deriving (Eq,Show) Note the last term is "M a" not "M a (L a)" as in the first type. Using this 'a' I could write terms like: M (K,And F (M (KD,F))), i.e. use tupling to define in the first component the data type of the modality and in the second component (and third if considering binary modal operators) defining what comes after the modality. I found with this approach I was able to match these types e.g. note the "(K,a)" data K = K deriving (Eq,Show) instance Logic (K,a) where match (Clause (pl,nl)) = However, crucially, I cannot seem to define recursive functions because on each recursive step I am changing the type of terms considered. The underlying algorithm requires me to strip off a layer of modalities (e.g. M (K,F) goes to F) at each step. For example if I have M (K,M (KD,F)) this has type: L (K,L (KD,L a)), if I pass to the subterm M (KD,F), then this has type: L (KD,L a). Thus Haskell could not resolve this type ('unification would produce infinite data type'). However this method seems very attractive because it only needs one data type to define many different languages. I've tried alternate approaches, for example explicitly defining the interlaced language, such as: data L1 = F1 | T1 | Atom1 Int | Neg1 L1 | And1 L1 L1 | Or1 L1 L1 | MCP L2 L3 deriving (Eq,Show) data L2 = F2 | T2 | Atom2 Int | Neg2 L2 | And2 L2 L2 | Or2 L2 L2 | MK L1 deriving (Eq,Show) data L3 = F3 | T3 | Atom3 Int | Neg3 L3 | And3 L3 L3 | Or3 L3 L3 | MKD L1 deriving (Eq,Show) However this becomes messy because I then need to define all of my operations (e.g. find conjunctive normal form) on these new constructors. It seems that I need to use the actual constructor to pattern match... I can't use some ADT functions. I've also tried the first method above with 2 type variables, with the same problems (unification of infinite data type). Does anyone have any ideas? Frankly I'd be impressed if someone even takes the time to read though this. Thanks, Rob

2 1

ANNOUNCE: Programming in Haskell - eBook version
by Graham Hutton 22 Aug '07

22 Aug '07

Dear all, Readers of this list may be interested to know that "Programming in Haskell" is now also available as an eBook, in addition to the traditional paperback and hardback versions. For further details, just click the eBooks link on the book's home page: http://www.cs.nott.ac.uk/~gmh/book.html Best wishes, Graham +-----------------------------------------------------------------+ | Dr Graham Hutton Email : gmh(a)cs.nott.ac.uk | | School of Computer Science | | University of Nottingham Web : www.cs.nott.ac.uk/~gmh | | Jubilee Campus, Wollaton Road | | Nottingham NG8 1BB, UK Phone : +44 (0)115 951 4220 | +-----------------------------------------------------------------+ This message has been checked for viruses but the contents of an attachment may still contain software viruses, which could damage your computer system: you are advised to perform your own checks. Email communications with the University of Nottingham may be monitored as permitted by UK legislation.

1 0

Commercial users of functional programming 2007: programe is published, registration open
by Simon Peyton-Jones 21 Aug '07

21 Aug '07

Friends, The program for the 2007 Commercial Users of Functional Programming workshop is now published. http://cufp.galois.com/ The workshop is co-located with ICFP, and will be held in Freiburg, Germany, on 4 October 2007. We had a terrific response to our call for talks, and there are twelve (!) speakers describing commercial applications, variously written in Caml Erlang F# Haskell ML Scheme The talks are informal, and there are no proceedings. We'll just have fun learning about functional programming used to solve real problems. Do come! Kathleen Fisher Simon Peyton Jones

1 0

help with IOArray
by robert bauer 19 Aug '07

19 Aug '07

I have an IOArray, but it doesn't work the way I expected it to. I defined newMem s = newIOArray (0, size-1) 0 and then x = newMem 30 then do { y <- x ; v <- readIOArray y 2 ; print v ; writeIOArray y 2 20 ; v <- readIOArray y 2 ; print v } this resulted in 0, 2 as expected. however, then do { y <- x ; v <- readIOArray y 20 ; print v } results in 0 I thought the IOArray was basically a static structure? Thanks

3 2

Ref class?
by Conal Elliott 16 Aug '07

16 Aug '07

does anyone know where there's a class that abstracts over IORefs? it includes newRef, readRef, and writeRef. i've seen it but can't remember where. - conal

4 4

Re: [Haskell] ghc.haddock?
by David Waern 16 Aug '07

16 Aug '07

> I'd like to give it a try. I guess the repo is > http://darcs.haskell.org/SoC/ghc.haddock/. Glancing around, see a version > of ghc, and I don't know how to build haddock. Is ghc.haddock a new flag > to > a forked version of ghc? > > Other questions: is ghc.haddock known to build & run on Windows? Is the > plan to merge it into the main ghc sources, and if so, when? > > I'd love to hear from others using ghc.haddock. > > Thanks, - Conal Hi Conal, The changes in ghc.haddock was merged to GHC last year after my SoC project was finished. This repository should not be used anymore. What you need is a quite recent GHC 6.7, probably from July or later. Then you should get Haddock 2.0 aka haddock.ghc from this darcs repository: http://darcs.haskell.org/SoC/haddock.ghc/. The package can be built using Cabal and GHC 6.7. I haven't tested it with Windows - please let me know if you have any problems. Thanks for taking interest! /David

5 5

ANNOUNCE: Guihaskell and PropLang 0.1
by Asumu Takikawa 15 Aug '07

15 Aug '07

Hello Haskellers. I'm one of the Google Summer of Code students for '07 and I'd like to announce the project my mentor, Neil Mitchell, and I have been working on. == GuiHaskell Guihaskell is a graphical REPL using PropLang, a GUI combinator library built on top of Gtk2hs, which aims to be an IDE for Haskell written in Haskell. It's still rough around the edges, so think of this as an alpha release. As such, I'd appreciate any feedback very much! Here's a feature list for 0.1: * Support for GHCi (default) and Hugs * Quick switching between compilers * Simple one-click profiling * Command history This first release of Guihaskell is mostly infrastructure. For future releases I aim to integrate more tools like Cabal and make it easier to use with an editor. == PropLang PropLang is a GUI library built on Gtk2hs that allows for high level design. The GUI is expressed as a series of relationships between GUI elements and data sources. Here's a "Hello World" example: import PropLang.Gtk import PropLang.Event main = do initPropLang window <- getWindow "foobar.glade" "wndFoo" let tb = getCtrl window "button" :: ToolButton tb!onClicked += putStrLn "Hello World!" showWindowMain window This example prints "Hello World!" when the user presses a button defined in a Glade file. PropLang is used with glade to define the interface. You can define more complicated relationships using the combinators in PropLang.Variable. Here's a snippet from GuiHaskell: tie (txtSelect!text) filename (\t -> if null t then Nothing else Just t) (maybe "" id) "tie" takes two PropLang variables and relates them so that when one is updated, it will inject its value into another. It also takes two functions to run on the data before injection. This snippet is used to tie the representation of the currently selected file in GuiHaskell (a Maybe String) to Gtk's TextView buffer (a String). If you injected a new value into filename... filename -< Nothing then txtSelect's text buffer would be set to "". You can also build other behaviors into PropLang variables to do interesting things. GuiHaskell has a configuration API built around PropLang. Configuration items are defined as special PropLang variables: filename <- newVarWithName "selected_filename" (newConfValueWithDefault Nothing "selected_filename") "newVarWithName" in PropLang.Variable lets you make new variables with custom actions to retrieve and set values. "newConfValue" is defined in GuiHaskell to serialize configuration items to disk so they can be read back after closing the program. For more information you can generate the Proplang docs with haddock. == Install Get the packages here: http://hackage.haskell.org/packages/archive/GuiHaskell/0.1/GuiHaskell-0.1.t… http://hackage.haskell.org/packages/archive/proplang/0.1/proplang-0.1.tar.gz Install with cabal: runhaskell Setup.lhs configure runhaskell Setup.lhs build runhaskell Setup.lhs install == You can send feedback to my e-mail, the list, or contact me on IRC (I'm Shimei on #haskell). Thanks. Cheers, Asumu Takikawa

1 0

Re: [Haskell] What makes a functional language functional?
by Philip K.F. Hölzenspies 10 Aug '07

10 Aug '07

Dear Chris, Aside from the points raised by others already, I wanted to add a small point. Aside from +'s commutativity. The + you use here can not be transformed the way you point out. Looking at the types: f :: Fractional a => a -> a -> a g :: t -> t In the expression g x + f x the type of + is: (+) :: Fractional a => t1 -> (a -> a) -> t2 The example as you give it would actually not pass through the type checker. If we simply define f as f x | x /= 0 = undefined | x == 0 = 0 the behaviour would be the one you describe. I'm not too sure about the actual formalisms, but I seem to recall that, since _|_ is not a value, non-termination does not violate referential transparency. Basically, it is undecidable for any x whether _|_ == x The undecidability even holds for x = _|_ Also, I can implement any program from a lazy functional programming language in, for example, C. If I program the test whether or not to evaluate the next element "now", I can even make my program behave in the exact same "lazy way" - but let's not discuss how large and ugly that code would be. This can be done with pure functions only, i.e. referentially transparent. I vaguely recall a formal semantics presentation about whether or not termination is part of the formal semantics at all. Since it has been so long ago since I scratched the surface of formal semantics, I'll refrain from making an idiot out of myself and committing to strong statements in that direction ;) Regards, Philip

1 0

ghc.haddock?
by Conal Elliott 10 Aug '07

10 Aug '07

I've heard of a version Haddock that understands all of GHC's syntax extensions. Does anyone the current status? - Conal

2 2

What makes a functional language functional?
by C.M.Brown 09 Aug '07

09 Aug '07

Hi, Is lazy evaluation necessary for a functional language to remain functional? The reason I ask is that because it violates beta-reduction, and also referential transparency (I think). In haskell, we can transform: g x + f x into: f x + g x as both f and g do not change the parameter x. If g always evaluates to a normal form (in both a lazy and a strict world) g x = x but f is defined thus: f x = (\y -> if x /= 0 then x else y/x) And we apply f to 0 (1/0) then f becomes _|_ therefore: 0 + _|_ /= _|_ + 0 Or, does this just become: _|_ = _|_ ? Or, am I missing something totally obvious? Regards, Chris.

3 3