mikeplus48's comments

mikeplus48 · on Dec 16, 2012

Start with the spelling. :)

  data GADT a where
       Constructor0 :: Field a -> Field b -> GADT (a, b)
       Constructor1 :: ...
       ...

mikeplus48 · on Dec 15, 2012

There's luakit, uzbl, surf and jumanji from the top of my head, but I don't think any of these have "full interoperability with the CLI". luakit is definitely my favourite as it has been much more reliable than uzbl and easier to configure/extend (in lua).

richo · on Dec 15, 2012

Pentadactyl and Vimium if you want a "real browser" underneath too.

mikeplus48 · on Aug 15, 2012

No, ghc produces statically linked binaries by default (-dynamic if you don't like that).

tomku · on Aug 15, 2012

A quick check of the git-annex package in Ubuntu shows that you're right, no runtime Haskell dependency. I can only assume that the same will be true for the user-friendly "assistant". Thanks!

egonschiele · on Aug 16, 2012

This is true, but then those static binaries tend to be very big (50+ mb).

dons · on Aug 16, 2012

50M!? 5 would be more likely, assuming stripping. As opposed to 5k with dyn libs.

joeyh · on Aug 16, 2012

I'm up to 15 mb :/

mikeplus48 · on July 2, 2012

I don't understand this point. If you have arguments x and y that you want to apply to this function, I don't see the problem in "using them directly".

Function application in Haskell is first class. If you have

    f :: x -> y -> z
    f x y = undefined

then use it like

    (f 0)

you have a new function:

    f 0 :: y -> z

then if you apply again,

    (f 0) 1

and this final expression, equivalent to f 0 1, gives you something of type 'z'

mortoray · on July 2, 2012

The signature says how you can curry the function, but what I'm saying is that the body of the function is written essentially oblivious to that currying. For example, the body of the function would be written the same if the signature were "x->y->z" or "y->x->z".

If we consider (f 0) this provides an auto-currying of the function. However, this "f" is quite different from a function that has the signature "x->(y->z)" where the body would indeed need to be different (where the currying is explicit).

mikeplus48 · on July 2, 2012

You don't have to syntactically consume all of arguments of a function to write its body.

    f :: a -> Int -> Int -> Int
    f x = (+)

There really isn't anything meaningful to do with a function before it has consumed all it's arguments other than returning another function.

> However, this "f" is quite different from a function that has the signature "x->(y->z)"

Yes, we have applied the argument of type 'x'. f 0 is no longer of type "x -> y -> z", or "x -> (y -> z)" (because of -> precedence, the two are equivalent), it is "y -> z".

Currying is explicit.

    f x y = foobar

is just short hand for

    f = \x -> \y -> foobar

mikeplus48 · on May 27, 2012

This gives me an idea for a scanf-like QuasiQuoter...

mikeplus48 · on May 24, 2012

I'm the author of this post, it was a joke. I said "For those who have no idea what they're doing 90% of the time when they are in bash" very sarcastically, but obviously this wasn't conveyed very well, sorry.

edit: I know the defense "it was a joke" is very overplayed, but really, somewhere in between the graphs with rainbows and explosions, this post was intended to be humourous. :)