John Meacham wrote:
interestingly enough, the monomorphism restriction in jhc actually
should apply to all polymorphic values, independently of the type class
system.
x :: a
x = x
will transform into something that takes a type parameter and is hence
not shared.
Interesting. I'd been
Chris Kuklewicz wrote:
Weak uses seq to achieve WHNF for it's argument
newtype Weak a = WeakCon {runWeak :: a}
mkWeak x = seq x (WeakCon x)
unsafeMkWeak x = WeakCon x
This doesn't actually do what you think it does. mkWeak and unsafeMkWeak are
the same function.
mkWeak 123 = seq 123
Marcin 'Qrczak' Kowalczyk wrote:
Encouraged by Mono, for my language Kogut I adopted a hack that
Unicode people hate: the possibility to use a modified UTF-8 variant
where byte sequences which are illegal in UTF-8 are decoded into
U+ followed by another character.
I don't like the idea of
Pursuant to a recent conversation with Simon, my previous post to this
thread is now obsolete. So please ignore it, and see the updated wiki page
instead.
-- Ben
___
Haskell-prime mailing list
Haskell-prime@haskell.org
Jim Apple wrote:
Have we considered Restricted Data Types?
http://www.cs.chalmers.se/~rjmh/Papers/restricted-datatypes.ps
I'd never seen this paper before. This would be a really nice extension to
have. The dictionary wrangling looks nasty, but I think it would be easy to
implement it in
John Hughes wrote:
That means that the Monad class is not allowed to declare
return :: a - m a
because there's no guarantee that the type m a would be well-formed. The
type declared for return has to become
return :: wft (m a) = a - m a
I'm confused. It seems like the type (a - m a)
Simon PJ thinks that Haskell' should include scoped type variables, and I
tend to agree. But I'm unhappy with one aspect of the way they're
implemented in GHC. What I don't like is that given a signature like
x :: a - a
there's no way to tell, looking at it in isolation, whether a is free
Bulat Ziganshin wrote:
{-# OPTIONS_GHC -fglasgow-exts #-}
main = do return xx = ((\x - print x) :: Show a = a - IO ())
main2 = do return xx = (\(x:: (forall a . (Show a) = a)) - print x)
main3 = do (x :: forall a . Show a = a) - return xx
print x
in this module, only main compiles ok
Simon Peyton-Jones wrote:
Another reasonable alternative is
data Set a = Eq a = Set (List a)
The type of member would become
member :: a - Set a - Bool
(with no Eq constraint).
John Hughes mentions this in section 5.2 of the paper, and points out a
problem: a function like
Philippa Cowderoy wrote:
Myself I'm of the view transformational patterns (as described in
http://citeseer.ist.psu.edu/299277.html) are more interesting - I can't
help wondering why they were never implemented?
Maybe because of tricky semantics. I'm not quite sure what
case x of
Ross Paterson wrote:
I don't think the original name is inappropriate: the feature described
is certainly existential quantification, albeit restricted to
alternatives of data definitions.
I think that existential quantification should mean, well, existential
quantification, in the sense that
Simon Marlow wrote:
there's a lack of modularity in the current
design, such that renaming the root of a module hierarchy requires
editing every single source file in the hierarchy. The only good reason
for this is the separation between language and implementation.
I don't see how this is
Ashley Yakeley wrote:
foo :: (Monad m) = [m a] - m [a]
instance Integral a = Eq (Ratio a)
class Monad m = MonadPlus m
I think the most consistent (not most convenient!) syntax would be
foo :: forall m a. (Monad m) = [m a] - m [a]
instance forall a. (Integral a) = Eq (Ratio a)
Malcolm Wallace wrote:
An explicit interface would be useful for many purposes besides
machine-checked documentation. For instance, it could be used to
eliminate the hs-boot or hi-boot files used by some compilers when
dealing with recursive modules.
Why *does* ghc require hs-boot files? What
I wrote:
What I don't like is that given a signature like
x :: a - a
there's no way to tell, looking at it in isolation, whether a is free or
bound in the type. [...]
Here's a completely different idea for solving this. It occurs to me that
there isn't all that much difference between
Niklas Broberg wrote:
Ben Rudiak-Gould wrote:
Are there uses of overlapping
instances for which this isn't flexible enough?
Certainly!
Hmm... well, what about at least permitting intra-module overlap in Haskell'
(and in GHC without -foverlapping-instances)? It's good enough for many
John Meacham wrote:
On Thu, Mar 02, 2006 at 03:53:45AM -, Claus Reinke wrote:
the problem is that we have somehow conjured up an infinite
type for Mul to recurse on without end! Normally, such infinite
types are ruled out by occurs-checks (unless you are working
with Prolog III;-), so
Philippa Cowderoy wrote:
On Wed, 8 Mar 2006, Doaitse Swierstra wrote:
xs `zipWith (+)` ys
There is one problem with this: it doesn't nest [...]
Another problem is that it's not clear how to declare the fixity of these
things. Should they always have the default fixity? Should they be
John Meacham wrote:
ghc's strictness analyzer is pretty darn good, If
something is subtle enough for the compiler not to catch it, then the
programmer probably won't right off the bat either.
Even the best strictness analyzer can't determine that a function is strict
when it really isn't. The
Bulat Ziganshin wrote:
Taral wrote:
T I don't see that more optimization follows from the availability
T of information regarding the strictness of a function result's
T subcomponents.
ghc uses unboxed tuples just for such sort of optimizations. instead
of returning possibly-unevaluated pair
Andy Gill wrote:
- [various reasons for deepSeq]
You left out the one that most interests me: ensuring that there are no
exceptions hiding inside a data structure.
deepSeq :: a - b - b
This ties demand for the (fully evaluated) normal form of an expression to
demand for the WHNF of a
Johannes Waldmann wrote:
class ( Show p, ToDoc i, Reader b, ToDoc b, Measure p i b )
= Partial p i b | p i - b where ... -- (*)
(*) A funny visual aspect of FDs is the absurd syntax.
On the left of |, the whitespace is (type arg) application,
but on the right, it suddenly denotes
[EMAIL PROTECTED] wrote:
I think that computable real fixity levels are useful, too.
Only finitely many operators can be declared in a given Haskell program.
Thus the strongest property you need in your set of precedence levels is
that given arbitrary finite sets of precedences A and B, with
I'm surprised that no one has mentioned showsPrec and readsPrec. Anything
more complicated than negative fixities would require their interfaces to be
changed.
-- Ben
___
Haskell-prime mailing list
Haskell-prime@haskell.org
24 matches
Mail list logo