On Sun, 16 Nov 2008, Neal Alexander wrote:
Brent Yorgey wrote:
---
ANN: OpenGL with extra type safety. Neal Alexander
Hopefully the code will be uploaded to Hackage as a separate package soon.
Hello,
I am very new to Haskell, this is my first day, and I wanted to know
if it is possible to prove correctness of a multi-threaded application
written in Haskell.
Basically, I want to check that a multi-threaded implementation of an
algorithm that detects cycles in a dynamically
Luke Palmer [EMAIL PROTECTED] writes:
STM
My apologies for side-tracking, but does anybody have performance
numbers for STM? I have an application waiting to be written using
STM, boldly parallelizing where no man has parallelized before, but if
it doesn't make it faster, the whole excercise
On Mon, Nov 17, 2008 at 4:04 AM, Silviu ANDRICA [EMAIL PROTECTED] wrote:
Hello,
I am very new to Haskell, this is my first day, and I wanted to know if it
is possible to prove correctness of a multi-threaded application written in
Haskell.
Basically, I want to check that a multi-threaded
Why is this wrong? (...)
(...) One way to code this would be to use functional dependencies:
class MyClass r s | r - s where function :: r - s
data MyData u = MyData u
instance MyClass (MyData v) v where function (MyData a) = a
One additional problem is that I (believe I) need that my
(...)
GHC says that the type of the result of 'function' is both determined by
the rigid type from MyClass and the rigid type from MyData. But why
can't both be the same?
are you OOPer? :)
What is an OOPer?
___
Haskell-Cafe mailing list
On Mon, 2008-11-17 at 16:39 -0200, Maurício wrote:
(...)
GHC says that the type of the result of 'function' is both determined by
the rigid type from MyClass and the rigid type from MyData. But why
can't both be the same?
are you OOPer? :)
What is an OOPer?
Object-Oriented
Jonathan Cast wrote:
[Functional and object-oriented programming] have points of similarity, but
on net the
best plan is to simply never reason analogically from one to the other.
Coming from the OO world, I found it very useful to see how the same
solution is modeled using different
Hello Maurício,
Monday, November 17, 2008, 9:38:06 PM, you wrote:
(...) One way to code this would be to use functional dependencies:
class MyClass r s | r - s where function :: r - s
One additional problem is that I (believe I) need that my class takes
just one type
FDs with just
On Mon, Nov 17, 2008 at 10:39 AM, Maurício [EMAIL PROTECTED] wrote:
(...)
GHC says that the type of the result of 'function' is both determined by
the rigid type from MyClass and the rigid type from MyData. But why
can't both be the same?
are you OOPer? :)
What is an OOPer?
I
On Mon, Nov 17, 2008 at 10:38 AM, Maurício [EMAIL PROTECTED] wrote:
newtype ComplexWithDouble = ComplexWithDouble (ComplexNumber Double)
deriving ...
Perhaps you want something like:
class Complex r c | c - r
where makeComplex :: r - r - c
realPart :: c - r
imagPart
Ketil Malde wrote:
My apologies for side-tracking, but does anybody have performance
numbers for STM? I have an application waiting to be written using
STM, boldly parallelizing where no man has parallelized before, but
if it doesn't make it faster, the whole excercise gets a lot less
Dear Haskell users,
I am working on a command-driven tool (::IO ()).
If the system invokes itself again, and the system's returned
data type would be 'IO a', say (IO Exp) (Expression).
tool:: a - IO()
The nested tool invocation returns (IO Exp) to the previous tool.
I am using dynamic error
(...) I don't recall where I found the following example, but copied
it locally as compelling evidence that the functional solution can be
much clearer and shorter than the same solution modeled with objects
and inheritance.
Greg,
I desagree with you. Bjarne Stroustrup, the original
On Mon, 2008-11-17 at 21:49 -0200, Maurício wrote:
(...) I don't recall where I found the following example, but copied
it locally as compelling evidence that the functional solution can be
much clearer and shorter than the same solution modeled with objects
and inheritance.
On Mon, Nov 17, 2008 at 9:49 PM, Maurício [EMAIL PROTECTED] wrote:
(...) I don't recall where I found the following example, but copied
it locally as compelling evidence that the functional solution can be
much clearer and shorter than the same solution modeled with objects
and
On Mon, 2008-11-17 at 16:04 -0800, Jonathan Cast wrote:
On Mon, 2008-11-17 at 21:49 -0200, Maurício wrote:
(...) I don't recall where I found the following example, but copied
it locally as compelling evidence that the functional solution can be
much clearer and shorter than the
Jason Dagit dagit at codersbase.com writes:
Hello,
Has anyone already made a tool to check if exported functions, data
constructors, types, etc are unused within a set of modules?
My SourceGraph programme (available on Hackage) can do this with a few
caveats:
1) Only supports functions,
On Mon, Nov 17, 2008 at 4:36 PM, Ivan Lazar Miljenovic
[EMAIL PROTECTED] wrote:
Jason Dagit dagit at codersbase.com writes:
Hello,
Has anyone already made a tool to check if exported functions, data
constructors, types, etc are unused within a set of modules?
My SourceGraph
2008/11/15 Galchin, Vasili [EMAIL PROTECTED]:
Hello,
I am looking for something to work on. Where are there perceived holes
in the Haskell library support?
Regards, Vasili
Hello Vasili
Maybe the haskell.org wiki would be a good place for people to record
their suggestions?
Hi,
What is the situation regarding statically dimension-checked linear
algebra libraries? It seems that Frederik Eaton was working on one in
2006 (see the paper Statically typed linear algebra in Haskell), and
he produced the Vectro library from this, based on GSLHaskell.
Are there any more
I wrote:
I don't recall where I found the following example
My apologies to Ralf Lammel and Ondrej Rypacek. Five seconds on
Google tells me I had copied that code verbatim from their paper, The
expression lemma.
http://www.uni-koblenz.de/~laemmel/expression/long.pdf
Great paper, by the way!
Tim Docker [EMAIL PROTECTED] writes:
My apologies for side-tracking, but does anybody have performance
numbers for STM? I have an application waiting to be written using
STM, boldly parallelizing where no man has parallelized before, but
if it doesn't make it faster,
Faster than what?
Is there a simple existing library that provides views of data types in
terms of unit, product and sum?
Here's what I threw together for my own use. I used associated types,
though functional dependencies would work as well.
class HasView t where
type View t
view :: t - View t
Hello Conal,
What you've done looks very much like the Regular datatype [1] in the
rewriting library [2]. The rewriting library, as its name indicates, is very
much targeted at rewriting. For a more complete library using a sum of
products view (and without type synonyms), try the new release of
If you have multiple agents interacting with some structure and you
want it to look like each of them is accessing it serialized, then STM
is exactly what you want.
The performance is always in comparison to what; you will likely get
worse performance than the best possible implementation of your
Perhaps you want something like:
class Complex r c | c - r
where makeComplex :: r - r - c
realPart :: c - r
imagPart :: c - r
data ComplexNumber t = CN t t
instance Complex t (ComplexNumber t)
where makeComplex = CN
realPart (CN r _) = r
imagPart
David,
I had to bring up a parenthetical from your message because I think it
is often a point of confusion:
2008/11/17 David Leimbach [EMAIL PROTECTED]:
(Would it then be fair to equate a Haskell class to a Java Interface, but not
to a Java class?)
This is a dangerous direction to go,
28 matches
Mail list logo
