* hackagebot cab 0.1.10 – A maintenance command of Haskell cabal packages http://hackage.haskell.org/package/cab-0.1.10 (KazuYamamoto) <ski> elliott_ : “it only makes sense for a monad to have one error type” — why ? <ski> “Without that, typeclass resolution would be problematic (requiring at the very least lots of manual type annotations everywhere).” — hmm, there is no class method signature not mentioning all the parameters, at<elliott_> ski: well, it only makes sense in terms of MonadError 
<elliott_> whether MonadError is good or not… that’s up to you * hackagebot dph-base 0.6.1.1 – Data Parallel Haskell common config and debugging functions. http://hackage.haskell.org/package/dph-base-0.6.1.1 (BenLippmeier) * hackagebot dph-prim-interface 0.6.1.1 – Data Parallel Haskell segmented arrays. (abstract interface) http://hackage.haskell.org/package/dph-prim-interface-0.6.1.1 (BenLippmeier) <ski> @src MonadError <lambdabot> class (Monad m) => MonadError e m | m -> e where <lambdabot> throwError :: e -> m a <lambdabot> catchError :: m a -> (e -> m a) -> m a <ski> elliott_ : i’m not sure what you mean by the former remark * hackagebot dph-prim-seq 0.6.1.1 – Data Parallel Haskell segmented arrays. (sequential implementation) http://hackage.haskell.org/package/dph-prim-seq-0.6.1.1 (BenLippmeier) <elliott_> ski: which one? * hackagebot dph-prim-par 0.6.1.1 – Data Parallel Haskell segmented arrays. (production version) http://hackage.haskell.org/package/dph-prim-par-0.6.1.1 (BenLippmeier) * hackagebot dph-lifted-base 0.6.1.1 – Data Parallel Haskell common definitions used by other dph-lifted packages. http://hackage.haskell.org/package/dph-lifted-base-0.6.1.1 (BenLippmeier) * hackagebot dph-lifted-vseg 0.6.1.1 – Data Parallel Haskell lifted array combinators. http://hackage.haskell.org/package/dph-lifted-vseg-0.6.1.1 (BenLippmeier) * hackagebot dph-lifted-copy 0.6.1.1 – Data Parallel Haskell lifted array combinators. (deprecated version) http://hackage.haskell.org/package/dph-lifted-copy-0.6.1.1 (BenLippmeier) <ski> the one about making sense <elliott_> ski: well, MonadError is the typeclass version of ErrorT <elliott_> which models a single error type <ski> elliott_ : well, how about `ErrorT e0 (WriterT w (ErrorT e1 m))’ ? * hackagebot dph-examples 0.6.1.1 – Data Parallel Haskell example programs. http://hackage.haskell.org/package/dph-examples-0.6.1.1 (BenLippmeier) * hackagebot dph-lifted-vseg 0.6.1.2 – Data Parallel Haskell lifted array combinators. http://hackage.haskell.org/package/dph-lifted-vseg-0.6.1.2 (BenLippmeier) <ski> @unmtl ErrorT e0 (WriterT w (ErrorT e1 m)) a <lambdabot> m (Either e1 (Either e0 a, w)) <Axman6> hmm, new jhc release. looks quite fun <Axman6> Want to create a varient of haskell that has 16 bit Ints, ASCII 8 bit Chars <Axman6> and pervasively uses null terminated C style strings? just create a base-tiny <Axman6> library and link it against jhc-prim. * hackagebot dph-examples 0.6.1.2 – Data Parallel Haskell example programs. http://hackage.haskell.org/package/dph-examples-0.6.1.2 (BenLippmeier) <Axman6> god damn <elliott_> Axman6: useful, that <Axman6> elliott_: the release email is much more informative. i just thought that was cool <elliott_> i was kidding <elliott_> as in… <elliott_> my sarcasm was itself kidding * hackagebot dph-examples 0.6.1.3 – Data Parallel Haskell example programs. http://hackage.haskell.org/package/dph-examples-0.6.1.3 (BenLippmeier) <zzo38> Is this the proper way to make the cabal package file? http://sprunge.us/haMR * hackagebot representable-functors 2.1.2 – Representable functors http://hackage.haskell.org/package/representable-functors-2.1.2 (EdwardKmett) <ivanm> zzo38: “cabal init” can generate the basis of one <ivanm> also, I would suggest *against* public domain <zzo38> ivanm: Why do you suggest against public domain? <ivanm> as depending on which country you’re in, you might not be legally allowed to release it under public domain <ivanm> ^^ just said 
<ivanm> I would suggest also providing a website URL if you have one <zzo38> OK. What if I set it to PublicDomain but add the LICENSE file with WTFPL license or something like that? <ivanm> and if you use darcs, git or hg give the repo <ivanm> zzo38: why not BSD3 or something? <ivanm> also, don’t list the TODO in the Description <zzo38> ivanm: There is no URL for this package (other than the Hackage), and it is a single file so there is no repository. <ivanm> shove the TODO as an extra file <ivanm> a README would also be a good idea <zzo38> O, sorry, I didn’t know don’t list TODO in the Description. <ivanm> zzo38: well, you can, but it gets annoying <ivanm> zzo38: you’d be better off with a better description of what hampp *is* and why you would want to use it <zzo38> But even if it is not in the description, I want to put in the .cabal file (possibly commented out) so that you can access it without downloading the entire package <ivanm> and have some example files included as documentation <ivanm> that would involve updating the .cabal file each time you change it <ivanm> this is why a repo is nice: people can look *there* for a README, TODO, etc. <zzo38> But I need to update the .cabal file each time I change it anyways (the minimum is to update the version number) <ivanm> yes <ivanm> but then you have syncing issues * hackagebot adjunctions 2.0.5 – Adjunctions http://hackage.haskell.org/package/adjunctions-2.0.5 (EdwardKmett) * hackagebot kan-extensions 2.1.2 – Kan extensions, the Yoneda lemma, and (co)density (co)monads http://hackage.haskell.org/package/kan-extensions-2.1.2 (EdwardKmett) <ivanm> zzo38: when I go to a hackage page, I want to see what the package is, and why I would want to use it <zzo38> O, yes; I really should fix that. <zzo38> But I don’t really know what to write. <zzo38> Although I do agree with you about that. <ivanm> excessive TODOs, Changelogs, etc. shoved into the description field just make it harder to get information <zzo38> OK, then I will comment out the TODOs so that they do not appear on the description webpage. <edwardk> the only package i’m anal retentive about keeping a changelog in my description field is ‘ad’ <edwardk> mostly because i got in the habit early on <ivanm> and that’s got too much of a wall of text feel to it <ivanm> the description should just be a brief overview of what the package is <ivanm> IMHO, of course <zzo38> I think you are correct; but unfortunately I don’t know what to write. <ivanm> use a README – especially one with some kind of markup, etc. – do a more in-depth description <ivanm> zzo38: what is it? <ivanm> and why would I want to bother downloading, installing and using it? <edwardk> zzo38: you can start doing what i do whenever ivanm asks me that question and just say ‘you wouldn’t’ <zzo38> It is Haskell macro preprocessor. You would download and use it in case you want to do preprocessor with your program. I am not really good at writing these kind of summary, but I can show you the codes in case<ivanm> edwardk: heh <zzo38> edwardk: Well, yes; not everyone is required to use it. Probably many people hate it. But in a few cases it can be useful. <ivanm> zzo38: what *kind* of macros? * hackagebot representable-tries 2.0.5 – Tries from representations of polynomial functors http://hackage.haskell.org/package/representable-tries-2.0.5 (EdwardKmett) * hackagebot monad-products 0.2.0.2 – Haskell 98 monad products http://hackage.haskell.org/package/monad-products-0.2.0.2 (EdwardKmett) <ivanm> how does it benefit someone? (shorter code? more concise? more readable?) <edwardk> and then when he asks why you can tell him because he should be writing some kind of graph library <ivanm> edwardk: stfu :p <koninkje> edwardk: ping! <ivanm> zzo38: don’t worry too much about it; it takes practice to write that kind of stuff <edwardk> heya <lambdabot> edwardk: You have 2 new messages. ‘/msg lambdabot @messages’ to read them. <edwardk> unification-fd? <zzo38> ivanm: There built-in macros and custom macros. Custom macros are just substitution, but built-in macros include calculation, auto-increment, and so on, and can be combined. But it also has reorderable named ch<koninkje> edwardk: yeah <ivanm> e.g. have a look at how the description of my graphviz package changed; it took a while before I figured “I should probably say this is for graph visualisation…” <ivanm> zzo38: so call it an extensible macro pre-processor or something <edwardk> fire away (either here or in msg) =) <zzo38> As well as being able to enter numbers such as 0b100110101 integer literals, and 0′A’ is also a valid integer literal for 65 <koninkje> so, I’d thought about doing that design before, but it has different type-system guarantees <edwardk> yes, but you break those guarantees in the case where you wind up using a GADT and lying about the argument to var <koninkje> In particular, whether variables are (transparently) transportable between different monads or term types <zzo38> So it actually has many features but there are also things missing. <ivanm> remember also to send announcement emails to haskell@ and haskell-cafe@ <koninkje> So I was curious about how the differences in semantics play out in your uses <koninkje> for the stuff I was doing it was good to maintain the invariant that variables can’t be transported, though I can see cases where it’d be good <zzo38> Probably it is difficult to know unless you look at the codes for this program (there is no proper documentation at this time) <koninkje> (of course you can always transport them via fmap) <zzo38> This is the program codes: http://sprunge.us/QBAU <edwardk> in yours or mine? <koninkje> in mine, since fmap is trivial <edwardk> i’m not sure i’m remembering enough of the issue to see where i’m giving you extra power to change variables <koninkje> yours doesn’t have the right kind for fmap, but it’s not indexed so transportation is free/invisible <edwardk> but the v is can depend on the monad <edwardk> er the v can <koninkje> Well, consider that I have two different universes/contexts/whatevs <zzo38> I have another, unrelated question, maybe edwardk knows (although maybe not). The question is making a monad transformer from any contravariant functor. <edwardk> sure, but then you make a monad with an ‘s’ parameter which infects the ‘v’ iirc the ST s version does that <koninkje> In my version, you have to be explicit about it if you want to take variables from one universe and move them over to the other <Axman6> @djinn ((a -> r) -> r) -> (a -> ((b -> r) -> r)) -> ((b -> r) -> r) <lambdabot> f a b c = a ( d -> b d c) <edwardk> zzo38: f a -> a ? <koninkje> whereas in your version, the variables are “free”; i.e., their interpretation is wholly defined by the monad, rather than the universe they’re in * ivanm -> dinner <zzo38> edwardk: For a monad (not a transformer), yes like that. A specific case of this has already been implemented in a package <edwardk> the only universes you gain the ability to move between are the map based ones <koninkje> how so? <edwardk> pulling up the package its been a few months <koninkje> If I have (Var 5). In my version that’s typed as belonging to a certain class of terms; whereas in yours it can be bound to any type of term (since the interpretation is wholly dependent on the monad) <edwardk> STVar s t — has the s from the monad baked in <edwardk> so you won’t be swapping it between monads, etc. <koninkje> sure. I was thinking of the IntVar though <edwardk> v is bound to a particular class of terms too, in my version the type infects the entire monad though <koninkje> right <edwardk> IntBindingT t m a = IT { … } <koninkje> implicitly it infects the monad in my version too <edwardk> yes. and for the other monads it also infects the term, so you’d really have to work to get it out and associated with a wrong flavor term <edwardk> er also infects the monad <koninkje> the main difference I see is just the semantics of whether variables are transportable or not; so I wasn’t sure if that was something that came up for you <zzo38> But can a monad transformer be made from a contravariant functor, rather than just a monad? * hackagebot http-conduit 1.2.5 – HTTP client package with conduit interface and HTTPS support. http://hackage.haskell.org/package/http-conduit-1.2.5 (MichaelSnoyman) <koninkje> edwardk: do you see what I mean about the semantics? <edwardk> i figured if you really wanted that non-transportability a region parameter could give it to you <koninkje> on the terms? <edwardk> and most of your monads already have one <edwardk> newtype IntVar s = IntVar Int <edwardk> IntBindingT s t m a = … <koninkje> that’s more of an artifact imo. If the variables have a type parameter, then the monad has to match with it <koninkje> whereas in yours, the variables don’t have the param; but the monads still must, since they provide the interpretation <koninkje> The bigger issue isn’t the monads though, it’s the terms themselves and a question of how closely we want them to be bound to their monad (vs not) <edwardk> this doesn’t cause me nearly the level of cognitive dissonance it seems to cause you <koninkje> there’s no dissonance, but there is a semantic difference; so I was curious whether it was the semantics that drove the patch, or just aesthetics <edwardk> to me it seems the notion of the variable type is at least selected by the monad and term type in all cases <edwardk> i’m almost always driven by pragmatics or aesthetics <augur> koninkje! <koninkje> proper semantics can be quite pragmatic <koninkje> augur! <augur> hows life dude <koninkje> not bad <koninkje> busy with grading, but good other than that <edwardk> yes, but the version without the silly extra variable has quite nice aesthetics <tgeeky> Terrible! I took an arrow to the knee! <augur> koninkje: whatchu grading <CodeWeaverX> Pfft, I can fix that, tgeeky. <koninkje> Q520— “all” the math and logic you need for cognitive science <tgeeky> CodeWeaverX: ACL and MCL? <augur> koninkje: oh boy <koninkje> it’s not bad, just takes a lot of time is all <tgeeky> koninkje: holy crap. <tgeeky> that’s a lot <koninkje> tgeeky: <tgeeky> isn’t that sort of.. unknown, too? <augur> koninkje: what does the logic part consist of? <CodeWeaverX> No, no. I took an arrow to the knee, and I thought my adventuring days were over. And then I got whisked away to here: http://pc.gamespy.com/pc/project-mercury/1217986p1.html <koninkje> well, it’s mainly intro to Bayesian probability theory, linear algebra (as used in machine learning etc), and a smattering of FOL <augur> aha <augur> so not really logic <augur> figures! <koninkje> augur: the logic is mostly filler at the end of term, for folks who haven’t seen FOL (or haven’t in a while) <tgeeky> augur: there’s nothing logical about the brain! <augur> tgeeky: brains beg to differ! <tgeeky> augur: and yet both can be true :O <CodeWeaverX> My brain doesn’t. Of course my brain’s been on beer for a while. <koninkje> augur: FWIW, logic (proper) is what Larry Moss does. But that’s also part of why he doesn’t delve into it in this course <augur> speaking of logic, im in a modal logic class <augur> its quite interesting <koninkje> ooh, just the basic stuff or more advanced things? <augur> dunno what qualifies as basic and what qualifies as advanced but <tgeeky> koninkje: if this is not relevant, or you don’t know, or you aren’t a “cognitive scientist” or whatever — isn’t the issue of the brain requiring/using/not using or requiring quantum effects still an open ques<koninkje> i.e., box and diamond, in different varations; or the various temporal logic stuff <augur> koninkje: well, we’re doing just box and diamond right now, but we’re talking about all sorts of interesting interpretations of things <augur> i mean, right now we’re just on the relational interpretation, but we’re touching on things like distinguishability, definability, etc. <koninkje> tgeeky: I’m doing a cognitive science / computational linguistics dual PhD; my MSE was computer science, and I seem to be incapable of stopping doing research on programming langages <CodeWeaverX> That. is very cool koninkje. <tgeeky> that seems to be a statement that you are qualified to answer :O <CodeWeaverX> Also serendipitous. My girlfriend is doing an undergrad very similar to that. <CodeWeaverX> I’m amused. The world is small. <koninkje> tgeeky: there’s still folks arguing both sides of that; though I think most cognitive scientists stay out of it, it’s more of a philosophical debate <koninkje> augur: /me nods <tgeeky> koninkje: yeah, I figured that would be the response. That’s fine. One day, it may become a physical (or neurobiological) one. <augur> koninkje: http://ai.stanford.edu/~epacuit/classes/modal.html class site <koninkje> augur: the temporal stuff is similar but moreso. I.e., we can think of box and dia as universal and existential quantification but on a different axis from exists/forall; temporal logics typically add a thir<augur> ya <zzo38> O, that is how temporal logics work. I did not know a lot about that. <koninkje> of course, after that you start to get into fun things like modal variants of the mu/nu fixedpoint operators <koninkje> ooh, you’re doing dynamic epistemic logic, nice <augur> well not yet we aint :p <koninkje> they had a course on that at the previous NASSLLI. The dynamics makes it much more interesting <koninkje> Have you gotten to any of the fun paradoxes that inspire modal logicians? <koninkje> Well, I should head off to bed; early day tomorrow <tgeeky> koninkje and by inspire; you mean, crush their little souls? <koninkje> yes, yes indeed <augur> koninkje_away: no not yet <augur> also night koninkje_away <zhuwenxuan> what <zhuwenxuan> hi <CodeWeaverX> hello <augur> zhuwenxuan: a girl in my modal logic class is named xuan! <zhuwenxuan> where is there <augur> umd <zzo38> I found dependent sums package for Haskell. Using that together with type families and reflected types could make something similar to an open case construct. <quintessence> :t 100undefined <lambdabot> forall t a. (Num (a -> t)) => t <zzo38> quintessence: What do you want that for? <quintessence> I was surprised it parsed, that’s all <zzo38> quintessence: It does parse now you can remember that for making code-golf. <Veinor> … that’s kind of scary <zzo38> What one is kind of scary? <Veinor> :t 100undefined <lambdabot> forall t a. (Num (a -> t)) => t <zzo38> Why is it kind of scary? <Veinor> It seems like the sort of thing that’d be a parse error. <ion> Should 1+2 be a parse error? <zzo38> ion: I think not. <quintessence> :t let r = undefined in 0xf00bar <lambdabot> forall t a. (Num (a -> t)) => t <mauke> > let rd = rd in 0xf0rd <lambdabot> 240 <quintessence> The mind of lambdabot is a strange, strange environment. <zzo38> It seems reasonable to me. <quintessence> The parsing is sane if surpring, but for that to evaluate lambdabot must have something like an instance Num (a -> Integer) where fromInteger = const, which is… less sane <nyingen> @quote <lambdabot> U says: Ow My Damned Brain <Jafet> > 1 2 3 4 5 <lambdabot> 1 * hackagebot hxournal 0.6.4.2 – A pen notetaking program written in haskell http://hackage.haskell.org/package/hxournal-0.6.4.2 (IanWooKim) <PreciousMetals> hello I just wrote a parser that uses Parsec, I don’t really have a lot of experience with it so if someone could give me some tips on how to improve this then that would be appreciated :3~ <PreciousMetals> http://hpaste.org/57616 <PreciousMetals> (it parses irssi log files) <frerich> PreciousMetal: I don’t have much experience with Parsec, but I think there’s a lot repetition there. For instance, the ‘time’ <frerich> PreciousMetal: Also, the ‘between (symbol1 “[") (symbol1 "]“)’ expression appears quite often, so that might be a good candidate for an ‘inBrackets’ function or so <frerich> PreciousMetal: I *thought* there was an ‘untilEol’ parser or so, which basically does ‘many (noneOf “n”)’ but I cannot find it anymore. However, since you use that construct in quite a few places, it might b<PreciousMetals> cool :3 <PreciousMetals> thank you a bunch~! <frerich> PreciousMetals: You’re welcome – again, I don’t haev much experience with Parsec. These are all just generic refactorings to reduce code duplication. <zomg> Someone is trying to turn JavaScript into Haskell! <zomg> http://typedjs.com/ <zomg> Okay, it does seem like a reasonably good idea to give types like that =) <tikhonjelvis> Eh, have you seen Roy: http://roy.brianmckenna.org/? <quintessence> frerich: You may want to try out the Applicative style: Constructor fooParser barParser instead of do { a <ion> preciousmetals: Applicative functors also tend to be very useful with parsers. E.g. “do foo; a bar <zomg> tikhonjelvis: that looks kinda icky tbh 
<PreciousMetals> ion :O thanks! <tikhonjelvis> zomg: I haven’t actually used it. But it is really trying to turn JavaScript into Haskell. <zomg> Yeah <frerich> quintessence, ion: Interesting! I don’t have much experience with Applicative yet (but I liked it so far!). In particular, I don’t think I’ve used the ‘ <quintessence> do the effects of both their arguments (left then right), but they only give back the value from the one they point to <quintessence> useful for sub-parsers that just have to match but that don’t return anything interesting <frerich> quintessence : Ah, so do something similiar, but they are bothq uite different from if I understand correctly? * frerich thought they are something simliar to <*> <ion> fa a) fa fb <ion> fa *> fb = (a b -> b) fa fb <ion> fa fb ≡ (a b -> a b) fa fb <frerich> So instead of ‘f foo bar’ I could also say ‘f foo bar’? <frerich> Oh, wait, no – I think it parses differently. <frerich> ‘foo bar’ would actually yield just what ‘bar’ gives, right? <quintessence> or liftA2 const, liftA2 (flip const), and liftA2 ($), if you prefer pointfree <quintessence> frerich: I’m not actually sure about the precedence / associativity, but I think so <ion> ((a c) is different from (a c)). <ion> > Just ‘a’ Just ‘c’ <lambdabot> Just ‘c’ * frerich nods <ion> > Just ‘a’ Just ‘c’) <lambdabot> Just ‘a’ <ion> quintessence: or liftA2 id to emphasize the id-ness. * hackagebot hamlet 0.10.8 – Haml-like template files that are compile-time checked http://hackage.haskell.org/package/hamlet-0.10.8 (MichaelSnoyman) * hackagebot persistent 0.8.0 – Type-safe, multi-backend data serialization. http://hackage.haskell.org/package/persistent-0.8.0 (MichaelSnoyman) * hackagebot persistent-mongoDB 0.8.0 – Backend for the persistent library using mongoDB. http://hackage.haskell.org/package/persistent-mongoDB-0.8.0 (MichaelSnoyman) * hackagebot persistent-mysql 0.8.0 – Backend for the persistent library using MySQL database server. http://hackage.haskell.org/package/persistent-mysql-0.8.0 (MichaelSnoyman) <tgeeky> ohhhh boyy * hackagebot persistent-postgresql 0.8.0 – Backend for the persistent library using postgresql. http://hackage.haskell.org/package/persistent-postgresql-0.8.0 (MichaelSnoyman) * hackagebot persistent-sqlite 0.8.0 – Backend for the persistent library using sqlite3. http://hackage.haskell.org/package/persistent-sqlite-0.8.0 (MichaelSnoyman) * hackagebot persistent-template 0.8.0 – Type-safe, non-relational, multi-backend persistence. http://hackage.haskell.org/package/persistent-template-0.8.0 (MichaelSnoyman) * hackagebot shakespeare 0.10.3 – A toolkit for making compile-time interpolated templates http://hackage.haskell.org/package/shakespeare-0.10.3 (MichaelSnoyman)
Feb 142012