On Tue, Apr 17, 2007 at 12:50:48PM +0200, Doaitse Swierstra wrote:
Just to show what kind of problems we are currently facing. The
following type checks in our EHC compiler and in Hugs, but not in the
GHC:
module Test where
data T s = forall x. T (s - (x - s) - (x, s, Int))
run ::
On Tue, Apr 17, 2007 at 11:39:03PM -0700, Brandon Michael Moore wrote:
On Tue, Apr 17, 2007 at 12:50:48PM +0200, Doaitse Swierstra wrote:
Just to show what kind of problems we are currently facing. The
following type checks in our EHC compiler and in Hugs, but not in the
GHC:
Hi all,
Credit Suisse has started using Haskell within GMAG, the group that
provides financial analytics for the bank. The main use of Haskell
is for a Domain Specific Embedded Language that is being used by the
people writing the financial analytics (these people typically have a
PhD
I just started playing around with GHC.PArr and array comprehension
and I was wondering if there is a way to define the transpose of a
matrix using array comprehension?
Cheers
Chris
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
Yep - I've seen it in course work I've set in the past - random walk
through the arrangement of symbols in the language (it was a process
algebra work and proof system to check deadlock freedom).
... but ...
Haskell even helps those people - if you've created something that
works (and you are
On 18/04/07, R Hayes [EMAIL PROTECTED] wrote:
One of the truly powerful things about Haskell is the short distance between
theory and practicality. The problem is how to demonstrate this
convincingly. The ability to prove a program's correctness is regularly
trotted out for show in this arena
[EMAIL PROTECTED] wrote:
How to solve simultaneous
equations using Gaussian elimination comes to mind.
Have a look at one of
file:///usr/local/lib/hugs/demos/Matrix.hs
file:///usr/share/hugs/demos/Matrix.hs
http://darcs.haskell.org/darcsweb/darcsweb.cgi?r=hugs98;a=headblob;f=/demos/Matrix.hs
On Wed, 18 Apr 2007, Chris Witte wrote:
I just started playing around with GHC.PArr and array comprehension
and I was wondering if there is a way to define the transpose of a
matrix using array comprehension?
Why not
let swap :: (i,j) - (j,i)
swap (a,b) = (b,a)
in ixmap (let
Dougal Stanton wrote:
*QuickCheck is a really powerful way to work.*
The real pain in the butt with unit tests is having to write the damn
things. Especially for corner cases - if they were easy to reason
about they wouldn't really be corner cases, would they? QC allows you
to sidestep
Looks like this needs to be run with
#!/usr/lib/ghc-6.6/bin/runghc
{-# OPTIONS_GHC -fglasgow-exts #-}
to get
instance MyString (Either String String)
where mystr = id
instance MyString String
where mystr = Right
to work.
I'm curious if there is a community feeling on whether
Without the flag:
[EMAIL
PROTECTED]:~/websites/gnuplotwebinterface/cgi-bin/gnuplot-scripts./financial2.hs
cisco candles 31-May-04 11-Jun-04
./financial2.hs:58:0:
Illegal instance declaration for `MyString (Either String String)'
(The instance type must be of form (T a b c)
Dougal Stanton wrote:
On 18/04/07, R Hayes [EMAIL PROTECTED] wrote:
One of the truly powerful things about Haskell is the short distance
between
theory and practicality. The problem is how to demonstrate this
convincingly. The ability to prove a program's correctness is regularly
trotted
Hmm, your BDD implementation claims (in the comment at the top) that
Equality is fast and accurate. But you don't do sharing
optimizations, and use derived Eq (rather than object identity), so
it's exponential in the number of nodes. Consider:
A
/ \
B |
\ /
Hi all,
Is there a way to achieve the effect of soft references in GHC? Or if
not, is there any hope that they will be implemented in the future?
(Soft references are like weak references, except that they are only
reclaimed by the garbage collector if memory is short.)
I'm building a
On Apr 16, 2007, at 9:07 AM, Neil Mitchell wrote:
Hi,
I am now releasing Data.Proposition. This library handles
propositions, logical formulae consisting of literals without
quantification. It automatically simplifies a proposition as it is
constructed using simple rules provided by the
Hi
Hmm, your BDD implementation claims (in the comment at the top) that
Equality is fast and accurate. But you don't do sharing
optimizations, and use derived Eq (rather than object identity), so
it's exponential in the number of nodes. Consider:
Its accurate and pretty fast - indeed I
I guess it is time to give my two cents on this topic I am definitely
not an expert Haskell programmer I am a mere hobbyist I make my bread
coding Java/C++/C.
I think the two things I like most about Haskell are
1. Its methods of combination Lazy Eval, Function composition and Higher
order
Suppose I need to manually derive Data and Typeable for SourcePos
from Parsec to make sure my code compiles. I won't actually be
running the code I manually derive since the constructor that
includes SourcePos will be skipped.
With Neil Mitchell's (and #haskell) help I'm doing this to
Hi Joel,
import Data.Generics
import qualified Text.ParserCombinators.Parsec as P
instance Data SourcePos where
gfoldl r k x = k x
typename_SourcePos = mkTyCon SourcePos
instance Typeable SourcePos
where typeOf _ = mkTyConApp typename_SourcePos ([])
strip = everywhere (mkT f)
On Wed, Apr 18, 2007 at 12:34:58PM +1000, Duncan Coutts wrote:
We can't actually guarantee that we have any IEEE format types
available. The isIEEE will tell you if a particular type is indeed IEEE
but what do we do if isIEEE CDouble = False ?
All the computer architectures I've ever used had
On 4/18/07, Taillefer, Troy (EXP) [EMAIL PROTECTED] wrote:
I have to strongly disagree with the statement that developers like to
debug. Debugging is necessary because you can't reason about any
sizeable piece of code just is not tractable even in Haskell. Now
automated tools for reasoning
Here here.
This reminds me of a recent discussion on the cafe. Thee OP amounted
to: What are the monad laws good for?. The answer was: It means the
monad doesn't do surprising things and its behavior is congruent with
the basic intuitions of sequenced computation.
In my eyes, proving nice
I still love Haskell, but...
since the language doesn't do batshit insane things behind your back
- Hmmm... I'd contend that the Haskell language is the one language that
does the most batshit insane things behind your back, for instance list
fusion. This is probably because there
It is unscientific to ask the (highly biased) people on this list how to
sell Haskell. A focus group of the target audience is clearly called
for. Having said that, I will now violate my own advice.
Knowledge of the audience is critical to the success of a presentation.
Simon (aka Dumbledore)
===LONG WINDED RANT WARNING
==
I am not try to hate on Haskell obviously I am a fan otherwise I
wouldn't be on this list but criticizing other languages
is not only a pointless waste of time it is logically flawed on many
levels.
A lot
On 4/18/07, Taillefer, Troy (EXP) [EMAIL PROTECTED] wrote:
Sorry for the long rant but I get tired of people with their juvenile and
unconstructive statements like C++ sucks
Or Language X is better then Language Y even if it could ever be
objectively true (which I am sorry it can't be) who
Dan Weston wrote:
Simon (aka Dumbledore) is speaking to four different Houses:
scientists (Ravenclaw), engineers (Hufflepuff), entrepreneurs
(Slytherin), and managers (Griffindor).
Agreed, although perhaps there are two groups of scientists: Computer
Scientists and Other Scientists. Dan
Paul Johnson wrote:
You cannot win over the entrepreneur with promises of easier and more
robust. This translates to anyone can do it and the valuable trade
secret of arcane wizardry is now devalued.
I suggest reading extracts from Beating the Averages by Paul Graham.
Then explain that
Seth Gordon wrote:
I think a more powerful argument would be to talk about cases where
Haskell is *actually being used* industrially. E.g., these folks at
Credit Suisse are using Haskell for their analytics because in their
line of work, if the implementation of the code doesn't match up
In general, problems that would lose millions of dollars are noticed
very quickly. Quants are constantly analyzing the sources of
shortfall in implementing strategies. Also, time to market is
generally more important than correctness. It's much better to have
a strategy that mostly
On Wed, 2007-04-18 at 16:17 +0300, Benja Fallenstein wrote:
Hi all,
Is there a way to achieve the effect of soft references in GHC? Or if
not, is there any hope that they will be implemented in the future?
(Soft references are like weak references, except that they are only
reclaimed by the
That was beautiful, thanks. :-)
On Wed, 2007-04-18 at 12:45 -0700, Dan Weston wrote:
Simon (aka Dumbledore) is speaking to four different Houses: scientists
(Ravenclaw), engineers (Hufflepuff), entrepreneurs (Slytherin), and
managers (Griffindor). My advice to him is:
On Wed, 2007-04-18 at 08:30 -0700, David Roundy wrote:
On Wed, Apr 18, 2007 at 12:34:58PM +1000, Duncan Coutts wrote:
We can't actually guarantee that we have any IEEE format types
available. The isIEEE will tell you if a particular type is indeed IEEE
but what do we do if isIEEE CDouble =
On Wed, 2007-04-18 at 08:34 -0700, Bryan O'Sullivan wrote:
Duncan Coutts wrote:
I'm currently exploring more design ideas for Data.Binary including how
to deal with alignment. Eliminating unnecessary bounds checks and using
aligned memory operations also significantly improves
Hi,
I've been wondering what is essential to Haskell and what isn't. Not
from a point of view of what could be removed from the language, but
what could be removed from a Core language.
Given the features of higher-order, laziness and data types:
Laziness can be converted to higher-order
Hi
A first order language without data types cannot exist - what could
the arguments of functions be, if they cannot be function types or
data types?
I should have clarified, in my mind I was thinking allowing only
non-recursive constants, namely Int's.
If you allow recursive primitive
As one who teaches programming in a lot of different languages, I can
state unequivocally that strong static typing of the Haskell or Ocaml
variety is (in addition to all its other benefits) a godsend to the
instructor. So many incorrect ways of writing programs are simply ruled
out right at
On Thu, Apr 19, 2007 at 10:20:21AM +1000, Duncan Coutts wrote:
and people will for ever be defining newtype wrappers or complaining
that the whole library isn't parametrised by the endianness or whatever.
For existing formats you need much more flexibility and control. The
Binary class is to
On Thu, Apr 19, 2007 at 02:47:30AM +0100, Neil Mitchell wrote:
Hi,
I've been wondering what is essential to Haskell and what isn't. Not
from a point of view of what could be removed from the language, but
what could be removed from a Core language.
Given the features of higher-order,
I was trying to use the array comprehension of the Data Parallel
Haskell package.
http://haskell.org/haskellwiki/GHC/Data_Parallel_Haskell
for instance I can define
{-# OPTIONS -fparr -fglasgow-exts #-}
module MatTest
where
import GHC.PArr
ident = [:[:1,0:],[:0,1:]:]
aVect = [:4,5:]
dotP ::
40 matches
Mail list logo
