- Haskell-Cafe - Haskell.org

old-time conflict when installing phooey
by Daryoush Mehrtash 27 Apr '09

27 Apr '09

When I try to install phooey I get conflict with old-time that I am not sure how to resolve. Any ideas? > cabal install phooey Resolving dependencies... cabal: dependencies conflict: ghc-6.10.1 requires old-time ==1.0.0.2 however old-time-1.0.0.2 was excluded because ghc-6.10.1 requires old-time ==1.0.0.1 Thanks Daryoush

3 2

RE: [Haskell] ANN control-monad-exception-0.1: Explicitly typed exceptions
by Simon Peyton-Jones 27 Apr '09

27 Apr '09

Is there a Haskell Wiki page on extensible exceptions? The paper is a fine reference, it'd be cool to have a wiki page giving programmer-oriented guidance, saying what comes with GHC what other packages are available and some simple examples of how to use them. Simon | -----Original Message----- | From: haskell-bounces(a)haskell.org [mailto:haskell-bounces@haskell.org] On Behalf Of | Pepe Iborra | Sent: 25 April 2009 19:52 | To: haskell(a)haskell.org | Subject: [Haskell] ANN control-monad-exception-0.1: Explicitly typed exceptions | | The control-monad-exception package [1] provides explicitly typed | exceptions for Haskell. | In other words, this is a perfect example of bundling in a Haskell | library what for other | programming languages is a native feature. | | The type of a computation in the EM monad carries a list of the exceptions that | the computation may throw. A exception is raised with 'throw', which | in addition adds it | to the type, and captured with 'catch', which correspondingly removes | it from the type. | Only safe computations (all exceptions handled) can escape from the monad. | | The encoding used for the exception list is based on a phantom type | variable carrying a | @Throws@ constraint for every exception type. Catching an exception | @e@ satifies the constraint | @Throws e@ thus removing it from the type. It is possible to teach | Throws about exception subtyping | by manually inserting new instances declaring the subtyping relations | between exceptions. I don't | believe there is a better way to handle this, as the existential | wrapper encoding used | for Control.Exception.SomeException does not reveal the subtyping | relations, but ideas are | welcome. | | Example | -------- | GHCi infers the following types | | eval :: (Throws DivideByZero l, Throws SumOverflow l) => Expr -> EM l Double | eval `catch` \ (e::DivideByZero) -> return (-1) :: Throws | SumOverflow l => Expr -> EM l Double | runEM (eval `catch` \ (e::SomeException) -> return (-1)) :: Expr -> Double | | for the code below. | | | > import Control.Monad.Exception | > import Data.Typeable | | > data Expr = Add Expr Expr | Div Expr Expr | Val Double | > eval (Val x) = return x | > eval (Add a1 a2) = do | > v1 <- eval a1 | > v2 <- eval a2 | > let sum = v1 + v2 | > if sum < v1 || sum < v2 then throw SumOverflow else return sum | > eval (Div a1 a2) = do | > v1 <- eval a1 | > v2 <- eval a2 | > if v2 == 0 then throw DivideByZero else return (v1 / v2) | | > data DivideByZero = DivideByZero deriving (Show, Typeable) | > data SumOverflow = SumOverflow deriving (Show, Typeable) | | > instance Exception DivideByZero | > instance Exception SumOverflow | | | Comments and patches are welcome. | Cheers, | Pepe Iborra | | [1] - http://hackage.haskell.org/cgi-bin/hackage-scripts/package/control-monad- | exception | _______________________________________________ | Haskell mailing list | Haskell(a)haskell.org | http://www.haskell.org/mailman/listinfo/haskell

1 0

Re: Is 78 characters still a good option? Was: [Haskell-cafe] breaking too long lines
by Jason Dusek 26 Apr '09

26 Apr '09

2009/04/26 Miguel <miguelimo38(a)yandex.ru>: > 2009/04/26 Jason Dusek <jason.dusek(a)gmail.com>: >> If we do not preserve the old ways, it'll be anarchy all the >> way down. > > How exactly are you going to preserve old ways? Whenever are we are presented with the a question of correct conduct, we must re-affirm our commitment to the practices handed down to us. When we revisit this question -- "Should we maintain the 80 column limit?" -- it as an opporunity to affirm this practice. Through this exercize, we perenially renew our faith in this convention, accepting the bonds of convention. This ritual -- the "line-length reminding ritual" -- is played out across all programming communities several times a year. Everyone says the same things. Then they all go away with the 80 column limit re-established in their minds. -- Jason Dusek

1 0

installing Sqlite3 driver for windows
by Michael P Mossey 26 Apr '09

26 Apr '09

I'm working from Real World Haskell, trying to install HDBC and the Sqlite3 driver on Windows XP. It was easy enough to use Cabal to install HDBC. However, for the Sqlite3 driver things get fuzzy. I downloaded hdbc-sqlite3_2.1.0.0.zip, but don't know what I'm supposed to do with it. Also, it wasn't clear what to do with the sqlite3.dll file. On this page <http://software.complete.org/software/wiki/hdbc/FrequentlyAskedQuestions> it seems to imply you need to put it in 'gch --print-libdir'\include and %windir%\system32 but that page is really about building the driver from source. Maybe it only needs to go in the system32 directory. Thanks, Mike

2 1

Haskell/JS -- better through typeclasses?
by Jason Dusek 26 Apr '09

26 Apr '09

I'd like to be able to translate Haskell to JavaScript. Many Haskell/JS bridges provide libraries for writing complete JavaScript programs in Haskell; some of them even include jQuery. However, my goals are more limited -- I'd like to be able to take a Haskell module and turn it into a JavaScript object. For example, I'd like to write a nice parser in Haskell and then reuse it on the client side. No need to handle all the DOM events or implement multi-threading. Of course, the place to start is by reading the commentary. A little bit of browsing suggests some questions of strategy: . Maybe a new backend is not the right thing? All the backends seem to be for real computers with real instruction sets. . Is it better to just work on transforming Core into JS directly? It seems that "External Core" is still in limbo. . Some translations strike me as baffling in principle. For example, a value like `ones`: ones = 1 : ones We'd want to avoid most native JavaScript containers, it seems; however, we are then unable to leverage the speed of native containers. It's entirely possible that translating Haskell to JavaScript may turn out not to be the best idea; maybe it is better to have a type class for types (for example, `Parser Char`) to provide their own translators? The it would be straightforward to prevent translation of programs that use concurrency libs, native ops or `IO`. -- Jason Dusek

7 11

ANN: Bamse-0.9.4, a Windows Installer generator
by Sigbjorn Finne 26 Apr '09

26 Apr '09

Hi, a new version of Bamse has been uploaded to hackage, http://hackage.haskell.org/cgi-bin/hackage-scripts/package/bamse Bamse is a package and application for letting you quickly put together Windows Installers for your software projects/products from within the comforts of Haskell. New in this release is the support for generating MSIs from your Cabal projects, having them either be built from source or just have them be installed and registered at install-time. i.e., one-click installation of Cabal packages. See examples/Cabal.hs for a worked example of how to bundle up Cabal packages. I've found this functionality a bit useful, hope others do too. The new version also adds support for handling .NET assemblies. enjoy --sigbjorn

2 2

Haskell/JS -- better through typeclasses?
by Dimitry Golubovsky 26 Apr '09

26 Apr '09

John wrote: > I can't speak for Jason, but for me, this is not very useful. I don't > want to write in a Haskell DSL, I want to write in Haskell. And not > the whole program, either, just the parts that really lend themselves > to functional programming (parsers, numeric computations, code > generators, various algorithms). What I presented is of course not a complete solution; this is just a tool to construct Javascript expressions in haskellized type-safe form. What I also mentioned: this monadic form may be an end-point for some other conversion, like GRIN. This answers the question how to translate a true Haskell program (like a parser) into Javascript (or a similar language). There are some experimental compilers with GRIN backends, plus I did my own experiments with GRIN that gave me some ideas. So I would just look at it as a starting point of some new family of tools which hopefully will end up opening possibility to translate Haskell things to Javascript. PS For now I am more concerned with the IDL part of it, but any suggestions on GRIN are welcome. -- Dimitry Golubovsky Anywhere on the Web

2 1

Haskell/JS -- better through typeclasses?
by Dimitry Golubovsky 26 Apr '09

26 Apr '09

Jason and everybody interested, Please check out a package I recently (just by coincidence: I haven't seen this topic on the list until after I uploaded it) uploaded to Hackage: http://hackage.haskell.org/cgi-bin/hackage-scripts/package/jsmw-0.1 This is a basic monadic interface to Javascript code generator (based on WebBits), providing sort of a macro (like in macro-assembler) facility. HJScript was used as a (sort of) prototype, but I chose slightly different notation for EDSL. >From here, I think two directions may be taken: 1. Some techniques are described in the GRIN thesis [1] how to convert a Haskell core to monadic form. These may be explored for this case. 2. Similarly to how the Web Consortium defined interfaces to its components using IDL *, Haskell modules converted to Javascript may expose their interfaces same way, thus providing a basis for a reusable component-based approach. Any discussions and suggestions are welcome. >From my own impressions, EDSL approach is better for interactive/AJAX parts of a Javascript application, as translation of non-strict evaluation (like it was done in the Yhc/Javascript project) just causes a lot of code generated, and does not improve the user interaction performance at all. For other (internal) components, translation from Haskell may be more appropriate, just to be able to reuse the existing libraries. One of experiments with Yhc involved a user-exposed form, and a parser to validate user's input. With this hybrid approach, the user interface part might be coded using an EDSL, and the parser could be translated from Haskell core. An IDL might be generated for the parser interface, thus making the parser module a reusable component. These are of course just thoughts and ideas for now. ------------------------------------ * See the DOM package: this is an auto-generated Haskel approximation of IDL specs provided for the basic DOM components. [1] http://www.cs.chalmers.se/~boquist/phd/index.html [2] http://hackage.haskell.org/cgi-bin/hackage-scripts/package/DOM-2.0.1 -- Dimitry Golubovsky Anywhere on the Web

3 4

Problems with Haskell Program Coverage
by Dominic Steinitz 26 Apr '09

26 Apr '09

I want to use hpc to check that the ASN.1 library tests cover all the code. When I run it with a set of tests that I *know* don't test certain things, it reports that they have been covered i.e. there are not coloured in the markup that hpc produces. I would have expected a lot of yellow. It seems to work ok on small amounts of code so I'm not clear what I'm doing wrong. I'd be happy to provide the .tix file or put the .html files somewhere if that would be helpful. Here's what I use: ghc -o NewTest NewTest.hs -fhpc --make NewTest hpc markup NewTest Dominic.

4 3

Type constraints and classes
by Neil Brown 26 Apr '09

26 Apr '09

Hi, I have a Haskell problem that keeps cropping up and I wondered if there was any solution/work-around/dirty-hack that could help. I keep wanting to define class instances for things like Functor or Monad, but with restrictions on the inner type. I'll explain with an example, because I find explaining this in words a bit difficult. Let's say I want to create a Monad instance for Set akin to that for lists: == import Data.Set import Prelude hiding (map) instance Monad Set where return = singleton m >>= f = fold union empty (map f m) -- Error: Could not deduce (Ord a, Ord b) from the context (Monad Set) == Everything fits (I think) -- except the type-class constraints. Obviously my Monad instance won't work if you have things inside the set that aren't Ord, but I can't work out how to define a restricted instance that only exists for types that have Ord instances. I can't express the constraint on the instance because the a and b types of return and >>= aren't visible in the class header. Shifting the constraint to be present in the type doesn't seem to help either (e.g. newtype Ord a => MySet a = MySet (Set a)...). Is there any way to get such instances as the one for Set working? I cannot carry around a compare function myself in a data type that wraps Set, because return cannot create such functions without the original type-class instance. I don't actually need a Monad for Set, but it neatly demonstrates my problem of wanting constraints on the type inside a Monad (or a Functor, or an Applicative, etc). I worked around a similar problem with Functor by opting for a new Functor-like type-class with the constraints, but doing that with Monad rules out using all the monad helper functions (liftM, mapM, etc), and the do notation, which would be a step too far. All suggestions are welcome, no matter how hacky, or how many GHC extensions are required :-) (provided they don't break all the other monads, e.g. redefining the signature of Monad). Thanks, Neil.

4 3