Brandon,
On May 8, 2007, at 12:33 AM, Brandon Michael Moore wrote:
braces x = group (PP. braces (nest 4 (linebreak x) linesbreak)
I ended up with the following:
nest = PP.nest 4
braces x = nest (lbrace $ x) $ rbrace
If you happen to be formatting C I've also worked out how to get
nice
Would someone kindly explain why we need co-arbitrary in QuickCheck
and how to define it?
Detailed examples would be awesome!
I would be willing to paste an in-depth explanation on my wall and
keep it forever.
Thanks in advance, Joel
--
http://wagerlabs.com/
joelr1:
Would someone kindly explain why we need co-arbitrary in QuickCheck
and how to define it?
Generating random function generators.
A nice explanation was given recently on the programming subreddit:
The CoArbitrary class continues to confuse me
Joel Reymont [EMAIL PROTECTED] writes:
Would someone kindly explain why we need co-arbitrary in QuickCheck
and how to define it?
Ever written a higher-order function and wanted to quickcheck it?
So where do you get your random functional arguments from?
Whereas the 'arbitrary' method allows
Hello Ketil,
the whole monadic business was introduced with the sole goal to let
haskellers believe that they are smarter than other programmers :)
Or perhaps to ensure that they are?
you mean Darwin's idea of natural selection? :)
--
Best regards,
Bulat
I'm looking for suggestions on how to create invariants for the
following AST transformation code. Any suggestions are appreciated!
I asked this question before and Lennart suggested abstract
interpretation as a solution. This would require interpreters for
both ASTs to determine that the
On May 8, 2007, at 9:33 , Joel Reymont wrote:
Would someone kindly explain why we need co-arbitrary in QuickCheck
and how to define it?
Detailed examples would be awesome!
I would be willing to paste an in-depth explanation on my wall and
keep it forever.
Thanks in advance, Joel
On May 8, 2007, at 1:04 , Justin Bailey wrote:
Looking at the libraries documentation, it seems like parsing a
string into a time and date should be as simple as:
import Data.Time.Format (parseTime)
myDate = parseTime ...
where ... is some string. But these functions don't seem to
Dear Haskellers,
as a Haskell newbie I really enjoyed Austin Seipp's article on writing a
packet sniffer in Haskell using the libpcap.
I played around with Network.Pcap and tried to dump packets into a pcap
file using the dump function:
dump :: Ptr PcapDumpTag - Ptr PktHdr - Ptr Word8 - IO ()
Duncan Coutts wrote:
On Thu, 2007-05-03 at 16:49 +0200, Thomas Schilling wrote:
By dependencies I
meant, library packages that GHC knows about.
For example, if I load something simple like
import System.Posix.Files
main = touchFile example
into GHCi and execute :main it prints
Loading
Hi,
well, I work with a Haskell project which I regulary compile with ghc.
I am a bit unhappy with the link time of the project (i.e. the time ghc
needs to link everyting).
The project consinst of ~60 Haskell and ~25 foreign files.
Some parts of the project are organized like a 'cluster', i.e.
On Tue, May 08, 2007 at 10:06:32AM +0100, Joel Reymont wrote:
I'm looking for suggestions on how to create invariants for the
following AST transformation code. Any suggestions are appreciated!
I asked this question before and Lennart suggested abstract
interpretation as a solution. This
On Tue, May 08, 2007 at 07:39:15AM +0100, Joel Reymont wrote:
If you happen to be formatting C I've also worked out how to get
nice argument
lists out of both pretty printers.
I'm formatting C# but I'll certainly take your arg list tips.
These narrow like
foo (a, b)
foo (a,
b)
foo
Back on December 14, Conrad Parker write:
On 15/12/06, Nicolas Frisby [EMAIL PROTECTED] wrote:
2) The welcome to the mailing list message could say if you're
new to Haskell, please check this FAQ first. I'm talking big letters
here; I'd even be OK with marquee.
.. hence I'd caution
On 08/05/07, Matthew Sackman [EMAIL PROTECTED] wrote:
:t let f r s = (return negate) = (\(fn::forall n . (Num n) = n - n) -
return (fn r, fn s)) in f
interactive:1:35:
Couldn't match expected type `a - a'
against inferred type `forall n. (Num n) = n - n'
In the pattern: fn
Dear all,
= Introduction =
In [1] Siskind and Pearlmutter expose the danger of perturbation
confusion in forward-mode automatic differentiation. In particular
they state:
We discuss a potential problem with forward-mode AD common to
many AD systems, including all attempts to
Oops, that went to soon.
My intention was to ask for comments from those who know better than
I. These corners of the type system are pretty unknown to me but I am
trying to learn from e.g. Oleg's array branding[1].
Anyway, please rip my exposition apart and expose my sure-to-be flawed
logic
On Tue, May 08, 2007 at 06:06:56PM -0400, Björn Buckwalter wrote:
We provide a type signature for 'd' where we existentially quantify
the phantom type 's' to prevent mixing of bundles from different
'd' operators.
d :: Num a = (forall s. Bundle s a - Bundle s a) - a - a
d f x = let (Bundle
On Tue, May 08, 2007 at 05:59:48PM -0700, David Roundy wrote:
Couldn't you do the same without branding if you simply made your function
polymorphic:
data Bundle a = Bundle a a
d :: Num a = (forall b. Num b = b - b) - a - a
d f x = let (Bundle y y') = f (Bundle x 1) in y'
and defined
Okay, here's an alternate, unbranded approach:
data Bundle a = Bundle a a
instance Num a = Show (Bundle a) where
showsPrec p (Bundle x x') = showsPrec p [x,x']
instance Num a = Eq (Bundle a) where
(Bundle x x') == (Bundle y y') = (x == y)
instance Num a = Num (Bundle a) where
On Fri, May 04, 2007 at 07:20:03PM -0700, Conal Elliott wrote:
[switching to haskell-cafe]
thanks for the explanation, John. doesn't the list cases mentioned in the
definition of (+) below assume whole program, in order to know all Num
instances?
Yes it does in the current implementation,
21 matches
Mail list logo
