#4485: Per-class incoherence, and solve incoherent instances last
--+-
Reporter: JeremyShaw | Owner:
Type: bug | Status: closed
#4485: Per-class incoherence, and solve incoherent instances last
-+--
Reporter: JeremyShaw|Owner:
Type: bug | Status: new
#4485: Per-class incoherence, and solve incoherent instances last
-+--
Reporter: JeremyShaw|Owner:
Type: bug | Status: new
#4485: Per-class incoherence, and solve incoherent instances last
-+--
Reporter: JeremyShaw|Owner:
Type: bug | Status: new
John Hughes wrote:
We can construct rather large polymorphic values, which have
to be converted in linear time to the same value of a
different type.
All true, but I doubt whether any of this is a big deal. MLers already live
with their value restriction, which has
John Hughes wrote:
What we need is different binding syntax for monomorphic and polymorphic
bindings. Roll on := and = ...
I agree absolutely that we need such a distinction. Although it's
worth clarifying a point. The monomorphism restriction
John Hughes wrote:
| `x := []' wouldn't be problematic, just monomorphic.
| That is, x must be used consistently as a list of a
| particular type.
Just to check if I understand you correctly. In your
proposal, does the following thing share `x'?
let x = fac 100 in x + x
(My understanding
Hi!
The binding form := must absolutely have a completely monomorphic type.
A while back I posted the result that the MR kills principal types in
Haskell. The problem with the MR is exactly that it introduces types
which may be polymorphic but not overloaded. So if we want to regain
principal
On Thursday 25 October 2001 07:21 am, John Hughes wrote:
My proposal is that := should bind *monomorphically* -- just like lambda
binding. The motivation for that is that a polymorphic function can easily
become overloaded after a small change to the program, such as adding
removal of
On Thu, Oct 25, 2001 at 09:47:31AM +, Levent Erkok wrote:
Another place where `:=' bindings are badly needed is the recursive
do-notation (mdo, as supported in hugs.) In an mdo, let bindings have
to be monomorphic, because they are passed back to the mfix loop in a
lambda binding. Hence,
Thu, 25 Oct 2001 09:47:31 +, Levent Erkok [EMAIL PROTECTED] pisze:
Another place where `:=' bindings are badly needed is the recursive
do-notation (mdo, as supported in hugs.) In an mdo, let bindings
have to be monomorphic, because they are passed back to the mfix
loop in a lambda
John Hughes wrote:
I noticed today that the presence or absence of a type signature can
change the RESULT of an expression in Hugs and GHC nowadays. Here's an
example:
a = (let x = ?x in
x with ?x = 1)
John Hughes wrote:
What we need is different binding syntax for monomorphic and polymorphic
bindings. Roll on := and = ...
If I recall correctly, in some earlier language (KRC?)
this difference was achieved by letting let-bindings be
polymorphic, and where-bindings be monomorphic.
The idea
John Hughes wrote:
What we need is different binding syntax for monomorphic and polymorphic
bindings. Roll on := and = ...
If I recall correctly, in some earlier language (KRC?)
this difference was achieved by letting let-bindings be
John Hughes wrote:
What we need is different binding syntax for monomorphic and polymorphic
bindings. Roll on := and = ...
I agree absolutely that we need such a distinction. Although it's worth clarifying a
point. The monomorphism restriction doesn't exclude polymorphism, just
I noticed today that the presence or absence of a type signature can
change the RESULT of an expression in Hugs and GHC nowadays. Here's an
example:
a = (let x = ?x in
x with ?x = 1)
with ?x = 2
-- a == 2
b = (let x :: (?x :: Integer) = Integer
x = ?x
Tue, 23 Oct 2001 08:00:34 -0700, Jeffrey R Lewis [EMAIL PROTECTED] pisze:
The best solution is to find a good way to eliminate the DMR.
Separating syntaxes of function definition and pattern binding would
have the right effect IMHO, but it's a radical change which breaks
compatibility and
17 matches
Mail list logo
