I'm trying to build todays cvs ghc on a winxp box, without trying
anything unusual. The build fails and I am rather lost in the
makefiles - any suggestions?
Cheers,
Claus
$ autoreconf
$ ./configure --host=i386-unknown-mingw32 --with-gcc=c:/mingw/bin/gcc
$ make 21 | tee make.log
the last
perhaps some items got lost from my last mail:
- url problem on http://www.haskell.org/ghc/
Mailing Lists points to non-existent
http://www.haskell.org/ghc/docs/latest/html/users_guide/introduction-ghc.html#MAILING-LISTS-GHC
- missing GLUT
the building guide might want to mention that
I am happy to report that the half-yearly editions of the
-
Haskell Communities and Activities Report
(next edition: May 2004)
http://www.haskell.org/communities/
When trying to build HaRe with ghc 6.2 (builds fine with ghc 6.0.1),
we encountered a long list of strange error messages of the kind:
...
*** Compiling Main:
compile: input file pfe_client.hs
*** Checking old interface for Main:
Failed to load interface for `MapDeclMBase':
It's called 'raw' because it is supposed to get the arguments through
*unmodified* to the called program. No file globbing, no escape stuff,
nothing.
That's exactly what I'm worried about: it seems that rawSystem is
*not* passing the arguments unmodified, but tries to compensate for
windows
No, the effect is that the arguments are passed unmodified to the
program. The implementation of rawSystem might have to do some
compensation under the hood (eg. on Windows), but that's not visible to
the client.
As I've learned to interpret the uncompensated arguments, I'd prefer
a
Dear Haskellers,
as part of our project on Refactoring Functional Programs
http://www.cs.kent.ac.uk/projects/refactor-fp/
we are pleased to announce the availability of HaRe 0.2 (also known
as HaRe 27/01/2004 ;-), a snapshot of our Haskell Refactorer
prototype. The major changes since HaRe
On behalf of the many contributors, I am happy to announce that the
-
Haskell Communities and Activities Report
(5th edition, November 2003)
http://www.haskell.org/communities/
On behalf of the many contributors, I am happy to announce that the
-
Haskell Communities and Activities Report
(5th edition, November 2003)
http://www.haskell.org/communities/
Is [marshaling functions] something absolutely impossible in
Haskell and by what reason? Just because of strong typing (forgive
my stupidity ;)? Or are there some deeper theoretical limitations?
If you're interested in some recent work here, have a look at Clean
(similar enough to
Dear GHC/GPH/GDH users and developers,
in case you haven't seen the calls for contributions on the main
Haskell list: the Haskell community hopes to hear from you about all
the interesting stuff you've been brewing over the last six months,
not to mention the even more interesting stuff in the
Dear Haskeller,
*you* are still envited to let the Haskell community know what
you've been doing with Haskell recently! Remember, in spite of its
printable formats, this is still basically an email survey:
- just hit the reply button now, and take a few minutes to compose
your
The function system works fine in Hugs except on windows where DOS limitations
cause the function to always return ExitSuccess. (ghc suffers from the same
problem on Windows.)
Actually, that is not quite correct: ghc seems to suffer from this
problem only on older Windows versions (such as
If you want access to its I/O streams as well, you can use
Posix.popen, which is not standard Haskell 98, I think, but it's
in GHC.
Even worse, it is not portable (AFAICT)! I'm worried by the tendency
towards Posix, at a time when, e.g., GHC by default no longer
supports this on Windows (went
Since releasing version 0.1 of the Haskell Refactorer HaRe, we've
continued to update the HaRe snapshots on our webpage every now and
then, in response to your feedback and bug reports.
http://www.cs.kent.ac.uk/projects/refactor-fp/hare.html
We do not usually announce every new snapshot
Dear Haskellers,
once again, we set out to get an overview of what is going on in all
things Haskell, and *you* are invited to help with this effort!
Please contribute to the forthcoming fifth edition of our
[moved to haskell-cafe]
The odd is in the conceptual explanation. If I give a description
of some f x = y function in Haskell I expect that some program f x
is reduced to y and the result is given back (possibly printed). A
good story to sell to students.
This is almost everywhere the
[apologies for multiple copies - experience has shown that not
all Haskellers can be reached via the main Haskell list anymore]
An entry for your diaries (no other action required right now):
--Pre-Call
Your contributions to the
Dear Haskellers,
as part of our project on Refactoring Functional Programs
http://www.cs.kent.ac.uk/projects/refactor-fp/
we are pleased to announce the availability of HaRe 0.1 (also
known as HaRe 01/10/2003 ;-), a snapshot of our Haskell Refactorer
prototype. You can get it via
[apologies for multiple copies - experience has shown that not
all Haskellers can be reached via the main Haskell list anymore]
An entry for your diaries (no other action required right now):
--Pre-Call
Your contributions to the
First, let me say that I'm intrigued. This looks like really neat
functionality to have available.
Thanks; obviously, we think so, too!
I'm curious whether you are planning (or have developed) tools to
*detect* cases for refactoring? Occasionally, I find myself wishing
for a tool to help
[apologies for multiple copies - experience has shown that not
all Haskellers can be reached via the main Haskell list anymore]
An entry for your diaries (no other action required right now):
--Pre-Call
Your contributions to the
[this seemed to be flowing along nicely, but now that the thread
has moved from information to organisation and meta-discussion,
I'd like to add a few comments, and an invitation]
On Saturday 30 August 2003 01:39, Hal Daume III wrote:
I'm attempting to get a sense of the topology of the
- use Helium at this stage, switch to full Haskell systems later?-)
- more relevant on these two lists: people have been going on
about teaching Prelude/Libraries for years. I understand that GHC
at least has seen a lot of work on making the Prelude replacable
recently; one good way of
What is the best way to represent cyclic data structures in Haskell?
There used to be some work on direct cyclic representations at UCL:
Dynamic Cyclic Data Structures in Lazy Functional Languages
Chris Clack, Stuart Clayman, David Parrott
Department of Computer Science, University
- using hFlush does *not* seem to cure the problem??
That's worrying, and it perhaps indicates that there's another problem
somewhere. I just tried a small test and hFlush does appear to do the
right thing, so do you think you could boil down your example to
something small that
==
The (Interactive) Glasgow Haskell Compiler -- version 5.04.3
==
We are pleased to announce a new patchlevel release of the Glasgow
Haskell Compiler (GHC),
To what extent does the windows ghc install actually depend on being
in a particular place or having registry entries?
Here, we'd occasionally like to use ghc on public machines which
don't have it installed, and on which we have no installation
permissions. Those machines do have access to
Actually a mild variant of Claus's proposal seems to work out
quite well. Another way to avoid the problems with types is
to use a multi-parameter type class. Little example attached.
Glad to be of help. The need to shadow the data types is a bit
annoying, but then the whole generic bit
Colin [ccing GHC users in case there are other enthusiasts out there]
| we briefly discussed the lack in
| Concurrent Haskell of any way to set up a data-driven
| thread -- one that works on a data structure D without
| ever forcing its evaluation, only proceeding with the
| computation
Having more than 10 years expirience with whitespace does not
matter languages, the only thing that drives me crazy is the
layout rule.
so in 10 years of programming, you've never written a Makefile?-)
As far as I understand it, I have 2 options:
1. Use braces and semicolons and ignore
Hmm, I've never heard of linking being a bottleneck. Even GHC itself
links in about 3-4 seconds here. One common problem is that linking on
a network filesystem takes a *lot* longer than linking objects from a
local disk. It's always a good idea to keep the build tree on the local
disk,
I am reading the article template meta-programming for haskell and am
wondering if
1) this is already implemented in ghc.
2) if not when this will be released
answered in section 2.1 (GHC) and 3.6.1 (Template Haskell) of the
Haskell Communities Activities Report (November 2002 edition):
There's been mention of a Binary module; .. That said, there was
also a post about using plain text. I tend to agree, except for
certain cases. However, that is *not* to say that you should
necessarily use Show/Read.
| Actually, deriving binary would be a nice thing to have in general
|
main = mapM (=putChar) getCharS where getCharS = getChar:getCharS
How would you suggest to neatly insert the error handling code into ?
\begin{code}
-- some suggestions for a little zoo of cats
module Main where
import IO
import Monad
main0 = interact id
main1 = getContents = putStr
main2 =
has anybody here used in a non-trivial way the showsPrec anti-parser?
Isn't the idea to make things trivial while avoiding performance
penalties? Perhaps: simple pretty-printing of abstract syntax trees?
I often use it to get simple debugging output for complex internal
data structures (first,
The many contributors and I are happy to announce that the
Haskell Communities and Activities Report
(3rd edition, November 2002)
http://www.haskell.org/communities/
is now available from the Haskell Communities home page in several
formats: in
I'm not actually sure whether this is a bug, but if it isn't,
could someone please enlighten me about what is going on?-)
[the following is a simplified version of a problem with instances
generated by Drift, for Strafunksi, where T would be the Drift
target, C would be Term, and expl(ode)
| What I don't understand, however, is why adding that extra
| constraint helps in any way? Shouldn't the addition of new
| things in the context only make more options available? Why
| does it make some of the existing, amgibuous options go away?
With the extra constraint, the instance
I'd argue that -package is a global option and should stay that way.
The only reason you might want to disable -package for certain
modules and not others is if you want to do some tricks with module
shadowing - and this definitely isn't supported in GHC. You should
pass the same -package
As some of you know, our refactoring project here at UKC has just
started (at long last). Of course, it will take some time before
this leads to concrete artifacts in terms of detailed refactoring
catalogues and prototype tools, but we would like to know a bit more
about the environment into
I'm curious exactly what is safe and what is unsafe to wrap
unsafePerformIO around when it comes to FFI calls.
Here's a simple test:
Could you imagine an alternative implementation of the same API in
pure Haskell? (Don't consider efficiency or effort required to write
the
The size problem is traceable to [Greencard's ffi code generation]
I took a look at this and found that Sigbjorn had fixed it some months
ago
Would that be in the released Greencard or only in the cvs version?
Building GDITypes with this command:
green-card --target=ffi -i.
---
Two suggestions for CVS maintainers:
1. we could make better use of the cvs.haskell.org home page:
- add a link to the cvs-web interface proper
- add an overview of what is where in the cvs tree
(probably best generated automatically from brief description
Thanks for looking at this Claus.
no problem - I'm kind of nearby, and I'm not promising anything
(unless just looking at it is going to help;-).
- the full-screen titlebar effect with the SOE variant suggests
some window-handling incompatibility, if it wasn't for Hugs and GHC
using
Long away and far ago (or something like that;), there was a
discussion on Lists implemented as arrays rather than linked
structures, during which Jerzy Karczmarczuk commented:
What bothers me quite strongly is the algorithmic side of operations
upon such objects.
Typical iterations map-
Suppose I have a task I want to do to each line of a file,
accumulate a result and output it,
..
I'd like to write something similar to
main = do res - foldX process_line initial_value getLine
print res
I feel this ought to be straightforward -- the structure is
Dear Haskellers,
over the last weeks, more and more of you have (been;-) volunteered
to provide short summaries of recent and planned activities in your
area of work with or on Haskell (for details, and for the current
status, see http://www.haskell.org/communities/).
Those summaries, as far
Haskell Communities and Activities Report
http://www.haskell.org/communities/
The current plan is to get contributions in by the end of April,
and to get the collective report out early next month (*).
I wrote new suggestions are welcome. Several Haskellers have
already contacted me
Dear fellow Haskeller,
it is time again - for contributions to the second edition of the
Haskell Communities and Activities Report
http://www.haskell.org/communities/
The current plan is to get contributions in by the end of April,
and to get the collective report out early next month
cpsfold f a [] ú
cpsfold f a (x:xs) ÿ x a (\y - cpsfold f y xs)
and f takes a continuation, Bob's my uncle, and I have a program that
runs quickly in constant space!
Good. I'm curious to know from other readers whether
continuations like this are the only way of solving it,
Actually, and quite apart from it being cumbersome to use, I've got
my doubts about whether this cpsfold really does the job (is that
just me missing some point?-).
It does the job for me! In practical terms I can see it works.
..[explanation omitted]..
I didn't express myself well:
2. When I hear translate to HTML I imagine that underlined
words which can be clicked to see, say, definition of
function. Sadly, most htmlizers are focused on highlighting
rather than navigation.
Why generate HTML pages if noone reads them?-)
Take this obscure location, for instance:
You don't need meta-programming technology (reflection) to do things like
generic prinitng. A generic programming extension of Haskell (like
Generic Haskell, or derivable classes) can do the job for you.
Isn't generic programming usually based on a kind of compile-time
reflection (if the
{-
Unlike my rough proposal, one should aim for a combination of
(mostly) in-Haskell implementation and (some) pre-processing. As
Thomas Nordin has pointed out to me in private email, Hugs (Dec
2001) already supports this (module lib/hugs/Quote.hs and flag +H).
The real trick is to have
users please telephone
01227 823674. The closing date is Friday 11 January 2002.
Informal enquires can be directed to either Simon or Claus:
{S.J.Thompson,C.Reinke}@ukc.ac.uk. More details of the project
and further particulars for the position can be found at:
http://www.cs.ukc.ac.uk
Peter Douglass writes:
Hi,
I have a number of questions regarding categories and datatypes. I know
that many of the folk in this mailing list could answer these question, but
I wonder if there is a more appropriate forum. (i.e. the question are not
Haskell specific).
Hello, I am interested in using global variables (in GHC). I need a
variable to store list of Integers to store temporary results. I
have been reading the module MVar, but I wonder if there is an
alternative way of doing it. I have already implemented my function
using an auxiliar
enquires can be directed to either Simon or Claus:
{S.J.Thompson,C.Reinke}@ukc.ac.uk. More details of the project
and further particulars for the position can be found at:
http://www.cs.ukc.ac.uk/people/staff/sjt/Refactor/
Simon and Claus
___
Haskell
Dear Haskellers,
over the last weeks, more and more of you have (been;-) volunteered
to provide short summaries of recent and planned activities in your
area of work with or on Haskell (for details, and for the current
status, see http://www.haskell.org/communities/).
Those summaries, as far
Dear Haskellers,
after the first rush of volunteers seems to have ebbed away, it is
probably time for a reminder. First, the good news:
We have just about enough topics covered to convince me that it makes
sense to go ahead. So the Haskell Communities page has moved to a more
permanent
First, a big thanks to those of you who immediately volunteered
to act as contact persons to their communities. That means that
five of the areas are already covered.
***
*** keep those contact offers coming!-) ***
Dear fellow Haskellers,
the recent (and eternal) questions about GUIs and future Haskell
developments are closely related to a general problem: trying to
keep up to date with what is going on within the Haskell community
as a whole while the breadth of interests in that community keeps
There was the feeling that there is not frequent enough
feedback from the Task Forces (eg, FFI Task Force, Library
Task Force) to the Haskell community as a whole. Clause
Reinke kindly volunteered to collect status reports of Task
Forces on a 6-monthly basis and post them to the Haskell
Haskell.org has a page "Job Adverts".
http://www.haskell.org/jobs.html
I like the new scope. But to minimise confusion of people looking for
paid jobs (which now exist), why not reflect the explanations in the first
paragraph in the page structure? Two main sections should be sufficient,
[oops, somehow this ended up in my drafts folder, not on the list;
sorry for the delay]
First, to avoid confusion: I'm not criticising the work described. I'm
just pointing out that, in my view, the major advantages of functional
programming lie beyond what is used in this application (in
This article is very good, and having read the conference paper earlier
in the year I finished it with only one question: What's a 'quant' ...
and is it good or bad to be one?
"Ten years ago, Jean-Marc Eber, then a quant at Société
Générale, ..."
The OED has:
..
So
Ever wanted to see what your Haskell program is doing?-)
-
GHood (pre-release, 11 January 2001)
"Graphical Hood" -- a Java-based graphical observation event viewer, as
a back-end for Andy Gill's Hood (Haskell Object Observation
Dominic,
What I can't see at the moment is how to keep what I was doing modular. I had
a module Anonymize, the implementation of which I wanted to change without
the user of it having to change their code. The initial implementation was a
state monad which generated a new string every time
Can someone help? The program below works fine with small files but when I
try to use it on the one I need to (about 3 million lines of data) it
produces no output. The hard disk is hammered - I assume this is the run time
system paging. My suspicion is that the program is trying to read in
Can someone help? The program below works fine with small files but when I
try to use it on the one I need to (about 3 million lines of data) it
produces no output. The hard disk is hammered - I assume this is the run time
system paging. My suspicion is that the program is trying to read in
Ever wanted to see what your Haskell program is doing?
Andy Gill's Hood library (http://www.haskell.org/hood/) represents
a big improvement over previous uses of trace co. It doesn't affect
strictness properties, and instead of displaying debug information
in the nearly incomprehensible order
nil :: List a
cons:: a - List a - List a
forlist :: b - (a - List a - b) - List a - b
..
The implementation I'm interested in (one without
constructors) is:
nil fornil forcons= fornil
consx xs fornil forcons= forcons x xs
forlist
73 matches
Mail list logo
