Bugs item #608378, was opened at 2002-09-12 13:44
Message generated for change (Settings changed) made by simonmar
You can respond by visiting:
https://sourceforge.net/tracker/?func=detailatid=108032aid=608378group_id=8032
Category: Prelude
Group: 5.04
Status: Closed
Resolution: Fixed
Priority:
Many thanks for Data.HashTable, which I am about to use.
Unfortunately
I seem to need an unseemly hack because the key I want,
namely ThreadId's,
don't have a hash function defined, and defining one requires
me to muck
around with GHC internal functions. Could some more hash
is there a way to go from a CString to a PackedString w/o going through
a normal String in the middle?
or should i write my own?
--
Hal Daume III | [EMAIL PROTECTED]
Arrest this man, he talks in maths. | www.isi.edu/~hdaume
G'day all.
On Wed, Aug 20, 2003 at 07:42:59AM +0200, Jan Scheffczyk wrote:
I always thought that there is a tiny difference between let and where:
They're semantically equivalent. See, for example:
http://haskell.org/onlinereport/decls.html#sect4.4.3.2
Cheers,
Andrew Bromage
Hi all,
Recently I've discovered an inversion operation on forests that transforms
'wide' forests into 'deep' onces and vice versa. I'm sure that this
operation is already known, however, I could not find any information on it.
(Largely because I don't know under what name to look for it.) You
I think similar things have been asked before, but I couldn't find anything
specific.
I have a data type with attributes. These attributes have different types.
Right now I'm using a lot of boilerplate like that:
data Gender = Masc | Fem | Neutr
...
data Attr= Gender Gender | Cat Cat |
[apologies if you receive multiple copies of this message]
---
Weighted Automata: Theory and Applications
Dresden University of Technology, June 1 - 5, 2004
The workshop will cover all aspects of weighted automata,
ranging from the theory
GPCE'03: 2nd International Conference on
Generative Programming and Component Engineering
In Cooperation with ACM SIGPLAN and SIGSOFT and
co-located at NetObjectDays'03
September 22-25, 2003, Erfurt, Germany
I use my 'DynamicMap' type to handle this sort of thing. However, I
don't really recommend this approach unless you're very careful. You
basically lose out on all nice type checking properties and enter a
world of dynamic typing (more or less).
Anyway, you can find it at:
Dear Marnix,
your transformation can be rewritten as the composition of three
functions: one that converts the forest into a binary tree (this
is based on the natural correspondence between forests and binary
trees (*), see Knuth TAOCP, Vol 1), one that mirrors a binary tree
swapping left and
On Wed, 20 Aug 2003 08:25:39 -0700
Hal Daume [EMAIL PROTECTED] wrote:
I use my 'DynamicMap' type to handle this sort of thing. However, I
don't really recommend this approach unless you're very careful. You
basically lose out on all nice type checking properties and enter a
world of dynamic
Wolfgang Jeltsch has observed:
I have this code:
class C a b c | a b - c where
f :: a - b - c
instance C a b c = C a (x,y,b) c where
f a (_,_,b) = f a b
instance C a (a,c,b) c where
f _ (_,c,_) = c
ghci -fglasgow-exts -fallow-overlapping-instances
At 7:42 AM +0200 8/20/03, Jan Scheffczyk wrote:
Hi Andrew,
let x = expensiveComputation foo in x + x
I would certainly hope that expensiveComputation wasn't called twice,
and even though the language doesn't guarantee it, I have already
written code that assumed it.
I always thought that
I want to sequence data structures in an efficient manner, to store them
to files and to send them over the network.
Ideally, I want to be able to write an infinite data structure (at least
one containing loops). If that is not possible I want to be able to read
as lazily as possible, this
On Tue, 19 Aug 2003 14:09:16 +0100 (BST)
C T McBride [EMAIL PROTECTED] wrote:
Hi
As an example, I'll use the Maybe monad. Suppose I want to write
code to handle experimental data, in which there might be missing
values. I might then decide to represent measurements by data of
type
On Wednesday 20 August 2003 9:16 am, Bernard James POPE wrote:
If you can live with supporting only one compiler then you can get a lot of
this done via the FFI.
In buddha, my debugger for Haskell, I have to print pretty versions of
arbitrary data structures, which is in many ways similar to
I want to sequence data structures in an efficient manner, to store
them
to files and to send them over the network.
Simply deriving Show and Read is not very good, because it's space
inefficient and read cannot give any output until the whole data
structure is parsed.
So I thought I should
Tim Docker writes:
:
| The list being folded over
| is implied by the DB query, is accessible through the IO monad.
| Hence a parameter is not required. It would really be:
|
| doquery :: Process - String - b - (b - IO (b,Bool)) - IO b
:
| One thing that I am unsure about is whether the
Hi,
Alistair writes:
This interface looks pretty similar to the interfacein Hugs The module is
hugs98/libraries/Hugs/Internals.hs:
Yes. You may recall that I had something even closer to the Hugs interface
previously which I called GhcInternals. I modelled that on what Hugs
provides.
I even
At 7:42 AM +0200 8/20/03, Jan Scheffczyk wrote:
Hi Andrew,
let x = expensiveComputation foo in x + x
I would certainly hope that expensiveComputation wasn't called twice,
and even though the language doesn't guarantee it, I have already
written code that assumed it.
I always thought that
20 matches
Mail list logo
