On Aug 13, 2008, at 5:48 AM, Edgar Friendly wrote:
Brighten Godfrey wrote:
Two things come to mind:
(1) The type of get_f1 is handled analogously to the way it is
handled
for objects, something like this:
val get_f1 : x : 'a; .. - 'a = fun
I'm guessing that if you did this, you
This is a good point. Thanks for the explanation. I'm having a hard
time thinking of any case other than =,, etc where type information
would be necessary to determine code generation. On the other hand
if you break the separation for those operators, maybe it's OK to
break it for
And Darcs the distributed revision control system.
Erik, Darcs is so slow, buggy and broken by design (I speak for direct
experience) that even the GHC team decided to switch to GIT or
Mercurial, see [1] and [2].
Consider this: three years ago I decided to study a functional
language and I had
On Thursday 14 August 2008 03:46:10 David Thomas wrote:
--- On Wed, 8/13/08, Jon Harrop [EMAIL PROTECTED] wrote:
I consider them all to be untested because nobody has ever done anything
significant using Haskell AFAIK.
Besides the window manager I'm currently using... :-P
Interestingly,
Thanks - nice summary
Dave M.
On 14/08/2008, blue storm [EMAIL PROTECTED] wrote:
So it seems the debate went on anyway. I had written something, but when
just before posting i saw Brian Hurt's post, and decided not to. It now
seems i was wrong, and actually (when reading the others) my post
Well said Brian.
Any tutorial is good enough at underlining respective language features.
Haskell has lazy evaluation, Caml has strict evaluation, don't pretend it's a
secret and don't ask whether good or bad.
Be responsible, try it yourself if needed, then choose yourself.
- damien
On Thu, Aug 14, 2008 at 02:57:47PM +0100, Jon Harrop wrote:
and Haskell is faster than most (scripting) languages used these days
anyway).
Despite being written in Python, Mercurial is orders of magnitude faster than
Darcs.
(wow, very funny)
by the same stupid thinking process:
On Thursday 14 August 2008 15:21:40 you wrote:
On Thu, Aug 14, 2008 at 02:57:47PM +0100, Jon Harrop wrote:
and Haskell is faster than most (scripting) languages used these days
anyway).
Despite being written in Python, Mercurial is orders of magnitude faster
than Darcs.
(wow, very
-BEGIN PGP SIGNED MESSAGE-
Hash: SHA1
On Thursday 14 August 2008 10:46:41 am Jim Farrand wrote:
Things like the (=) operator in OCaml vex me. One of the big
advantages of static typing and type inference is that stupid
programmer errors are prevented at compile time. However, the (=)
On Wed, 13 Aug 2008, Jacques Carette wrote:
Here is a much simplified version from a (much) larger problem I have
recently encountered:
type 'a a = [`A of 'a b]
and 'a b = [`B of 'a a]
and 'a c = [`C ]
type 'a d = [ 'a a | 'a b | 'a c]
type e = e d
# this code gives an error (details
2008/8/14 Peng Zang [EMAIL PROTECTED]:
(=) : 'a - 'a - bool
But instead:
(=) : (#equatable as 'a) - 'a - bool
where
class type equatable = object
method equals : 'self - bool
end
This gives all the advantages of static typing and type inference and prevents
stupid errors and
Hello everyone,
We've just noticed that Ocaml permits to declare a value several times in an
.mli file.
For example : We can write in a.mli
val f : int
val f : bool
and it compiles.
But if we define a value f in a.ml it compiles only when f's value is 'a.
From
external files, only
Jon Harrop wrote:
184,574: FFTW (14,298 lines of OCaml)
For FFTW, Ocaml is used the generate C code. Nothing that the final
user of libfftw links to is written in Ocaml. I don't think this one
really counts.
Some of the Haskell projects (e.g. pugs and srcinst) have even *decreased*
in
-BEGIN PGP SIGNED MESSAGE-
Hash: SHA1
On Thursday 14 August 2008 12:04:23 pm Jim Farrand wrote:
This doesn't answer my question at all. :)
Is there any theoretical reason they couldn't added? The kind of
answer I'm looking for is There is no theoretical reason why not, or
This is
Typw inference in haskell is not decideable (nor is it in ocaml when
using objects) and you have to provide some type information. I would
much rather trade some inference for more power in the type system
(value restriction and lack of higher rank polymorphic really kill
some coding styles)
On Thu, Aug 14, 2008 at 7:46 AM, Jim Farrand [EMAIL PROTECTED] wrote:
2008/8/14 Peng Zang [EMAIL PROTECTED]:
In Haskell you can write a function that takes anything that is showable (a
type class) and print it out. The sig would be something like (I'm mixing
OCaml and Haskell syntax here,
On Thursday 14 August 2008 21:57:59 you wrote:
Excerpts from Jon Harrop's message of Thu Aug 14 15:57:47 +0200 2008:
On Thursday 14 August 2008 12:50:43 blue storm wrote:
and Haskell is faster than most (scripting) languages used these days
anyway).
Despite being written in Python,
Excerpts from Jon Harrop's message of Thu Aug 14 23:16:26 +0200 2008:
On Thursday 14 August 2008 21:57:59 you wrote:
Excerpts from Jon Harrop's message of Thu Aug 14 15:57:47 +0200 2008:
On Thursday 14 August 2008 12:50:43 blue storm wrote:
and Haskell is faster than most (scripting)
Nathaniel Gray wrote:
It could be done. See this paper from POPL '07:
http://portal.acm.org/citation.cfm?id=1190215.1190229
That paper seems to be stuck behind the ACM's knowledge firewall and
hence out of reach for people like me.
Fortunately, it also seems to be available here:
On Thu, 14 Aug 2008, Jim Farrand wrote:
2008/8/14 Peng Zang [EMAIL PROTECTED]:
Out of curiosity, are there any theoretical reasons why OCaml could
not be extended with type classes? They are one of my favourite
features of Haskell, and I think they would really improve OCaml.
Because
On Thursday 14 August 2008 22:50:19 you wrote:
I'm talking about the informal algorithms, their independent of that kind
of things...
Yes, that may well be true. I think we would need in-depth knowledge of Darcs
to be able to distinguish between the two.
Do any OCaml projects use Darcs, BTW?
I guess you need it to mirror the value shadowing on the implementation side
:
include Foo
let bar = baz
This is legal if Foo already defines bar, and most of the time desired and
useful.
In the interface file you'll want to write :
include FOO (* Foo's signature *)
val bar : ...
One is that Haskell forces your program into two parts. Parts that contain
side-effects (in monads) and the part that is pure.
You can actually do quite a bit more, using different monads to
compartementalize different aspects of your code. You will, by the
way, have noticed that Haskellers
23 matches
Mail list logo
