On Sun, Mar 16, 2014 at 11:06 AM, Christiaan Baaij
christiaan.ba...@gmail.com wrote:
Iavor is working on a branch that allows the constraint solver to call an
external solver: https://github.com/ghc/ghc/tree/decision-procedure
Currently, it: a) only supports CVC4 (an SMT solver), and b) is
-- unix-bytestring 0.3.7
The unix-bytestring package offers a full selection of Unix/Posix-specific
functions for reading and writing ByteStrings to Fds.
--
On 7/22/13 7:41 PM, David Thomas wrote:
On Mon, Jul 22, 2013 at 4:04 PM, wren ng thornton w...@freegeek.org
wrote:
In principle, we could translate between these two forms (the f2 == f1
direction requires detecting that y does not depend on x). However, in
practice, the compiler has no way
On 7/23/13 9:01 PM, Michael Orlitzky wrote:
Obviously not what I want! Has anyone
else run into this? Figured out a workaround?
I haven't run into this specific problem, but I do have a sort of
workaround. Whenever dealing with CmdArgs (or any similar system) I
typically define *two* record
On 7/22/13 9:06 AM, Tom Ellis wrote:
On Mon, Jul 22, 2013 at 07:52:06PM +1200, Chris Wong wrote:
A binding is memoized if, ignoring everything after the equals sign,
it looks like a constant.
In other words, these are memoized:
[...]
f = \x - x + 1
[...]
and these are not:
f x
-- data-fin 0.1.0
The data-fin package offers the family of totally ordered finite sets,
implemented as newtypes of Integer, etc. Thus, you get all the joys of:
data Nat = Zero | Succ !Nat
data Fin
On 6/1/13 3:18 PM, TP wrote:
In other words, bottom can be an inhabitant of a concrete type, not a type
constructor, which I can understand. But a type of kind Nat is a concrete
type, so why bottom cannot be an inhabitant of this type?
The technical term is proper type. That is, types are used
-- stm-chans 2.1 / 3.0
The stm-chans package offers a collection of channel types, similar to
Control.Concurrent.STM.{TChan,TQueue} but with additional features.
On 5/27/13 5:29 PM, Alexander Solla wrote:
As per recent discussions, I'm making a list of volunteers who are willing
to pick up some slack in Hackage package maintenance, so that we can submit
an amendment to the Haskell Prime Committee's ticket 113 (
-- prelude-safeenum 0.1.0
The prelude-safeenum package offers a safe alternative to the Prelude's
Enum class in order to render it safe. While we're at it, we also
generalize the notion of enumeration to
-- stm-chans 2.0.0
The stm-chans package offers a collection of channel types, similar to
Control.Concurrent.STM.{TChan,TQueue} but with additional features.
--
On 5/8/13 12:14 PM, Conal Elliott wrote:
Hi Wren,
Have you taken this constrained categories experiment further,
particularly for adding products? As I mentioned in a haskell-cafe note
yesterday, I tried and got a frightening proliferation of constraints when
defining method defaults and
Hello all,
So I'm processing a large XML file which is a database of about 170k
entries, each of which is a reasonable enough size on its own, and I only
need streaming access to the database (basically printing out summary data
for each entry). Excellent, sounds like a job for SAX.
However,
On 4/25/13 9:49 PM, Dan Doel wrote:
I don't really think they're worth saving in general, though. I haven't
missed them, at least.
The thing I've missed them for (and what I believe they were originally
designed for) is adding constraints to derived instances. That is, if I
have:
data Bar
On 4/14/13 8:53 PM, Kim-Ee Yeoh wrote:
On Sun, Apr 14, 2013 at 3:28 PM, wren ng thornton w...@freegeek.org
wrote:
Whereas the problematic
values due to infinities are overspecified, so no matter which answer you
pick it's guaranteed to be the wrong answer half the time.
Part of this whole
On 4/13/13 1:18 PM, Jerzy Karczmarczuk wrote:
This is not a Haskell problem. For Ints, ALL representations are valid
numbers, a NaN is a specific float object, unless I'm mistaken, so the
introduction of such an abnormal number would require some serious
modifications of the representation.
On 4/3/13 11:46 PM, Albert Y. C. Lai wrote:
On 13-04-03 07:39 PM, Alexander Solla wrote:
There's your problem. Mathematicians do this specifically because it is
helpful. If anything, explicit quantifiers and their interpretations
are more complicated. People seem to naturally get how
-- bytestring-lexing 0.4.3
The bytestring-lexing package offers efficient reading and packing of
common types like Double and Integral types.
-- Changes (since
-- bytestring-lexing 0.4.2
The bytestring-lexing package offers efficient reading and packing of
common types like Double and Integral types.
-- Changes (since
On 3/15/13 3:29 PM, Evan Laforge wrote:
However, which error msg shows up depends on the order of the (|)
alternatives, and in general the global structure of the entire
parser, because I think it just backtracks and then picks the last
failing backtrack. Even after carefully rearranging all
On 2/27/13 2:17 AM, Vincent Hanquez wrote:
Two major problems of lazy bytestrings is that:
* you can't pass it to a C bindings easily.
* doing IO with it without rewriting the chunks, can sometimes (depending
how the lazy bytestring has been produced) result in a serious
degradation of
On 2/24/13 7:56 AM, Kim-Ee Yeoh wrote:
On Sun, Feb 24, 2013 at 7:47 PM, Roman Cheplyaka r...@ro-che.info wrote:
Or perhaps you meant that the production itself, when interpreted as a
definition, is corecursive?
I was merely thrown off by your mention of well-founded and the assertion
that
On 2/13/13 11:18 PM, wren ng thornton wrote:
On 2/13/13 11:32 AM, Nicolas Bock wrote:
Since I have very little experience with Haskell and am not used to
Haskell-think yet, I don't quite understand your statement that
regexes are
seen as foreign to Haskell-think. Could you elaborate? What would
On 2/12/13 5:47 PM, Nehal Patel wrote:
And so my question is, that in 2013, why isn't this process a full fledged part
of the language? I imagine I just don't know what I'm talking about, so correct
me if I'm wrong, but this is how I understand the workflow used in practice
with program
On 2/13/13 3:55 AM, Andrew Polonsky wrote:
Hello,
Is there any difference in efficiency between these two functions, when
compiled with all optimizations?
map f [] = []
map f (a:as) = f a : map f as
and
map f x = map' x where
map' [] = []
map' (a:as) = f a : map' as
As Alp says,
On 2/13/13 11:32 AM, Nicolas Bock wrote:
Since I have very little experience with Haskell and am not used to
Haskell-think yet, I don't quite understand your statement that regexes are
seen as foreign to Haskell-think. Could you elaborate? What would a more
native solution look like? From what I
On 2/12/13 3:37 AM, Simon Marlow wrote:
One reason for the major version bumps is that base is a big
conglomeration of modules, ranging from those that hardly ever change
(Prelude) to those that change frequently (GHC.*). For example, the new
IO manager that is about to get merged in will force
On 2/11/13 11:47 AM, Johan Holmquist wrote:
I was about to leave this topic not to swamp the list with something
that appears to go nowere. But now I feel that I must answer the
comments, so here it goes.
By agressive optimisation I mean an optimisation that drastically
reduces run-time
On 1/30/13 7:21 AM, Jan Stolarek wrote:
I will be writing a parser in Haskell and I wonder how to approach the problem.
My first thought
was to use monadic parser, e.g. like the one described by Hutton and Meijer in
Monadic Parsing
in Haskell functional pearl. But then I stumbled upon this:
On 1/29/13 4:25 AM, Junior White wrote:
Hi Cafe,
I have two programs for the same problem Eight queens problem,
the link is http://www.haskell.org/haskellwiki/99_questions/90_to_94.
My two grograms only has little difference, but the performance, this is
my solution:
The difference is
On 1/24/13 1:40 AM, Ertugrul Söylemez wrote:
David Thomas davidleotho...@gmail.com wrote:
We could even set up NotOnHackage: a package repository just like
Hackage, except the packages are just documentation on why there is
no such package. Implementation-wise it's just a wiki; but the idea
is
On 1/23/13 3:00 AM, Alexander Kjeldaas wrote:
If we step back, I think the lesson here is that Haskell libraries exist,
but the concepts are far enough from what you expect to exist given
background knowledge from another programming language.
So what is actually needed is not monad-bool, but
On 1/21/13 1:40 AM, Shachaf Ben-Kiki wrote:
For example:
{-# LANGUAGE TypeFamilies #-}
import Unsafe.Coerce
newtype Id a = MkId { unId :: a }
{-# RULES fmap unId fmap unId = unsafeCoerce #-}
data family Foo x y a
data instance Foo x y (Id a) = FooI x
data
On 1/14/13 1:09 PM, Simon Peyton-Jones wrote:
Friends
I'd like to propose a way to promote newtypes over their enclosing type.
Here's the writeup
http://hackage.haskell.org/trac/ghc/wiki/NewtypeWrappers
Any comments? Below is the problem statement, taken from the above page.
I'd
On 1/14/13 2:47 PM, Stephen Paul Weber wrote:
Somebody claiming to be Simon Peyton-Jones wrote:
* For x1 we can write map MkAge x1 :: [Age]. But this does not
follow the newtype cost model: there will be runtime overhead from
executing the map at runtime, and sharing will be lost too.
On 1/14/13 9:15 PM, Iavor Diatchki wrote:
It looks like what we need is a different concept: one that talks about the
equality of the representations of types, rather then equality of the types
themselves.
+1.
In fact, this distinction is one of the crucial ones I had in mind when
working on
On 1/13/13 12:44 PM, Alexander Solla wrote:
Hask is a very rich category, and is suitable for encoding a lot (but not
all) of category theory. As far as I know, the actual boundary is as yet
unknown.
I'm not sure that's the most appropriate way to render things. In
general, rich categories
On 1/13/13 1:53 PM, Alfredo Di Napoli wrote:
Thank you Alexander for the reply.
My wondering is: is Hask a category created by Haskell researchers or was
something already present in literature?
Hask was created by Haskellers in discussions on blogs etc. If one is
being particular about the
On 1/13/13 3:52 PM, Iavor Diatchki wrote:
On Sun, Jan 13, 2013 at 12:05 PM, Conal Elliott co...@conal.net wrote:
so there is really no way for GHC to figure out what is the intended value
for `a`.
Indeed. Though I wonder: does the type-checker really need to find a
binding for `a` in this
On 12/31/12 4:26 PM, Rico Moorman wrote:
Hello Bob and Mike,
Reading a little within the suggested book I came across the following
statement.
We should first examine the merits and limitations of the traditional
approach: using
functions as a basis for the architecture of software systems.
On 12/21/12 3:27 AM, Oleksandr Manzyuk wrote:
On Fri, Dec 21, 2012 at 4:40 AM, Alexander Solla alex.so...@gmail.com wrote:
I don't see how associativity fails, if we mod out alpha-equivalence. Can
you give an example? (If it involves the value undefined, I'll have
something concrete to add
On 12/20/12 7:07 PM, Christopher Howard wrote:
On 12/20/2012 03:59 AM, wren ng thornton wrote:
In order to fake this theory in Haskell we can do:
newtype MonoidCategory a i j = MC a
instance Monoid a = Category (MonoidCategory a) where
id = MC mempty
MC f
On 12/21/12 2:35 PM, Chris Smith wrote:
It would definitely be nice to be able to work with a partial Category
class, where for example the objects could be constrained to belong to a
class. One could then restrict a Category to a type level representation
of the natural numbers or any other
On 12/17/12 9:45 PM, Christopher Howard wrote:
So you could have...
(coupler . thing) . gadget
Because the coupler and the thing would combine to create a component
with one spare connector. This would then combine with the gadget to
make the final component. However, if you did...
coupler .
On 12/18/12 5:03 PM, Christopher Howard wrote:
Since I received the two responses to my question, I've been trying to
think deeply about this subject, and go back and understand the core
ideas. I think the problem is that I really don't have a clear
understanding of the basics of category
On 12/20/12 6:42 AM, Christopher Howard wrote:
code:
instance Category Integer where
id = 1
(.) = (*)
-- and
instance Category [a] where
id = []
(.) = (++)
---
But these lead to kind mis-matches.
As mentioned in my other email (just posted) the kind mismatch is
On 12/14/12 10:56 AM, Gershom Bazerman wrote:
On 12/14/12 9:44 AM, Simon Peyton-Jones wrote:
This thread has made it clear that we should do more to help people
find a way in to GHC. Here is what I have done:
·Started a GHC Reading List page
On 12/12/12 3:07 AM, Janek S. wrote:
Dnia środa, 12 grudnia 2012, wren ng thornton napisał:
Other than that, it's hard to say. What part of the compiler are you
(most) interested in hacking on? The type system? The compilation down
to C-- and LLVM? The concurrency and parallelism? Debugging
On 12/13/12 3:14 AM, Colin Adams wrote:
Presumably you are talking about companies who want to distribute programs
(a very small minority of companies, I would think)?
Not at all. In addition to Michael's own rebuttal, I'll add my own.
There are many companies which *fear* the L/GPL. The
On 12/13/12 9:30 AM, Herbert Valerio Riedel wrote:
Alfredo Di Napoli alfredo.dinap...@gmail.com writes:
Let me just chime in to give my 2 cents; I quote Micheal 100%; if we want
to push Haskell out of the academic/open source world to the real world,
well, GPL is not the way to go, due to its
On 12/11/12 8:58 AM, Janek S. wrote:
Dear list,
I would like to learn about internals of GHC and contribute to its development
in the future. I
read a couple of papers that give a very general overview of GHC (chapter from
AoS, papers about
inliner and multicore support) and I'm thinking what
On 12/11/12 9:29 AM, Janek S. wrote:
One way to do that would be to have a page (wiki, perhaps) that has a
reading list for learning about GHC.
Well, I think that GHC wiki has really decent commentary. I'm just not sure if
reading it will be
enough to get started (probably not). So guidance
On 12/11/12 9:30 PM, Ramana Kumar wrote:
I wonder if this discussion has been had before in the Haskell community.
If so, pointers to archives could be of interest.
Indeed, the discussion has been had more than once. Alas, I'm too bogged
for time to look up the archives at the moment.
I'm
Hello all,
I'm one of those curmudgeons still working on OSX 10.5.8. Recently I
finally got around to building the latest GHC and, FWIW, everything
seems to have worked out fine. I did get a few failed tests in the
testsuite though, and I'm curious what they mean or if they're actually
cause
On 12/1/12 11:58 PM, Kim-Ee Yeoh wrote:
On Sun, Dec 2, 2012 at 10:52 AM, wren ng thornton w...@freegeek.org wrote:
My goal for all this is in setting up the type system, not performance.
I figure there are other folks who know and care a lot more about the
numerical tricks of giving the actual
On 11/29/12 2:17 PM, Ivan Salazar wrote:
The bad side is that direct translation of algorithms are almost always
very slow and the work needed to make them perform is very mind bending.
Indeed. The thing is, all algorithms make (implicit) assumptions about
the cost model of the underlying
On 11/30/12 4:58 PM, Mark Flamer wrote:
Thanks for all the replies,
It sounds like there is enough interest and even some potential
collaborators out there. I have created a few data structures to represent
sparse vectors and matrices. The vector was a simple binary tree and the
matrix a quad
On 11/20/12 6:54 AM, c...@lavabit.com wrote:
Hello,
I know nothing about compilers and interpreters. I checked several
books, but none of them explained why we have to translate a
high-level language into a small (core) language. Is it impossible
(very hard) to directly translate high-level
On 11/21/12 4:59 PM, Artyom Kazak wrote:
I saw a question on StackOverflow about the difference between isAlpha
and isLetter today. One of the answers stated that the two functions are
interchangeable, even though they are implemented differently.
I decided to find out whether the difference in
On 11/5/12 6:23 PM, Eric M. Pashman wrote:
I've been playing around with the idea of writing a genetic programming
implementation based on the ideas behind HList. Using type-level programming,
it's fairly straighforward to put together a program representation that's
strongly typed, that
On 10/26/12 2:41 PM, Greg Fitzgerald wrote:
Hi Haskellers,
I've recently found myself using the expression: foldr (.) id to compose
a list (or Foldable) of functions. It's especially useful when I need to
map a function over the list before composing. Does this function, or the
more general
On 10/27/12 3:23 PM, Greg Fitzgerald wrote:
Should library functions target Control.Category? We write for Num,
IsString, and ListLike. Haskell overloads number literals and string
literals, and awkwardly not List literals. Should Haskell overload
function application too?
How cool would it
On 10/5/12 7:11 AM, Johannes Waldmann wrote:
I was really surprised at the following:
*Main 1 + 2 * 3
7
*Main ( \ (+) (*) - 1 + 2 * 3 ) (+) (*)
9
because I was somehow assuming that either
a) the Prelude fixities of the operators are kept
After dealing with how Coq handles infix operators,
On 9/30/12 7:00 AM, Tillmann Rendel wrote:
Vasili I. Galchin wrote:
I would an examples of monads that are pure, i.e. no side-effects.
One view of programming in monadic style is: You call return and = all
the time. (Either you call it directly, or do notation calls it for
you). So if you
On 9/28/12 2:48 PM, Mario Blažević wrote:
On 12-09-26 08:07 PM, wren ng thornton wrote:
On 9/25/12 1:57 PM, Sjoerd Visscher wrote:
Maybe we could make a literal [a,b,c] turn into
unpack [a,b,c]#
where
[a,b,c]#
is a statically-allocated vector?
I'm kinda surprised this isn't already
On 9/24/12 8:53 AM, George Giorgidze wrote:
We will release GHC patches for both approaches, meanwhile the
feedback from the community on the approaches that we took would be
very much appreciated. Which one those would you prefer? or would you
suggest a different one.
The first one is much
On 9/25/12 1:57 PM, Sjoerd Visscher wrote:
Maybe we could make a literal [a,b,c] turn into
unpack [a,b,c]#
where
[a,b,c]#
is a statically-allocated vector?
I'm kinda surprised this isn't already being done. Just doing this seems
like it'd be a good undertaking, regardless of
On 9/18/12 8:32 AM, Jan Stolarek wrote:
Hi list,
I have yet another question about folds. Reading here and there I encountered
statements that
foldr is more important than foldl, e.g. in this post on the list:
http://www.haskell.org/pipermail/haskell-cafe/2012-May/101338.html
I want to know
On 9/18/12 4:27 AM, o...@okmij.org wrote:
There has been a recent discussion of ``Church encoding'' of lists and
the comparison with Scott encoding.
I'd like to point out that what is often called Church encoding is
actually Boehm-Berarducci encoding. That is, often seen
newtype ChurchList a
On 9/14/12 5:16 PM, Eric Velten de Melo wrote:
But now I'm kinda lost. Is there an easy way to explain the difference between:
-iteratee
-conduit
-enumerator
John Lato's iteratee library is the original one based on Oleg
Kiselyov's work. I've used it a fair deal and am quite fond of it.
On 9/12/12 5:37 PM, Francesco Mazzoli wrote:
At Wed, 12 Sep 2012 12:04:31 -0300,
Eric Velten de Melo wrote:
It would be really awesome, though, if it were possible to use a
parser written in Parsec with this, in the spirit of avoiding code
rewriting and enhancing expressivity and abstraction.
On 8/30/12 10:26 AM, Erik Hesselink wrote:
Note that this does not work if you want to support multiple versions
of GHC, and might not work in general, since
* The hiding of catch is needed for preludes that still have it, since
otherwise it will probably conflict with the one from
On 8/26/12 9:10 PM, Sebastien Zany wrote:
Thanks Wren. That was my guess too, but it seems not necessary:
http://stackoverflow.com/questions/12103309/when-is-a-composition-of-catamorphisms-a-catamorphism
Well, sure. I was meaning in the general case. If you have the right
kind of
On 8/27/12 6:27 PM, Tristan Seligmann wrote:
On Aug 27, 2012 8:40 PM, Erik Hesselink hessel...@gmail.com wrote:
The other question is how useful test suites in a released package
are. Aren't they much more useful (and used more often) in source
repositories?
Having tests available in a
On 8/24/12 3:44 AM, Sebastien Zany wrote:
More specifically (assuming I understood the statement correctly):
Suppose I have two base functors F1 and F2 and folds for each: fold1 :: (F1
a - a) - (μF1 - a) and fold2 :: (F2 a - a) - (μF2 - a).
Now suppose I have two algebras f :: F1 μF2 - μF2 and
On 8/22/12 9:18 AM, Leon Smith wrote:
I think we actually agree more than we disagree; I do think distinguishing
hard and soft upper bounds (no matter what they are called) would help,
and I'm just trying to justify them to some of the more dismissive
attitudes towards the idea
Hopefully.
On 8/22/12 12:35 PM, David Menendez wrote:
As I see it, there are four possibilities for a given version of dependency:
1. The version DOES work. The author (or some delegate) has compiled
the package against this version and the resulting code is considered
good.
2. The version SHOULD work. No
On 8/22/12 5:23 PM, Matthew Steele wrote:
So my next question is: why does unpacking the newtype via pattern matching
suddenly limit it to a single monomorphic type?
Some Haskell code:
foo :: (forall a. a - Int) - Bool
foo fn = ...
newtype IntFn a = IntFn (a - Int)
bar1 ::
On 8/23/12 1:02 PM, Patrick Browne wrote:
I am just not sure whether there is a model expansion from the super-class model
to the subclass model.
If by model expansion from... you mean that there is a
canonical/unique/special mapping from every superclass model to some
subclass model, then
On 8/17/12 12:54 AM, Alexander Solla wrote:
On Thu, Aug 16, 2012 at 8:07 PM, wren ng thornton w...@freegeek.org wrote:
Though bear in mind we're discussing second-order quantification here, not
first-order.
Can you expand on what you mean here? I don't see two kinds of
quantification
On 8/17/12 5:35 AM, TP wrote:
Hi,
I am currently reading documentation on Generalized Algebraic Data Types:
http://en.wikibooks.org/wiki/Haskell/GADT
I have a question concerning this page. Let us consider the following code
proposed in the page:
--
-- Phantom
On 8/17/12 11:28 AM, Leon Smith wrote:
And the
difference between reactionary and proactive approaches I think is a
potential justification for the hard and soft upper bounds; perhaps we
should instead call them reactionary and proactive upper bounds instead.
I disagree. A hard constraint
On 8/15/12 12:32 PM, David Feuer wrote:
On Aug 15, 2012 3:21 AM, wren ng thorntonw...@freegeek.org wrote:
It's even easier than that.
(forall a. P(a)) - Q = exists a. (P(a) - Q)
Where P and Q are metatheoretic/schematic variables. This is just the
usual thing about antecedents being in
On 8/15/12 2:55 PM, Albert Y. C. Lai wrote:
On 12-08-15 03:20 AM, wren ng thornton wrote:
(forall a. P(a)) - Q = exists a. (P(a) - Q)
For example:
A. (forall p. p drinks) - (everyone drinks)
B. exists p. ((p drinks) - (everyone drinks))
In a recent poll, 100% of respondents think A true, 90
On 8/15/12 11:02 PM, MightyByte wrote:
One tool-based way to help with this problem would
be to add a flag to Cabal/cabal-install that would cause it to ignore
upper bounds.
I'd much rather have a distinction between hard upper bounds (known to
fail with) vs soft upper bounds (tested with).
On 8/13/12 5:42 PM, Jay Sulzberger wrote:
One difficulty which must impede many who study this stuff is
that just getting off the ground seems to require a large number
of definitions of objects of logically different kinds. (By
logic I mean real logic, not any particular formalized system.)
We
On 8/13/12 9:25 PM, Jay Sulzberger wrote:
I did suspect that, in some sense, constraints in combination
with forall could give the quantifier exists.
It's even easier than that.
(forall a. P(a)) - Q = exists a. (P(a) - Q)
Where P and Q are metatheoretic/schematic variables. This is
On 8/8/12 9:41 PM, Jay Sulzberger wrote:
Haskell's type classes look to me to be a provision for declaring
a signature in the sense of the above article.
Just to clarify this in the context of my previous post, type classes
define signatures in two significantly different ways.
(1) The
On 8/8/12 3:36 PM, Patrick Browne wrote:
On 08/08/12, *Ertugrul Söylemez *e...@ertes.de wrote:
So you basically just mean
class (Functor f) = Applicative f
Yes, but I want to know if there is a simple mathematical relation between the
classes and/or their types
Let us introduce
On 7/30/12 9:51 PM, Christian Sternagel wrote:
Thanks Wren, for the explanations (also in your previous mail)!
On 07/30/2012 01:29 PM, wren ng thornton wrote:
On 7/24/12 9:19 PM, Christian Sternagel wrote:
(x == y) = True == x = y
(x == y) = False == not (x = y)
(x == _|_) = _|_
(_|_ == y
On 7/30/12 5:35 PM, Henk-Jan van Tuyl wrote:
- Block creation of usernames
o ending with two or more digits
o with more than one x or q
o starting with buy
o longer than 20 characters
o with more than 4 consonants in a row
As other's've mentioned, many of these constraints impose undue burden
On 7/24/12 9:19 PM, Christian Sternagel wrote:
Dear all,
Thanks for your replies. Just to clarify: I am fully aware that inside
Haskell there is no guarantee that certain (intended) requirements on
type class instances are satisfied. I was asking whether the intention
for Eq is that (==) is
On 7/24/12 9:19 PM, Christian Sternagel wrote:
(x == y) = True == x = y
(x == y) = False == not (x = y)
(x == _|_) = _|_
(_|_ == y) = _|_
Those axioms state that (==) is sound w.r.t. to meta-equality and strict
in both it's arguments.
An immediate problem that arises here is: what exactly
On 7/27/12 1:49 PM, Ross Paterson wrote:
So a language is referentially transparent if replacing a sub-term with
another with the same denotation doesn't change the overall meaning?
But then isn't any language RT with a sufficiently cunning denotational
semantics? Or even a dumb one that gives
On 6/27/12 2:57 PM, Alexander Foremny wrote:
Sweet! Thank you very much!
Just out of curiosity: how does this differ from the following, not
compiling type signature?
library :: forall t. NetworkDescription t (Behavior t String) - IO ()
The type:
(forall a. F a) - G
is isomorphic to:
-- unification-fd 0.8.0
The unification-fd package offers generic functions for single-sorted
first-order structural unification (think of programming in Prolog, or
of the metavariables in type
On 6/21/12 1:15 PM, Brandon Allbery wrote:
On Thu, Jun 21, 2012 at 5:11 AM, Rouan van Dalenrvda...@yahoo.co.ukwrote:
Can anyone shed some light on why the succ and pred functions of the Enum
typeclass throw
exceptions if we go over the upper or lower boundary, and not return Maybe
a?
Enum
On 6/24/12 5:41 AM, Anton Kholomiov wrote:
I think monad's methods are misleading, let's rename them
class Monad m where
idM :: a - m a
(*$) :: (a - m b) - m a - m b
We can see that `return` is a monadic identity and the `bind`
is an application in disguise. So now we have two
On 6/7/12 12:40 PM, Sean Leather wrote:
I was hoping somebody else had a bright idea, but no takers, yet.
I don't remember where I got my GMP.framework from, exactly. I thought it
used to be bundled with the HP. But it's apparently not anymore.
I did some digging and came across the old
Hello all,
I'm working on creating some distribution bundles of GHC 7.4.1 and HP
2012.2.0.0 for OSX 10.5 to help rectify the lack of support on older
Macs. In building GHC I've run into a linking error in stage1:
ld: duplicate symbol ___gmpz_abs in
libraries/integer-gmp/gmp/objs/add.o
1 - 100 of 1018 matches
Mail list logo
