00:00:00 --- log: started haskell/07.03.30
00:00:14 --- join: Thunder (n=Thunder@rhiannon-e0.net.iks-jena.de) joined #haskell
00:01:43 --- join: therp (n=nil@chello080108077214.34.11.tuwien.teleweb.at) joined #haskell
00:04:07 --- part: fuzan left #haskell
00:06:41 --- join: phb2 (n=phb2@c213-100-46-125.swipnet.se) joined #haskell
00:08:32 --- quit: fantasma ("Leaving")
00:11:14 --- quit: gour (Read error: 104 (Connection reset by peer))
00:11:28 --- join: gour_ (n=Gour@34-64.dsl.iskon.hr) joined #haskell
00:12:51 --- nick: gour_ -> gour
00:24:13 --- join: jtoy (n=jtoy@c-24-60-178-47.hsd1.ma.comcast.net) joined #haskell
00:26:36 --- join: Ademan (n=dan@h-67-101-145-200.snfccasy.dynamic.covad.net) joined #haskell
00:27:53 <dons> ?uptime
00:27:53 <lambdabot> uptime: 6d 13h 30m 4s, longest uptime: 6d 13h 30m 4s
00:27:55 <dons> ?users
00:27:55 <lambdabot> Maximum users seen in #haskell: 337, currently: 289 (85.8%), active: 28 (9.7%)
00:31:30 --- quit: ramkrsna ("Leaving")
00:31:41 --- quit: AtnNn_ ("foobar")
00:34:26 --- quit: mjk ("KVIrc 3.2.6 Anomalies http://www.kvirc.net/")
00:34:28 --- quit: triplah_ (Read error: 110 (Connection timed out))
00:34:57 --- join: LoganCapaldo (n=logan@ool-457a8e39.dyn.optonline.net) joined #haskell
00:35:44 --- quit: Jaak ("Leaving")
00:39:52 --- join: x0FDA5E (n=mpi@88.119.37.217) joined #haskell
00:40:38 --- part: x0FDA5E left #haskell
00:41:04 --- join: bringert (n=bringert@dynamic-46-62.chl.chalmers.se) joined #haskell
00:41:10 --- quit: jtoy (Connection timed out)
00:41:23 --- join: jgrimes_ (n=sinfinit@Lee-15-155.rh.ncsu.edu) joined #haskell
00:43:56 --- quit: xinming (Read error: 104 (Connection reset by peer))
00:44:16 --- quit: nominolo ("bye")
00:47:45 --- quit: nornagon_ ("IRC is like a revolving door!")
00:47:49 --- quit: Pseudonym ("using sirc version 2.211+ssfe")
00:48:38 <tsp> > time
00:48:39 <lambdabot>   Not in scope: `time'
00:48:46 <tsp> lol, there's no way to get the current time in haskell?
00:48:49 <tsp> > now
00:48:50 <lambdabot>   Not in scope: `now'
00:48:50 --- join: xinming (n=xinming@222.212.0.14) joined #haskell
00:48:59 <tsp> ah, probably a module
00:49:18 <kfish> ?hoogle time
00:49:19 <lambdabot> System.Time :: module
00:49:19 <lambdabot> Time :: module
00:49:19 <lambdabot> System.Locale.time12Fmt :: TimeLocale -> String
00:49:59 <kfish> ?docs System.Time
00:49:59 <lambdabot> http://haskell.org/ghc/docs/latest/html/libraries/base/System-Time.html
00:55:04 --- join: Jaak (n=Jaak@193.40.10.181) joined #haskell
00:56:50 --- quit: jgrimes (Read error: 110 (Connection timed out))
01:06:27 --- quit: Ademan ("Leaving")
01:06:35 --- join: pstickne (n=pstickne@c-71-236-176-94.hsd1.or.comcast.net) joined #haskell
01:09:34 <dons> ?uptime
01:09:35 <lambdabot> uptime: 6d 14h 11m 45s, longest uptime: 6d 14h 11m 45s
01:09:55 <dons> so clearly its possible to find out the current time using the haskell language...
01:12:48 --- quit: prb_ ()
01:13:39 <dolio> Even if the way to get the current time were named 'time', lambdabot wouldn't let you use it, because it'd have to live in the icky IO monad.
01:13:44 <earthy> do { t <- getCurrentTime; show t }
01:14:06 <earthy> oh, and that's Data.Time
01:14:11 <earthy> which is *much* nicer than System.Time
01:14:14 <abz> >  toCalendarTime =<< getClockTime
01:14:15 <lambdabot>   Not in scope: `getClockTime'
01:20:10 <siti> what's that lib that's a unicode wrapper around bytestrings called?
01:20:15 <siti> the*
01:20:54 <mux> Data.CompactString I think
01:23:43 <siti> thanks
01:24:16 --- quit: pstickne (Read error: 110 (Connection timed out))
01:24:27 --- join: pstickne_ (n=pstickne@c-71-236-176-94.hsd1.or.comcast.net) joined #haskell
01:27:44 --- join: ikegami-- (n=ikegami@29.41.138.210.xn.2iij.net) joined #haskell
01:35:11 --- quit: shawn_ ("This computer has gone to sleep")
01:35:46 --- join: Dybber (n=Dybber@192.38.109.188) joined #haskell
01:35:53 --- join: beelsebob (n=tatd2@194-247-233-62.dynamic.dsl.as9105.com) joined #haskell
01:35:56 --- quit: kombinator (Read error: 113 (No route to host))
01:39:54 --- join: chris2 (n=chris@p549d2da3.dip0.t-ipconnect.de) joined #haskell
01:43:24 --- join: mr_tenor (n=nick@c220-239-37-8.rivrw7.nsw.optusnet.com.au) joined #haskell
01:43:47 --- join: boegel (n=boegel@86-39-27-222.customer.fulladsl.be) joined #haskell
01:43:49 <hpaste>  gour pasted "test" at http://hpaste.org/1192
01:44:03 <gour> hmm
01:44:21 <gour> glguy: how to direct hpaste to #haskell.hr ?
01:44:26 --- join: kombinator (n=michal@wifi160.wlan.ens-lyon.fr) joined #haskell
01:45:32 <gour> (if it's invoked from there)
01:47:18 <gour> @seen glguy
01:47:19 <lambdabot> glguy is in #haskell. I last heard glguy speak 3h 28m 41s ago.
01:48:02 <Vq^> gour: what about making the announcement yourself instead of using the announce function in the bot?
01:48:33 <gour> Vq^: ?
01:50:17 --- quit: boegel ("Leaving")
01:50:17 --- quit: diffbavis (Read error: 104 (Connection reset by peer))
01:50:41 <Vq^> maybe i misunderstood your question
01:51:08 <gour> Vq^: i pasted from #haskell.hr, but bot reported paste here
01:51:25 <Vq^> how do you paste from a channel?
01:53:05 <gour> Vq^: well, previously there was separate paste for #haskell.hr, now @paste in #haskell.hr gives http://hpaste.org/new which is disturbing for #haskell users, so question is how to get separate paste for #haskell.hr & similar channels
01:54:08 --- join: nominolo (n=nominolo@dhcp-246-14.nomad.chalmers.se) joined #haskell
01:55:17 <Vq^> ok, then i understand
01:55:23 <Vq^> hej nominolo
01:57:02 --- quit: beelsebob (Client Quit)
01:58:43 --- join: shawn (n=shawn@adsl-70-231-255-214.dsl.snfc21.sbcglobal.net) joined #haskell
01:58:45 --- quit: scw (Read error: 110 (Connection timed out))
02:00:37 <nominolo> hi Vq^
02:07:48 --- join: malcolmw (n=malcolm@venice.cs.york.ac.uk) joined #haskell
02:12:14 --- nick: [vincenz] -> vincenz
02:12:24 --- join: the_dormant (n=on@freeway.rd.francetelecom.com) joined #haskell
02:15:32 --- quit: Forn (Remote closed the connection)
02:16:37 --- quit: shawn (Read error: 110 (Connection timed out))
02:17:07 --- quit: brooks (Read error: 110 (Connection timed out))
02:25:40 --- join: mrchebas (n=alexey@53532F4D.cable.casema.nl) joined #haskell
02:31:20 --- join: triplah_ (n=tripped@121.45.226.201) joined #haskell
02:31:31 <ndm> @seen augustss
02:31:31 <lambdabot> augustss is in #haskell. I don't know when augustss last spoke.
02:31:34 <ndm> @seen augustss_
02:31:34 <lambdabot> I saw augustss_ leaving #haskell 14h 13m 30s ago, and .
02:31:56 <ndm> @seen ddarius
02:31:56 <lambdabot> I saw ddarius leaving #haskell, #haskell-overflow and #haskell-blah 2h 46m 27s ago, and .
02:31:57 --- join: brooks (n=chatzill@218.1.118.69) joined #haskell
02:32:18 <ndm> @tell ddarius wasn't around last night, but am now if you have any questions - or feel free to email them in
02:32:18 <lambdabot> Consider it noted.
02:32:22 --- quit: MarcWebe1 ("leaving")
02:32:48 <ndm> @tell sorear either is fine by me, probably avoiding conflicts is a priority, given a low number of users
02:32:48 <lambdabot> Consider it noted.
02:33:37 <ndm> @where logs
02:33:37 <lambdabot> http://tunes.org/~nef/logs/haskell/ http://meme.b9.com/cdates.html?channel=haskell
02:34:47 --- join: guenni (n=guenni@HSI-KBW-091-089-067-034.hsi2.kabelbw.de) joined #haskell
02:41:26 <tsp> @where isPrefixOf
02:41:27 <lambdabot> I know nothing about isprefixof.
02:41:35 <quicksilver> it's in Data.List
02:41:41 <tsp> thanks
02:41:43 <quicksilver> @hoogle isPrefixOf
02:41:44 <lambdabot> List.isPrefixOf :: Eq a => [a] -> [a] -> Bool
02:42:01 <quicksilver> '@where' is for websites, not functions, really
02:42:09 <quicksilver> @index isPrefixOf
02:42:10 <lambdabot> Data.List
02:42:57 --- quit: kombinator (Read error: 113 (No route to host))
02:44:30 --- join: diffbavis (i=dv@193.77.153.149) joined #haskell
02:45:52 --- join: wilx|wrk (n=Miranda@gw.eccam.com) joined #haskell
02:48:14 --- quit: bringert ()
02:48:49 --- join: kombinator (n=michal@grue.residence.ens-lyon.fr) joined #haskell
02:52:59 <hpaste>  tsp pasted "replaceString problem" at http://hpaste.org/1193
02:53:15 <tsp> I tried to rewrite that, but I know I"m missing something
02:53:30 <tsp> I worked through the logic, but it still gives an exception at the end
02:55:20 <quicksilver> tsp: you don't want that 'do'
02:55:31 <quicksilver> tsp: do is for monads, this code is not monadic :)
02:55:34 --- join: LPhas (n=Phas@81-208-106-68.ip.fastwebnet.it) joined #haskell
02:56:13 --- quit: savor (Remote closed the connection)
02:56:15 <tsp> does that matter? it'll just run them in sequence
02:56:59 <quicksilver> tsp: yes, it does matter
02:57:10 <quicksilver> tsp: 'just run them in sequence' doesn't really mean anything
02:57:24 <quicksilver> tsp: do returns something in some monad; it works out which monad by type inference
02:57:51 <quicksilver> you don't want to use any monad here
02:57:54 <tsp> what can I replace the do with? I tried {, didn't work. I tried nothing, didn't work
02:59:16 <quicksilver> Oh, interesting
02:59:26 <quicksilver> actually the 'do' isn't your problem, although it's not needed
02:59:35 <quicksilver> the problem is you called it replaceINString once
02:59:36 <tsp> taking it out wouldn't even let it compile
02:59:37 --- join: dfeuer (n=topolog@wikimedia/Dfeuer) joined #haskell
02:59:40 <quicksilver> and replaceString the other time
02:59:45 <tsp> oh
02:59:52 <tsp> and the compiler didn't warn me about this
03:00:16 <tsp> ah, that's why
03:00:22 <tsp> the empty list base case
03:00:25 * quicksilver nods
03:00:34 <tsp> how can I get it to compile without the do {} in there?
03:00:49 * mux lifts self into the morning monad
03:01:27 <quicksilver> tsp: trying to work that out for you. I'm not totally familiar with non-layout code :)
03:01:55 <tsp> quicksilver: what will happen when I start writing larger projects? noone will be able to read my code
03:02:07 <tsp> I had that problem with perl :)
03:02:32 <mux> heh
03:02:53 <tsp> I like the fact that I can write a replace in string function by calling it from itself
03:03:07 <tsp> I imagine it'll be slow as crap though
03:03:35 <tsp> @src words
03:03:35 <lambdabot> words s = case dropWhile isSpace s of
03:03:36 <lambdabot>     "" -> []
03:03:36 <lambdabot>     s' -> w : words s'' where (w, s'') = break isSpace s'
03:04:07 --- quit: brooks (Read error: 110 (Connection timed out))
03:04:24 <tsp> dropWhile isSpace s?
03:04:31 <Cale> tsp: there are some things you could do to speed it up -- computing the length of the thing being replaced over and over is a bit of a waste
03:04:34 <tsp> does that trim spaces from the beginning of the string?
03:04:53 <tsp> Cale: but I'd need to keep passing the length around
03:04:53 <Cale> tsp: yeah
03:04:56 --- join: der_igel (n=der_igel@brsg-4db2d38b.pool.einsundeins.de) joined #haskell
03:05:11 <Cale> tsp: indeed you would, though you could do that in an internally defined function
03:05:13 <Cale> er
03:05:15 <Cale> actually, no
03:05:25 <tsp> it'd still need to be passed around :)
03:05:29 <tsp> and recomputed
03:05:33 <Cale> You'd define a function internally which used it as a constant bound by the outer function
03:05:45 <tsp> you can define functions inside functions?
03:05:50 <Cale> absolutely
03:05:51 <tsp> neat
03:05:53 <Cale> with where and let
03:05:56 <quicksilver> tsp: the only way I can get it parse without layout is to add a module Main where {} around the whole thing
03:06:00 <Cale> You can make local definitions
03:06:08 <tsp> quicksilver: heh
03:06:11 <quicksilver> Cale: have you ever tried turning off layout for the toplevel?
03:06:26 <quicksilver> Cale: I can't seem to do with without an explicit 'module'
03:06:46 <Cale> quicksilver: Yeah, you probably need that.
03:07:29 <tsp> is layout itself written in haskell?
03:07:55 <hpaste>  quicksilver annotated "replaceString problem" with "remove the 'do'" at http://hpaste.org/1193#a1
03:08:10 <quicksilver> tsp: there is my version with no 'do'
03:08:56 <quicksilver> Cale: the report appears to be incorrect. the report has the grammar reductions : module -> body and body -> { impdecls; topdecls; }
03:08:58 <tsp> got it
03:08:59 <tsp> neat
03:09:07 <tsp> I think I'm slowly starting to figure this out :)
03:09:16 <quicksilver> Cale: but that isn't accepted by ghci with explicit {}s
03:09:57 --- join: edwardk (n=edwardk@pdpc/supporter/base/edwardk) joined #haskell
03:10:07 <quicksilver> tsp: the reason your do code worked, is that lists are a monad. And because you only had one statement in the 'do' it wasn't actually doing anything monadic. It was an odd way to write it, though :)
03:10:13 <hpaste>  Cale annotated "replaceString problem" with "my version of your idea" at http://hpaste.org/1193#a2
03:10:34 <quicksilver> Cale: he's using a screen reader, layout isn't convenient for him :)
03:10:40 <Cale> oh
03:10:43 <Cale> okay...
03:11:48 <hpaste>  Cale annotated "replaceString problem" with "without layout." at http://hpaste.org/1193#a3
03:11:52 <dcoutts> interesting, perhaps that's a good justification to provide explicit layout as an option
03:12:06 <quicksilver> dcoutts: ?
03:12:14 <dcoutts> not, 'perhaps' is is a good justification
03:12:21 <dcoutts> quicksilver: accessibility
03:12:40 <tsp> dcoutts: what does explicit layout mean?
03:12:43 <quicksilver> dcoutts: but your phrasing suggested that explicit layout wasn't an option currently
03:12:44 <Cale> That's a good point, I wonder how accessible python is.
03:12:44 <dcoutts> and a tool to convert implicit to explicit for people who want to read code that way
03:12:48 <quicksilver> dcoutts: that's what confused me
03:12:58 <tsp> Cale: someonw rote me a brace processor for python :)
03:13:05 <Cale> tsp: nice :)
03:13:08 <tsp> else i have to use l in ed with tabs
03:13:14 <dcoutts> quicksilver: well few people use it, that's what I mean and some people wonder why it's provided as an option
03:13:20 <quicksilver> dcoutts: right, yes :)
03:13:40 <quicksilver> dcoutts: I just discovered an odd bug, too; it seems you can use explicit at the top level, unless you use the module Main where {} form
03:13:45 <quicksilver> dcoutts: s/can/can't/
03:14:00 <dcoutts> quicksilver: report it as a bug
03:14:02 <quicksilver> dcoutts: so 'quick scripts' can't use explicit at the top level
03:14:09 <quicksilver> dcoutts: in what? ghc?
03:14:12 <dcoutts> right
03:14:24 <dcoutts> though check what hugs does too
03:14:42 <desp> clear
03:14:44 <dcoutts> might be a bug in both or our misunderstanding
03:14:56 <dcoutts> if they differ it's a bug
03:15:40 <quicksilver> dcoutts: I don't have hugs here
03:15:49 <quicksilver> dcoutts: I checked the grammar the haskell report
03:15:52 <dcoutts> quicksilver: what's the example, I'll try it
03:15:57 <quicksilver> dcoutts: it's fairly clear to me that it should work
03:16:02 <quicksilver> I'll paste it
03:16:15 --- quit: tizoc (Connection timed out)
03:16:27 --- quit: dfeuer (No route to host)
03:16:35 <hpaste>  quicksilver pasted "simple top-level explicit layout (not accepted by ghci)" at http://hpaste.org/1194
03:17:56 <dcoutts> quicksilver: ok, hugs accepts that so it must be a ghc bug
03:18:09 <dcoutts> so go ahead and report it
03:18:38 <dcoutts> and cite the example of users with screen readers as an extra motivation to fix it
03:20:23 --- join: tizoc (n=user@r190-64-207-192.dialup.adsl.anteldata.net.uy) joined #haskell
03:21:42 <Cale> quicksilver: what if you drop the braces?
03:22:02 <quicksilver> Cale: then it doesn't like the '3' on its own
03:22:11 <quicksilver> Cale: it believes that to be the start of a new topdecl
03:22:14 <Cale> ah, okay
03:22:33 <quicksilver> Cale: the real example was fun x = \nif
03:22:38 <Cale> Yeah, so I suppose you need to include an explicit module declaration.
03:22:44 <quicksilver> yes, that's the workaround
03:22:49 <quicksilver> but it should work :)
03:23:01 <Cale> which is just  module Main where { ... }
03:25:17 <quicksilver> Cale: yes, that's what I did :) Note that line in the code I pasted for tsp just before you did :)
03:25:20 <quicksilver> http://hackage.haskell.org/trac/ghc/ticket/1253
03:25:22 <lambdabot> Title: #1253 (Can't use explicit braces/semicolons (i.e. non-layout) at top level with  ...
03:26:39 <dcoutts> quicksilver: good bug report
03:26:57 <quicksilver> thanks :)
03:27:03 --- quit: noclouds (Remote closed the connection)
03:28:19 --- join: DukeDave (n=DukeDave@146.227.5.194) joined #haskell
03:31:15 --- join: robreim (n=bobstopp@luckynet229060.luckynet.jp) joined #haskell
03:34:05 --- join: cptchaos (n=cptchaos@e182068137.adsl.alicedsl.de) joined #haskell
03:44:05 --- join: meester (n=meester@e248078.upc-e.chello.nl) joined #haskell
03:44:09 <arcatan> btw, do ghc and gtk2hs work on windows?
03:44:51 <ndm> arcatan: yes, perfectly
03:45:41 --- join: daniel_larsson (n=danilo@sd-rlas.servicefactory.se) joined #haskell
03:46:12 --- join: der_eq (n=eq@dslc-082-082-069-211.pools.arcor-ip.net) joined #haskell
03:47:43 --- join: BCoppens (n=bartcopp@kde/developer/coppens) joined #haskell
03:49:54 --- quit: iblechbot (Read error: 110 (Connection timed out))
03:50:44 --- quit: mrchebas ()
03:52:58 <nominolo> @pl \x f -> f x
03:52:58 <lambdabot> flip id
03:53:44 <nominolo> @pl \x fs -> map (\f -> f x) fs
03:53:44 <lambdabot> map . flip id
03:56:17 --- quit: LoganCapaldo (Read error: 110 (Connection timed out))
03:57:10 --- join: gh_ (n=gh@geh.loria.fr) joined #haskell
03:57:18 <quicksilver> nominolo: or simply map ($x) fs
03:57:34 <quicksilver> nominolo: sometimes going all-the-way pointfree isn't worth it :)
03:57:45 <tsp> lol, Trac - which hackage.org uses - is written in python?
03:57:52 <quicksilver> tsp: yup :)
03:58:04 <nominolo> quicksilver: oh, yes. thanks.  that looks more readable :)
03:58:05 <quicksilver> tsp: the world is a big place, it takes a while to rewrite it *all* in haskell :)
03:58:38 <tsp> quicksilver: good to know python still has a place :)
03:59:13 <tsp> one of haskell's major weaknesses is object orientation - e.g. in my replaceString function, I have to explicitly specify the string
03:59:25 --- quit: gh_ (Remote closed the connection)
03:59:26 <tsp> where in an OO language I would say string.replace(old,new)
03:59:44 <nominolo> so now you write replace string old new
03:59:47 <nominolo> even shorter
03:59:53 <tsp> ah
04:00:03 <tsp> hmm, the string object wouldn't change anyway
04:00:06 <ibid> tsp: maybe that's because haskell is not an object oriented language? :)
04:00:13 <ibid> tsp: there are no objects in haskell
04:00:26 <vincenz> data Object;
04:00:37 <tsp> ibid: objects make it significantly easy to encapsulte stuff
04:00:48 <tsp> s/easy/easier
04:00:50 <vincenz> tsp: so do modules
04:01:08 <vincenz> or data-types
04:01:09 <nominolo> tsp: haskell has quite a different approach, though. that's certainly true
04:01:24 <rahikkala> The object.thingInsideObject syntax is just a kluge to make not having multiple dispatch look natural ;)
04:01:25 <ibid> tsp: maybe so, but that does not make haskell an oo language. for information hiding, use modules
04:01:36 --- part: edwardk left #haskell
04:01:52 <hpaste>  LPhas annotated "happs learning" with "(no title)" at http://hpaste.org/1195#a1
04:01:57 <vincenz> for encapsulation, use data-types with record-syntax
04:02:04 <ibid> tsp: you can encapsulate data and behavior by putting functions inside the data
04:02:07 --- join: dfeuer (n=topolog@wikimedia/Dfeuer) joined #haskell
04:02:09 <vincenz> for templates use higher-order tycons
04:02:22 <nominolo> tsp: hm .. if you use haskell the right way, things are even nicer encapsulated
04:02:33 <quicksilver> tsp: haskell offers all the abstractions that OO offers, but they are actually more fine-grained
04:02:43 <quicksilver> tsp: so you can pick and choose the appropriate ones for the circumstance
04:02:59 <nominolo> e.g. you start by defining some data type, then the primitives.  then you implementation is quite easy to substitute
04:03:00 <ibid> quicksilver: that's not true. there is no object abstraction in haskell
04:03:21 <vincenz> ibid: I was going to make the same comment, though existentials help
04:03:27 <dons> an existential is just an object.
04:03:37 --- join: dirkjanh (i=83d35341@gateway/web/cgi-irc/ircatwork.com/x-9cc47c243aa5dfe3) joined #haskell
04:03:42 <dons> full type abstraction, statically checked.
04:03:42 * vincenz beeps dons 
04:03:46 <ibid> dons: an existenial IORef i could buy as an object :)
04:03:48 <pejo> Subtyping! Emacs! Vim! Ed!
04:04:00 * vincenz peers at pejo 
04:04:01 <dons> ibid: hehe. ok. state-boy ;-)
04:04:25 <ibid> dons: oject = identity + STATE  + beavior
04:04:31 <vincenz> ibid: not true
04:04:34 <dolio> Objects don't need to be mutable. For instance, strings aren't in Java.
04:04:36 <tsp> hmm, could a state help me maintain all the lists I would need in writing, say, an irc client?
04:04:41 <tsp> or would I still have ot pass it to everything
04:04:42 <vincenz> ibid: what about languages that have non-mutable objects, like ocaml?
04:04:51 <ibid> vincenz: they are not true objects
04:05:01 <vincenz> ibid: according to *your* definition
04:05:06 <ibid> vincenz: of course, this is very much a matter of definition :)
04:05:09 <dons> tsp,any state you need, you pass in a monad. see e.g. lambdabot or xmonad.
04:05:24 <ibid> vincenz: according to a definition that makes a lot of sense to me :) ... not mine by any measure, btw
04:05:37 <vincenz> ibid: many people consider it objects hence the little o' in o'caml
04:05:49 <vincenz> mutability is orthogonal and that's what 'ref's are for
04:05:53 <ibid> vincenz: yes, they do, and they're wrong from my pov :)
04:05:58 <tsp> but I'd need to make everything a monad - in the case of an irc client, ignore user, etc
04:06:04 <ibid> but this is a fruitless debate
04:06:07 <ibid> --> goes
04:06:08 <vincenz> mutability `isOrthogonalTo` objects
04:06:27 <vincenz> > True
04:06:28 <lambdabot>  True
04:06:28 --- join: gh_ (n=gh@geh.loria.fr) joined #haskell
04:06:30 <nominolo> tsp: no, everything will live in the same monad
04:06:50 <tsp> nominolo: would that allow me to do something like addToList ignored_users user?
04:07:03 <tsp> nominolo: or would the one-use-per-variable apply
04:07:17 <vincenz> dons: how hard is it to grow arrays?
04:07:23 <nominolo> tsp: yes, something like:  ignoreUser :: Username -> IrcM ()
04:07:42 <tsp> ah
04:07:49 <vincenz> or simply
04:07:55 <vincenz> ignoreNominolo :: IrcM ()
04:07:56 <vincenz> :P
04:08:17 <tsp> I thought that once a variable was set, I couldn't reset it - so if my monad had an ignoreList, I couldn't add to it
04:08:20 <dons> tsp: yeah, i think you'll just need some experience writing apps in haskell. none of this is terribly hard, you just have to learn how to do it.
04:08:29 <nominolo> tsp: and ignoreUser u = do s <- get; put (returnNewStateWithUserIgnoredAdded s u)
04:08:32 <quicksilver> tsp: that's only true in a sense
04:08:37 <tsp> ah, return the state
04:08:46 <quicksilver> tsp: you can explicitly pass a state around
04:08:54 <quicksilver> tsp: and when it changes, you just pass the new state around, instead
04:09:02 <quicksilver> tsp: then, that becomes a bit of a hassle
04:09:02 --- quit: dirkjanh ("CGI:IRC (Ping timeout)")
04:09:05 <dons> > runState (do x <- get ; put (x+1) ; return () ) 7
04:09:06 <lambdabot>  ((),8)
04:09:06 <quicksilver> tsp: and that's where monads come in
04:09:09 <nominolo> vincenz: yes, but that is just api-sugar ;)
04:09:14 <quicksilver> tsp: monads are a way to 'hide plumbing'
04:09:20 <quicksilver> tsp: in this case, passing state around all the time
04:09:26 <tsp> quicksilver: ah, so I can change the monad and it'll get passed around
04:09:27 <vincenz> nominolo: :)
04:09:28 <quicksilver> tsp: the state is still being passed but it's hidden away
04:09:31 <quicksilver> tsp: right
04:10:22 * nominolo has class now
04:10:23 <tsp> monads are confusing - I've read docs on them etc but they still get me for a loop, I just know how to read a file now :)
04:10:42 <quicksilver> tsp: well you don't need to try to understand them up front
04:10:52 --- quit: nominolo ("Get MacIrssi - http://www.g1m0.se/macirssi/")
04:10:53 <quicksilver> tsp: experiement with some general programming and pick them up gradually
04:11:23 <tsp> I don't want to be stuck writing string parsers :) I want to hack a text editor, but again can't pass the list of lines around
04:11:35 <tsp> and don't know where to look for easy docs on this stuff
04:11:56 <earthy> what do you consider easy?
04:11:59 <vincenz> Yay for amazon:
04:11:59 <vincenz> Yay for amazon: As someone who has expressed interest in books by Douglas R. Hofstadter,
04:12:02 <vincenz> you might like to know that "I Am a Strange Loop" will be released on 5
04:12:05 <vincenz> April 2007. You can pre-order your copy for just £14.24 by following the
04:12:07 <vincenz> link below.
04:12:14 <vincenz> grr, damn newlines
04:12:50 <quicksilver> tsp: fair enough, but nobody writes a text editor in a new language on their 3rd day :)
04:12:54 <earthy> http://www.cs.uu.nl/docs/vakken/gont/diktaat.pdf is a reasonable introduction to grammars and parsing e.g.
04:12:57 <quicksilver> tsp: it takes a while for it to filter in
04:13:27 * earthy agrees with quicksilver there
04:13:31 <vincenz> earthy: does it deal with GLR?
04:13:34 <earthy> give it time to gestate
04:13:48 <earthy> vincenz: it's a bachelor's course...
04:14:08 <vincenz> GLR has matrured enough...
04:14:42 --- quit: Dybber ("Leaving")
04:14:45 <earthy> yeah, but from 'barely knows fp' up to 'understands glr
04:14:50 <earthy> ' is quite some ways
04:15:13 <earthy> you won't get students that far in a mere 200 hours
04:15:15 <vincenz> oh, it's a bacherlor course on FP, I thought it was a bachelor course on parsing
04:15:21 <earthy> it is on parsing
04:15:39 <earthy> but it als has to introduce regular languages and grammars and such
04:16:01 <psykotic> isn't GLR just a nondeterministic interpretation of LR tables?
04:16:11 <vincenz> psykotic: you're alive
04:16:34 <vincenz> psykotic: yes, but 'just' is a matter of definitioin
04:17:23 <psykotic> well i mean a naive nondeterministic interpretation, as opposed to something like that algorithm named after a japanese guy which tries to merge "threads" of execution
04:18:21 <psykotic> tomita
04:18:52 <earthy> ghe. tomita is cool
04:19:01 <vincenz> from a webpage "Tomita's Algorithm amounts to a simple generalisation of the standard LR algorithm. "
04:19:14 <earthy> parseforests in less than exponential time
04:20:46 <psykotic> vincenz, tomita is glr except that it uses dynamic programming to share as much as possible
04:21:28 <psykotic> basically suppose you have an LR parsing that in one part splits off two ways due to a potential ambiguity and later continues normally. in that case tomita would share the last common part between the two split off parsings
04:21:40 * vincenz nods
04:22:41 <psykotic> so, tomita is a little tricky but just interpreting an LR table nondeterministically is really basic, especially in a functional language
04:23:18 <psykotic> you could write it in a backtracking monad and the code would be the same as a normal LR table machine/driver
04:23:38 --- join: Averell- (n=averell@i577B52F0.versanet.de) joined #haskell
04:23:54 --- quit: Averell (Nick collision from services.)
04:23:56 --- nick: Averell- -> Averell
04:24:28 --- join: kuribas (n=user@108.3-200-80.adsl-dyn.isp.belgacom.be) joined #haskell
04:24:57 --- join: LoganCapaldo (n=logan@ool-457a8e39.dyn.optonline.net) joined #haskell
04:25:01 --- join: Alneyan (n=Hush@i05m-87-90-220-231.d4.club-internet.fr) joined #haskell
04:27:28 <psykotic> vincenz, btw one nice thing about GLR is that you can use the extremely simple LR(0) table generating algorithm and still get something with full generality
04:27:49 <vincenz> psykotic: does it hold the same propertiers as tomita that it improves if you use a 'better' grammar table?
04:27:51 <Saizan> LR?
04:27:54 <psykotic> from that point of view the purpose of the other algorithms is efficiency, not generality
04:28:14 <vincenz> right
04:28:17 <vincenz> which answers my Q
04:28:52 --- join: doserj (n=doserj@dewey.inf.ethz.ch) joined #haskell
04:29:29 <psykotic> Saizan, its a class of bottom-up parsing algorithms. LR stands for left-to-right parse, rightmost derivation
04:30:42 --- join: eddyp_ (n=eddy@ns.bitdefender.com) joined #haskell
04:30:43 <Saizan> ah, so the table is the one with Not-terminal symbols on one side and terminals on the other?
04:32:17 <psykotic> actually the states (one of the "dimensions") is made up of item sets, where an item is a right-hand-side/rule with a "position" inside the rule indicated, and the item sets are closed with respect to an operation thats similar to epsilon closure in regular expressions
04:34:21 <psykotic> so for instance, suppose you have a production expr <- expr + expr
04:34:25 --- quit: ikegami-- (Remote closed the connection)
04:35:15 <psykotic> the possible items for that production would be _ expr + expr, expr _ + expr, expr + _ expr and expr + expr _, where the _ is a position/marker
04:35:39 <psykotic> it basically says how much of that rule has already been matched and how much has to be matched
04:36:08 <Saizan> oh
04:36:31 <Saizan> ok, is something i've never seen :)
04:36:33 <psykotic> so a set of those items corresponds to a bunch of different rules being explored in parallel
04:38:14 <psykotic> i think this is usually covered in compiler courses. most people seem much more comfortable with topdown parsing ala LL(k)
04:38:35 --- quit: bolrod (Read error: 110 (Connection timed out))
04:39:00 <psykotic> anyway this is the kind of thing that yacc does
04:39:47 --- join: peddro (n=peddro@212.203.31.1) joined #haskell
04:44:14 --- join: bolrod (n=Tim@84-104-179-208.cable.quicknet.nl) joined #haskell
04:47:18 <Saizan> i'm following one this semester, only 48 hours though :\
04:48:17 --- join: YayikAyran06 (n=YayikAyr@81.214.18.171) joined #haskell
04:50:07 <YayikAyran06> anybody has a code for burrows-wheeler transform?
04:50:40 --- quit: balodja (Read error: 113 (No route to host))
04:50:46 <psykotic> YayikAyran06, try searching the haskell-cafe archives, i remember someone posted code for BWT there
04:53:00 --- join: chub (n=Chubbuck@195.90.13.83) joined #haskell
04:53:42 --- join: bringert (n=bringert@dhcp-248-145.nomad.chalmers.se) joined #haskell
04:58:11 --- quit: wilx|wrk ("Miranda IM! Smaller, Faster, Easier. http://miranda-im.org")
04:58:41 --- quit: the_dormant ("This computer has gone to sleep")
05:00:34 --- join: the_dormant (n=on@freeway.rd.francetelecom.com) joined #haskell
05:00:37 --- join: twanvl (n=twanvl@ip5451f037.direct-adsl.nl) joined #haskell
05:02:28 --- quit: the_dormant (Client Quit)
05:04:17 --- quit: ski (Read error: 110 (Connection timed out))
05:05:07 --- join: uccus (n=chatzill@60.225.79.76) joined #haskell
05:15:58 --- join: int-e (n=noone@t54fc41f1.pool.terralink.de) joined #haskell
05:16:38 --- quit: a-priori_ (Read error: 110 (Connection timed out))
05:18:24 --- join: iblechbot (n=iblechbo@62.216.217.252) joined #haskell
05:19:13 <YayikAyran06> anybody willin to help for a college homework :) ?
05:20:14 --- join: balodja (n=noname@62.117.85.97) joined #haskell
05:20:23 <twanvl> sure
05:21:15 <Jaak> @quote homework
05:21:16 <lambdabot> vincenz says: sure, give us your homework and we'll email it straight to your teacher :)
05:21:28 <YayikAyran06> great ;)
05:22:21 <YayikAyran06> bothead make me pass wif A+ ;)
05:22:23 <vincenz> notice how the sarcasm drips off of that like the oil from a philly chees steak
05:23:35 --- join: beelsebob (n=tatd2@82.153.3.179) joined #haskell
05:24:45 <Thunder> I found some funny things today: My last Xmas lecture ... http://www.iks-jena.de/mitarb/lutz/vortrag/weihnacht2004.hs ... Script: http://www.iks-jena.de/mitarb/lutz/vortrag/weihnacht2004.ps.bz2 it's about rautavistic computer science. Have fun or ignore it.
05:29:49 <quicksilver> I think Andrzej
05:30:05 <quicksilver> aworksi is taking the path to trollhood
05:30:11 <tsp> Thunder: who uses postscript?
05:30:20 <vincenz> Woo
05:30:21 <vincenz> gtk2hs+=
05:30:23 <vincenz> gtk2hs++
05:30:28 <vincenz> Gotta love software that builds so smoothly
05:30:29 <tsp> how did you write that in postscript? I thought it was binary
05:30:34 --- quit: kfish ("pike!")
05:30:45 <Thunder> tsp: You can get the tex source, too.
05:30:57 <tsp> vincenz: does the haskell gtk api support the accessibility interfaces?
05:31:13 <vincenz> tsp: no idea
05:31:38 <tsp> Thunder: that reminds me - another thing I want is a way to read tex documents - hearing all the symbols drives me nuts
05:31:45 <vincenz> http://www.haskell.org/gtk2hs/docs/gtk2hs-docs-0.9.11/
05:32:29 <pejo> tsp, is pdf significantly better than postscript from an accessibility pov?
05:32:37 <tsp> pejo: lol
05:32:41 <tsp> pejo: some would say yes
05:32:48 <tsp> but adobe reader is so slow its almost unusable
05:33:06 <vincenz> wtf is accessibility?
05:33:09 <tsp> pdftotext screws up -everything-, including indentation for a python book I found
05:33:27 <Thunder> tsp: Stick to the haskell source and you get the idea.
05:33:33 --- join: dirkjah (i=83d35272@gateway/web/cgi-irc/ircatwork.com/x-e20b838b01e3ae23) joined #haskell
05:33:36 <tsp> vincenz: it helps screen reader users
05:33:45 <vincenz> tsp: by doing ...what?
05:34:01 <tsp> vincenz: providing hooks and api's so that we can use the programs
05:34:07 <vincenz> contrast settings help screen reader users
05:34:29 <vincenz> oh, wait, I parsed 'screen reader user' wrongly
05:34:36 <tsp> vincenz: how so? Contrast is some sort of monitor setting
05:34:37 <vincenz> you mean for TTS
05:34:39 <tsp> vincenz: yeah
05:34:41 * vincenz nods
05:35:00 <vincenz> I thoguht you meant users that read from screen at first
05:35:13 <tsp> vincenz: I don't even have a monitor - its in a closet for when I need to pull out the webcam and the other box for some obstenent piece of software that won't talk
05:35:28 --- join: MarcWeber (n=marc@pd9e0bcb7.dip.t-dialin.net) joined #haskell
05:35:37 <vincenz> tsp: you're blind?
05:35:50 <tsp> vincenz: yup
05:35:53 --- quit: uccus ("Chatzilla 0.9.77 [Firefox 2.0.0.3/2007030919]")
05:36:08 <tsp> funny enough, I can never configure X properly enough that it'll work
05:36:17 <dcoutts> :-)
05:36:24 <tsp> work = be able to take a screenshot of it  to see what breaks
05:36:46 --- quit: dfeuer (Read error: 110 (Connection timed out))
05:36:49 <tsp> so I went back to windows as the talking terminal - it has a good vmware setup for the linux box I need for haskell hacking :)
05:37:35 <tsp> accessibility isn't just the os - I want to buy a new computer, and am 99% positive that I'll have to get a pile of people on irc and the webcam to configure its bios
05:38:33 --- join: mkhl (i=mkhl@200-153-181-164.dsl.telesp.net.br) joined #haskell
05:38:48 --- join: tizoc[w] (n=user@r190-64-32-122.dialup.adsl.anteldata.net.uy) joined #haskell
05:41:52 <psykotic> tsp, are there any text editors with good support for the blind?
05:42:20 --- quit: ClaudiusMaximus ("->")
05:42:29 <psykotic> i remember hearing about emacspeak but wasn't sure about how well it works
05:43:18 --- join: xeroxuni (i=82c0d142@gateway/web/cgi-irc/ircatwork.com/x-b9d29ec9d10686a9) joined #haskell
05:43:19 --- join: nominolo (n=nominolo@intothevoid.csbnet.se) joined #haskell
05:44:03 <tsp> emacspeak works, but I don't like it much
05:44:24 <tsp> I don't like the whole arrow keys and cursor movement style of editing
05:44:44 --- join: lordrat (n=lordrat@r2aj154.net.upc.cz) joined #haskell
05:44:49 <tsp> for example, if you have the mistyped line "this is a test on the #haskel channel on freenode"
05:45:19 <tsp> you have to hit next-word over the "this is a test of the", then find the l to add an extra l
05:45:45 <nominolo> tsp: you prefer raskin-style leap-keys?
05:45:45 <tsp> where I can just type out s/haskel/haskell and get it the first time, with ed reprinting the line due to the lack of a trailing /
05:45:45 <psykotic> couldnt you use incremental search to position the point?
05:46:02 <arcatan> this reminds me of the video in which somebody tries to code perl with windows vista speech recognition
05:46:11 <tsp> psykotic: incremental search might get me somewhere else
05:46:16 <vincenz> arcatan: that was .... sad
05:46:29 <vincenz> tsp: you have ed running on irc?
05:46:40 <tsp> vincenz: ed on irc? no
05:47:02 <tsp> but it's become so much of a habbit to type s/x/y without even thinking about it now that I may as well write an ed interface to irc with a scrollback and all
05:47:51 <vincenz> or :quit
05:47:55 --- quit: lordrat (Client Quit)
05:48:10 <tsp> for example, in emacs's dired mode, emacspeak would speak files, directories and links in different voices - that's all well and good, but it uses a dectalk speech synth which I have. The problem with that is that the speech server lags
05:48:38 --- join: benny (n=benny@p57b564d5.dip.t-dialin.net) joined #haskell
05:48:42 <tsp> no-one else on the emacspeak mailing list thinks it lags. I think that they're so used to slow speech response that it's natural to them
05:48:50 * quicksilver nods
05:49:14 <quicksilver> real screenreader experts have their voices up so fast that unskilled people have no chance of understanding :)
05:49:27 <quicksilver> I listened to a podcast of a fast screenreader once
05:49:29 <tsp> case in point: http://silenceisdefeat.org/~tspivey/eloquence.flac
05:49:40 <tsp> quicksilver: podcasts are pretty slow
05:49:57 <tsp> that flac file was my normal speed as of a month or two ago - I think I sped it up a bit since then
05:50:02 <therp> woot, after a slightly wrong unification algorithm and a typo, my embedded prolog finally solves the zebra problem.
05:50:15 <quicksilver> tsp: but this podcast contained a recording of someones screenreader at high speed
05:50:19 <tsp> quicksilver: ah
05:50:28 <tsp> high speed is subjective though :)
05:50:47 <quicksilver> tsp: indeed. I don't claim to be experienced, but it was fast enough that I couldn't understand it :)
05:51:04 <tsp> I can listen at high speed, but most of the info I get is useless - for example in windows
05:51:17 --- quit: YayikAyran06 ()
05:51:19 <vincenz> like "Please reboot"
05:51:49 <tsp> run dialog type the name of a ... <I shut it up> control<enter> desktop list view not selected my documents 1 of 67 control panel blah blah blah
05:52:06 <tsp> I don't care that my desktop reappeared for a second and a half
05:53:08 <vincenz> how do you deal with special characters? (non-alphabetical ones)
05:53:20 <tsp> vincenz: ah, punctuation? it reads them, if I set it to
05:53:33 <vincenz> doesn't that get overly verbose/
05:53:39 <tsp> yup
05:53:47 <tsp> every time I speak, it says less tsp greater
05:54:03 <tsp> I could turn that off, but I'd need to keep tweaking it for everything I did
05:54:11 <vincenz> does it use a different voice to make it clear it's punctuation?
05:54:20 <tsp> and under windows I need to go through a cupple of menus to get to it
05:54:30 <tsp> vincenz: nope
05:54:31 <tsp> vincenz: that would be highly annoying
05:54:39 <pejo> quicksilver, apparently you get used to listening quickly quite soon if you do it a lot. I visited a company that monitors tv/radio/newspapers for companies and all they listened to souded like chip and dale.
05:54:43 <vincenz> alphabetical backslash  symbol \
05:54:43 --- quit: xeroxuni ("Stoka--")
05:54:54 <tsp> heh
05:54:58 <tsp> for a \, it just says back slash
05:55:10 <vincenz> I typed back slash
05:55:15 <tsp> yeah
05:55:17 <tsp> it read that too
05:55:25 <vincenz> well they must sound similar
05:55:32 <tsp> it does
05:55:33 <mux> can it read
05:56:17 <mux> err
05:56:19 <vincenz> simpleMonadFunction :: (Monad m) => String -> m String
05:56:22 <tsp> ouch
05:56:25 <mux> can it read λ ?
05:56:32 <tsp> mux: it read that
05:56:39 <mux> as lambda? :)
05:56:43 <tsp> but its my job to figure out what it does, it doesn't tell me its a function
05:56:49 <mux> that's very nice
05:56:56 <tsp> it said
05:57:16 <vincenz> tsp: no he typed a lambda symbol, he wasn't referring to my code
05:57:19 <tsp> ah
05:57:21 <tsp> the ?
05:57:24 <vincenz> no
05:57:28 <vincenz> prior to that was a lambda symbol
05:57:29 <mux> only ? if you don't have utf-8
05:57:30 <vincenz> it's extend UTF
05:57:32 <tsp> damnit
05:57:39 <tsp> tera term doesn't support utf-8 :)
05:57:42 <mux> ok
05:57:48 <tsp> if it did, it probably would have read something
05:57:54 <vincenz> but yeah, my function signature would be a haskell function signature
05:57:55 <mux> λx.x
05:58:03 --- join: vstranger (n=stranger@p57B83FC6.dip0.t-ipconnect.de) joined #haskell
05:58:11 <tsp> vincenz: it made no sense of that - reading the punctuation literally
05:58:23 <vincenz> even the parentheses?
05:58:27 <tsp> yup
05:58:37 <vincenz> good :) they
05:58:41 <vincenz> they're maeningfunl
05:58:47 <tsp> it also doesn't distinguish between 2 of the 3 possible letter "a"s in swedish
05:59:08 * dylan wonders how a braile combination input/output device would be.
05:59:29 <tsp> dylan: I have a braille display, but that thing is impossible to use when I"m lying in a bed where I do most of my work these days :)
05:59:38 <tsp> besides, they suck with ed
06:00:00 <vincenz> you use ed and not vi?
06:00:06 --- join: miez (n=g@241-120-16-213.pandsl.hu) joined #haskell
06:00:10 <tsp> ed and edbrowse
06:00:10 --- nick: peddro -> Peddro
06:00:17 <int-e> vi displays too much information I guess
06:00:21 <vincenz> probably
06:00:23 <tsp> edbrowse mostly, but fall back to ed if edbrowse doesn't work
06:00:28 <psykotic> im impressed that you can get anything done at all this way. you must have a very good memory--as a programmer i rely on the screen extensively as a sort of ultra short term memory, i cannot imagine not having that.
06:00:31 --- join: russo (n=russo@dslb-088-074-006-166.pools.arcor-ip.net) joined #haskell
06:00:53 --- quit: mr_tenor (Remote closed the connection)
06:00:58 <tsp> psykotic: memory wise, its not that great - I have to keep going back up to previous functions/classes
06:00:59 <vincenz> psykotic: I was thinking the same thing, getting the structure of code must require very good memory
06:01:07 <tsp> haskell is truely annoying
06:01:10 <dylan> tsp: were you born blind or did it happen later in life?
06:01:13 <tsp> dylan: born this way
06:01:26 <tsp> I doubt that I'd want to be able to see - too much new learning
06:01:33 <psykotic> tsp: how do you visualize the relationship between parts of a text}
06:01:41 <tsp> psykotic: how so?
06:01:43 <psykotic> i feel bad using the term visualize
06:01:48 <tsp> psykotic: text wise
06:01:48 <psykotic> how do you organize it in your head
06:01:52 <tsp> psykotic: no idea, I just do
06:01:59 <tsp> psykotic: I'm stuck in the ed lines mindset
06:02:21 <tsp> I know that haskell is going to give me problems when I go beyond 1 or 2 functions
06:02:26 <vincenz> tsp: what about such things as matching braces in a java-like language?
06:02:37 <tsp> vincenz: edbrowse has a B command that solves that, mostly
06:02:49 <tsp> and it also browses the web which is a plus
06:03:01 <tsp> but I want to rewrite that is a true talking app
06:03:34 <vincenz> tsp: I guess you also try to minimize what is displayed in whatever windowing system you use?
06:03:34 <quicksilver> vincenz: for tsp, haskell has braces :P
06:03:52 <tsp> I use mutt to read mail, but it's too big and bulky - it takes up an entire screen for its index, when I could use the previous lines of output to display something else
06:03:53 <vincenz> quicksilver: yeah, layout rule would suck
06:03:57 <malcolmw> I can imagine that if you keep your function definitions short, haskell might be better than e.g. Java for comprehension.
06:04:12 <tsp> the best language I've found so far is python - oddly enough
06:04:18 <tsp> write a brace parser for it and there we go
06:04:18 <vincenz> tsp: with the indent??
06:04:42 <tsp> vincenz: I strugled around with tabs and ed's \t\t\t, tried to memorize my level (mostly worked), but someone wrote me a brace parser that helps alot
06:04:56 <tsp> so I can write def f(x): {
06:04:58 <vincenz> if you like python, try ruby, it's much like python but it has explicit end's
06:05:08 <tsp> vincenz: ruby and edbrowse's brace matching didn't get along
06:05:15 <tsp> since it uses end, and no explicit begin
06:05:43 <malcolmw> I think it should be easy to persuade any haskell compiler to convert layout to explicit braces and give you the result
06:05:58 <vincenz> yes, that's actually purely a lexer thing
06:06:09 <tsp> malcolmw: if I start learning haskell, I guess someone will be annoyed enough to write one that goes the other way
06:06:14 <vincenz> tsp: and although haskell has indent rules, it's just a short cut for internal brace-style coding
06:06:17 <tsp> malcolmw: contributing to it, that is
06:06:17 <malcolmw> after all, the compiler it doing it internally anyway, so making it available to the user should be simple
06:06:25 <vincenz> tsp: braces are standard syntax as well
06:07:11 <vincenz> tsp: the lexer replaces the start of an indentiation with a hidden brace, so you can program with explicit braces, but it would be nice if the lexer could reoutput code so you could easily bracify other people's code
06:07:19 <tsp> vincenz: that would be cool
06:07:36 <tsp> vincenz: how about going the other way? would people really be able to read, say, a hundred line program written in my style?
06:08:04 <vincenz> tsp: sure, it's somorphic
06:08:10 <tsp> I do the equivalent of ,s/^\s*//g and it's almost a g/^$/d
06:08:11 <vincenz> isomorphic even
06:08:21 <tsp> vincenz: isomorphic?
06:08:24 <int-e> tsp: maybe with some preprocessing (namely, indenting it)
06:08:35 <malcolmw> although it would be a little more difficult, I'm sure a tool to convert braces to layout would not take long to write
06:08:37 --- join: jewel (n=jewel@61.247.251.10) joined #haskell
06:08:58 <malcolmw> in fact, a compiler can probably do that already as well
06:09:01 <int-e> tsp: a flat view can be highly confusing if you're not used to it.
06:09:18 <vincenz> tsp: if one line is indented more than a previous line, the lexer inserts a brace for the parser.   But you acn progam with explicit braces
06:09:31 <tsp> vincenz: that part is easy
06:09:39 --- join: the_dormant (n=on@freeway.rd.francetelecom.com) joined #haskell
06:09:45 * malcolmw notes that the Hat parser can read explicit braces and output nicely indented layout style instead
06:09:59 <vincenz> malcolmw: I think the reverse direction would be more interesting for tsp
06:10:27 <dcoutts> in theory the Language.Haskell lib can do that
06:10:27 <int-e> hmm. I wonder how hard it is to write a tool that adds the explicit braces. does something like this exist already?
06:10:37 <vincenz> int-e: it's the lexer that does it...
06:10:38 <dcoutts> in practise it misses a bunch of stuff
06:10:40 --- nick: sioraiocht|sleep -> sioraiocht
06:10:51 <malcolmw> int-e: pretty much every compiler does layout to braces
06:10:55 <vincenz> int-e: any h98 compatible lexer that keeps comments could do it
06:11:06 <dcoutts> the Language.Haskell pretty printer can produce both styles
06:11:15 <quicksilver> well, sort of
06:11:17 <vincenz> dcoutts: nice, though what of comments?
06:11:21 <malcolmw> oh yeah, I forgot about the comments - compilers tend to strip those away
06:11:24 <quicksilver> a h98 lexer would typically remove newlines and blanklines, though
06:11:28 <dcoutts> however it does other stupid things like miss out (..)parens
06:11:30 --- join: ddarius (n=Derek@208.180.182.107) joined #haskell
06:11:32 <vincenz> quicksilver: indeed, and comments
06:11:50 <quicksilver> which is not the end of the world
06:11:54 <quicksilver> but just making that point :)
06:11:59 <dcoutts> the HaRe stuff keeps the comments
06:12:02 <quicksilver> you'd want to add back newlines between different functions, at least
06:12:10 <quicksilver> and possibly around multi-line comment blocks
06:12:16 <vincenz> the whole idea of this tool would be to ease code reading of other people's code for tsp , removing the comments sort of defeats that purpose
06:12:17 <dcoutts> since it's a refactorer it tries to keep existing stuff as much as possible
06:12:28 <tsp> quicksilver: haskell has no way for, say, an editor to find the next/previous function :)
06:12:44 <tsp> in python, I can just do /^\s*def /
06:12:49 <tsp> at least with ed
06:12:57 <vincenz> tsp: you can do /^[^\s]/
06:13:13 <tsp> what good would that be?
06:13:21 --- quit: vstranger ("BitchX: causing all sorts of havok!")
06:13:23 <tsp> that woudl search for anything that wasn't indented
06:13:28 --- join: ekidd (n=emk@pool-72-92-149-224.burl.east.verizon.net) joined #haskell
06:13:39 <vincenz> tsp: yes, whic can only be comments or top level deifnitions
06:13:46 * vincenz mutters at the lag induced by his ssh connection
06:13:49 <quicksilver> vincenz: unles you're not using layout
06:13:55 --- quit: execlp (Read error: 113 (No route to host))
06:13:57 <quicksilver> vincenz: in which case, any line can be non-indented :P
06:14:01 <tsp> in layout that holds true, I think
06:14:01 <vincenz> quicksilver: which is rare
06:14:06 <quicksilver> vincenz: but not for tsp
06:14:10 <quicksilver> vincenz: for him, it's universal
06:14:13 <tsp> vincenz: in my case, I need a way to jump between elements
06:14:17 <vincenz> quicksilver: n but he can look for braces instead
06:14:24 <tsp> not for functions
06:14:30 <quicksilver> vincenz: toplevels don't get braces
06:14:35 <tsp> although I could just code with the x = do { thing I did earlier
06:14:43 <quicksilver> what you need to look for is 'top-level semicolons'
06:14:53 <tsp> heh, ;'s could be anywhere
06:14:58 <quicksilver> but that implies your editor can match braces
06:15:03 <quicksilver> and know which semicolonos are top-level
06:15:09 <tsp> lol, edbrowse can match braces
06:15:16 <tsp> but that's it
06:15:21 --- join: execlp (n=execlp@ppp-81-25-50-76.ultranet.ru) joined #haskell
06:15:21 <quicksilver> tsp: yes, but match braces and then exclude semicolons inside them
06:15:22 <vincenz> tsp: why not use something custom, namely place a little marker in a comment?
06:15:25 <quicksilver> tsp: which is slightly more :)
06:15:38 <tsp> vincenz: I'll probably end up doing that
06:15:40 <mauke> /=$/
06:15:49 <vincenz> {-function-}
06:15:56 <quicksilver> /=$/ is pretty good
06:15:59 <ddarius> Why not just add top level type declarations and search for those.
06:16:00 <lambdabot> ddarius: You have 1 new message. '/msg lambdabot @messages' to read it.
06:16:06 <quicksilver> as long as you make that a convention
06:16:15 <tsp> quicksilver: what's /=$/?
06:16:25 <quicksilver> tsp: regexp for equals at the end of a line?
06:16:29 <tsp> ah
06:16:30 <tsp> yeah
06:16:51 <vincenz> that would bork as soon as you have trailing spaces or one-line functions
06:16:59 <quicksilver> indeed
06:17:00 <vincenz> foo x = x + x
06:17:06 <tsp> I was thinking - can I make a function that does nothing, then put it at the beginning?
06:17:09 <mauke> trailing spaces is just /=\s*$/
06:17:10 <tsp> e.g.
06:17:25 <tsp> f x = func $ x+1;
06:17:31 <vincenz> tsp: id?
06:17:35 <tsp> where func is something that does nothing
06:17:40 <vincenz> id does nothing
06:17:47 --- join: zarvok (i=ccasingh@BEANCOUNTER.RES.cmu.edu) joined #haskell
06:17:55 <mauke> whatever = undefined;
06:18:00 <int-e> tsp: sure you can define   func x = x   and that will work.
06:18:02 <vincenz> > let foo x = id $ x + x in foo 2
06:18:03 <lambdabot>  4
06:18:03 <mauke> (great for prototyping, too)
06:18:11 --- join: shawn (n=shawn@adsl-70-231-255-214.dsl.snfc21.sbcglobal.net) joined #haskell
06:18:23 <tsp> @src id
06:18:24 <lambdabot> id x = x
06:18:26 <tsp> ah
06:18:44 <mauke> @src undefined
06:18:44 <lambdabot> undefined =  error "Prelude.undefined"
06:19:13 <vincenz> what I love doing in haskell, is making everything undefined, making sure my top-level type signuatres are correct and then incrmenentally code, usinig the compiler to tell me when I have bugs :)
06:19:34 <vincenz> sigh, this ssh lag is really annoying, I only see what I type like a second after I type it, all these stupid typos :/
06:19:35 --- join: shawn_ (n=shawn@adsl-70-231-255-214.dsl.snfc21.sbcglobal.net) joined #haskell
06:20:14 <vincenz> tsp: why do you use X or windows, why not a plain term?
06:20:14 <tsp> vincenz: are you sshing from a cellphone or something?
06:20:30 <vincenz> tsp: no, but for some reason the box I'm sshing to has a laggy connection
06:20:41 <tsp> vincenz: I can't use X - I just use it for qemu or vmware since orca nd gnome can speak it :) otherwise, its windows and tera term
06:20:58 <tsp> the plain terms works, until someone asks me to call them on skype
06:20:59 <vincenz> why not a plain linux tty?
06:21:04 <vincenz> ah
06:21:29 <tsp> besides, bsd on a sparc box atm, and linux on a vmware box under win for haskell
06:21:32 <vincenz> well X ONLY for skype and then linux tty's
06:21:35 --- join: Ytinasni_ (n=a@203.109.208.201) joined #haskell
06:21:36 <tsp> ghc doesn't like sparc64
06:22:20 --- quit: Ytinasni (Nick collision from services.)
06:22:25 --- nick: Ytinasni_ -> Ytinasni
06:23:28 <dcoutts> tsp: ghc-6.4.1 builds and works fine on sparc, 6.4.2 is ok except for some issues in ghci and 6.6 fails to work for me on sparc64
06:23:53 <tsp> dcoutts: what does 6.6 do?
06:23:54 <dcoutts> tsp: mind you I'm using 32bit user space (as I believe is common)
06:23:59 <tsp> you could probably use 6.4.2 to compile 6.6
06:24:07 <dcoutts> tsp: I've tried
06:24:07 --- join: jmelesky (n=jmelesky@dsl081-136-068.chi1.dsl.speakeasy.net) joined #haskell
06:25:19 <dcoutts> tsp: it build the ghc stage2 ghc binary (I think it was stage2 not just stage1) but when run that fails immediately with an error message like "schedule: re-entered unsafely. perhaps you forgot to make a foreign export as 'safe'? "
06:25:47 <vincenz> unsafeMakeStage2
06:25:51 <tsp> dcoutts: is this on bsd?
06:25:54 <dcoutts> tsp: there's a full bug report in the ghc trac somewhere, I think solaris had the same issue. I'm using linux.
06:25:54 <tsp> weird
06:25:58 <tsp> ah
06:25:59 <tsp> linx
06:26:01 <tsp> s/x/ux
06:26:32 <dcoutts> tsp: debian have a build but they build unregisterised, without ghci and without the threaded rts :-(
06:26:42 <dcoutts> tsp: which is a shame since 6.4.1 worked just perfectly
06:27:00 * dcoutts -> bed
06:27:05 <dcoutts> g'night folks
06:27:09 <vincenz> cya dcoutts
06:27:48 <tsp> hmm
06:28:11 <dcoutts> @tell dons I implemented the new desugarer, see the code in darcs
06:28:12 <lambdabot> Consider it noted.
06:34:13 --- quit: shawn (Read error: 110 (Connection timed out))
06:36:02 --- quit: beelsebob (Client Quit)
06:36:31 <mux> ghc not working on sparc64?
06:36:42 --- quit: JohnMeacham (Read error: 104 (Connection reset by peer))
06:36:43 <Alneyan> Naive question of the day: is it considered bad style to use parallel list comprehensions?
06:36:47 * mux ponders booting his netra X1
06:37:00 --- quit: DukeDave (Remote closed the connection)
06:37:05 <dons> Alneyan: they're rather nice, imo.
06:37:06 <lambdabot> dons: You have 1 new message. '/msg lambdabot @messages' to read it.
06:37:12 <dons> Alneyan: though you can always use a zip.
06:37:20 <dons> maybe if more people used them, they'd be standardised :-)
06:37:35 <dons> Alneyan: certainly not bad style. maybe a bit obscure.
06:38:07 --- join: rashakil (n=rashakil@shocking-pink-21.dynamic2.rpi.edu) joined #haskell
06:39:01 <Alneyan> dons: Yeah, I quite like them too, so I reckon I'll stick with them. Thanks!
06:39:14 <Saizan> parallel as in Control.Parallel?
06:39:37 <ski_> > [x+y | x <- [0,1,2] | y <- [10,30,50]]
06:39:37 <lambdabot>  Parse error
06:39:44 <merus> > [(x, y) | x <- [1..3], y <- [1..3]]
06:39:46 <lambdabot>  [(1,1),(1,2),(1,3),(2,1),(2,2),(2,3),(3,1),(3,2),(3,3)]
06:40:28 <Saizan> oh, i tought that was a common use..
06:40:39 <wolverian> the former, not the latter.
06:41:23 <Saizan> > [[x+y | x <- [0,1,2]] | y <- [10,30,50]] -- this?
06:41:24 <lambdabot>  [[10,11,12],[30,31,32],[50,51,52]]
06:41:29 <ski_> no
06:41:33 <ski_> not nested
06:41:47 <ski_> parallel / lock-step / zipping
06:42:13 <Saizan> liftM2?
06:42:15 <Igloo> malcolmw: What is the good reason hmake doesn't do macros?
06:42:31 <ski_> (Saizan : for certain values of 'm', yes ..)
06:42:55 <ski_> > liftM2 (+) [1..3] [1..3]  -- not this 'm', e.g.
06:42:57 <lambdabot>  [2,3,4,3,4,5,4,5,6]
06:43:03 <malcolmw> Igloo: macros are not required for conditional imports
06:44:00 <merus> > liftM2 (,) [1..2] [1..2]
06:44:01 <lambdabot>  [(1,1),(1,2),(2,1),(2,2)]
06:44:05 <merus> hunh.
06:44:20 <ski_> you want the stream monad ..
06:44:24 <malcolmw> Igloo: at least, I can't think of a good use of macros that couldn't just be placed directly into the conditional
06:44:31 <merus> the stream monad?
06:44:38 --- quit: ddarius (Read error: 110 (Connection timed out))
06:45:01 <ski_> merus ; 'return' is 'repeat', and 'join' takes the diagonal
06:45:20 <merus> Oho.
06:45:25 <malcolmw> Igloo: also, this is the first time anyone ever has tried it :-)  which is good evidence that it isn't needed
06:45:41 <ski_> (merus : and if you want, you can use potentiall-finite streams)
06:45:57 * merus `ap` class -- :(
06:46:20 <ski_> malcolmw : isn't it evidence that it was needed right here ?
06:46:41 <malcolmw> ski_: no, because it was trivially easy to replace the macro with a pure conditional
06:47:30 <ski_> malcolmw : (heh, was not following your conv.) .. where is this example showed ?
06:47:37 <malcolmw> ski_: (it even made the code shorter)
06:47:53 <quicksilver> :t repeat
06:47:56 <lambdabot> forall a. a -> [a]
06:48:01 <ski_> :t return
06:48:03 <lambdabot> forall a (m :: * -> *). (Monad m) => a -> m a
06:48:11 --- join: Gu1 (n=mwheelen@72.14.22.104) joined #haskell
06:48:12 <malcolmw> ski_: in a patch I just pushed to the filepath package repo
06:48:14 <quicksilver> > repeat 1
06:48:15 <lambdabot>  [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1...
06:48:36 <ski_> quicksilver,merus : so 'liftM2' basically is 'zipWith' in that monad
06:48:38 --- quit: zarvok ("BitchX-1.1-final -- just do it.")
06:48:39 <quicksilver> ah, gotcha
06:48:41 * quicksilver nods
06:48:45 <quicksilver> yes, I worked it out now :)
06:49:03 <quicksilver> so parallel list comprehensions are in fact zipWith comprehensions?
06:49:10 <ski_> hm
06:49:22 <ski_> [x+y | x <- [0,1,2] | y <- [10,30,50]]
06:49:24 <ski_> is
06:49:36 <ski_> zipWith (+) [0,1,2] [10,30,50]
06:49:38 * quicksilver nods
06:49:42 <quicksilver> yes, that's what I meant
06:49:46 --- join: erg0t (n=ergot@200.69.210.29) joined #haskell
06:49:53 <quicksilver> is this syntax provided by some actual compiler extension?
06:49:59 <ski_> and, assuming '[]' here is our zipping monad (assuming we can hide the standard one .. or something)
06:50:06 --- join: JohnMeacham (n=JohnMeac@h-69-3-118-110.lsanca54.dynamic.covad.net) joined #haskell
06:50:14 <ski_> quicksilver : you can always make a newtype, or new datatype
06:50:27 <ski_> liftM2 (+) [0,1,2] [10,30,50]
06:50:37 <Saizan> http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#parallel-list-comprehensions <--
06:50:39 <lambdabot> Title: 7.3. Syntactic extensions, http://tinyurl.com/y6v6by
06:50:44 <ski_> do x <- [0,1,2]; y <- [10,30,50]; return (x+y)
06:50:59 <ski_> [x+y | x <- [0,1,2] , y <- [10,30,50]]
06:51:06 <ski_> QED
06:51:38 <ski_> quicksilver : it looks like you're right .. amazing discovery :)
06:52:11 <sioraiocht> > do {x <- [0,1,2]; y <- [10,30,50]; return  (x+y)}
06:52:12 <quicksilver> ski_: well this converstaion started
06:52:12 <lambdabot>  [10,30,50,11,31,51,12,32,52]
06:52:17 <quicksilver> ski_: with someone talking about using them :)
06:52:18 <sioraiocht> ?
06:52:29 <quicksilver> sioraiocht: yes, but that uses the standard List monad
06:52:38 <quicksilver> sioraiocht: ski_ is talking about a different way of making lists into moands
06:52:41 <ski_> sioraiocht : that uses the ordinary list monad instance, not the one we were considering here
06:52:48 <sioraiocht> ah, sorry
06:53:02 --- quit: kosmikus ("leaving")
06:53:03 * sioraiocht just joined the convo
06:53:37 <erider> good morning
06:53:59 <ski_> hm .. so this is strange .. the '|' in parallel list comprehensions is actually like ',', just for another monad
06:54:20 <ski_> hm, what about guards in list comprehensions
06:54:24 <ski_> ?
06:54:38 <ski_> in the ordinary list monad we have
06:55:02 --- join: ihope_ (n=ihope@c-71-205-100-59.hsd1.mi.comcast.net) joined #haskell
06:55:10 --- nick: ihope_ -> ihope
06:55:17 <ski_> [x+y | x <- [0,3,6,9] , y <- [1,5,8] , x < y]
06:55:21 <ski_> is the same as
06:55:43 <ski_> do x <- [0,3,6,9]; y <- [1,5,8]; guard (x < y); return (x+y)
06:55:46 <ski_> :t guard
06:55:48 <lambdabot> forall (m :: * -> *). (MonadPlus m) => Bool -> m ()
06:56:04 --- join: johnnowak (n=johnnowa@207-38-246-119.c3-0.wsd-ubr2.qens-wsd.ny.cable.rcn.com) joined #haskell
06:56:25 <ski_> so, the obvious question is : can one make out other monad an instance of 'MonadPlus', and what does guards mean there ?
06:56:33 <ski_> (s/out/our/)
06:56:49 --- join: nornagon_ (n=nornagon@203-219-165-210.static.tpgi.com.au) joined #haskell
06:56:49 --- quit: dolio (Read error: 104 (Connection reset by peer))
06:56:53 <ski_> :t mzero
06:56:55 <lambdabot> forall (m :: * -> *) a. (MonadPlus m) => m a
06:58:27 <ski_> hm .. which laws should hold ?
06:59:11 <ski_> i guess 'mzero' must be '[]', if anything at all .. (otherwise we get to partial values, and i don't think we should need to do that)
06:59:49 <Saizan> do (x,y) <- zip [0,3,6,9] [1,5,8]; guard (x < y); return (x+y) <-- it should behave like this one in the list monad, right?
07:00:03 <ski_> i'm not sure
07:00:17 --- join: crathman_ (n=chatzill@69.15.198.171) joined #haskell
07:00:27 <ski_> i still don't know what 'guard' would do in the (potentially finite) stream monad
07:00:37 <quicksilver> I don't think it can work
07:00:42 --- join: dolio (n=dolio@nr10-216-68-185-39.fuse.net) joined #haskell
07:00:56 <quicksilver> the semantics saizan wants is to 'miss out' some elements of the zip
07:01:04 <quicksilver> but that's a complete change to the monad
07:01:16 <quicksilver> that effect can't be acheived with a monadplus instance
07:01:17 --- quit: MarcWeber ("leaving")
07:01:34 <ski_> left_mzero :: forall ma. mzero >> ma = mzero
07:02:00 <ski_> would 'mzero = []' satisfy that ?
07:02:25 <ski_> (>>) = liftM2 (flip const)  -- i think
07:02:53 <ski_> so that means zipping with the empty list .. and that gives an empty list !
07:02:58 <Cheery> does there exist some builtin function which would do:   (f ["ad", "be", "cg"] ", ") == ["ad, be, cg"]
07:02:59 <quicksilver> ski_: mzero = [] would kill everything
07:03:01 <quicksilver> ski_: right
07:03:04 <dino-> I was trying to get readFile behavior to be both strict and faster, so I tried Data.ByteStream.Char8
07:03:05 --- quit: kpreid ()
07:03:05 <Cheery> ägh, something like that
07:03:12 <quicksilver> Cheery: Data.List.intersperse
07:03:17 <ski_> quicksilver : so that law holds, at least .. yay !
07:03:24 <quicksilver> :t intersperse
07:03:26 <lambdabot> forall a. a -> [a] -> [a]
07:03:30 <dino-> It seems super slower just doing a B.readFile and then length . B.words on the result
07:03:33 --- join: kpreid (n=kpreid@cpe-24-59-154-165.twcny.res.rr.com) joined #haskell
07:03:35 <ski_> @src guard
07:03:36 <lambdabot> guard True  =  return ()
07:03:36 <lambdabot> guard False =  mzero
07:03:46 <quicksilver> > concat . intersperse ", " $ ["ad","be","cg"]
07:03:47 <lambdabot>  "ad, be, cg"
07:03:58 <quicksilver> Cheery: see? :)
07:04:04 <ski_> foo = do x <- [0,3,6,9]; y <- [1,5,8]; guard (x < y); return (x+y)
07:04:08 <dino-> Like more than twice as slow. :o
07:04:36 <ski_> 'foo' zips three lists, and maps '(\(x,y,_) -> x+y)'
07:04:38 <Cheery> I see, I need to concat it myself later then
07:04:43 <ski_> hm
07:04:43 <dino-> I wonder if I'm doing something wrong. Maybe using the wong module.
07:04:45 <quicksilver> Cheery: yes but that's not very hard :)
07:04:45 <ski_> well
07:05:00 --- quit: bringert ()
07:05:03 --- quit: sioraiocht ()
07:05:13 <Cheery> concat $ intersperse ", " ["a", "b", "c"]
07:06:05 <Saizan> > concatMap (++ ", ") ["a","b","c"]
07:06:06 <lambdabot>  "a, b, c, "
07:07:29 <quicksilver> Saizan: similar but not the same :)
07:07:46 <Saizan> yeah
07:08:48 <ski_> > let return = repeat; join ((a:_):ass) = a : join (map tail . takeWhile (not . null) $ ass); join _ = []; (>>= f) = join . map f; guard b = if b then return () else [] in [0,3,6,9] >>= \x -> [1,5,8] >>= \y -> guard (x < y) >>= \_ -> return (x+y)
07:08:48 <lambdabot>  Parse error in pattern
07:09:20 <Cheery> Saizan, thanks about that too.
07:09:26 <Cheery> it's also a bit useful. :)
07:10:30 <quicksilver> Cheery: so many different ways to do stuff :)
07:11:31 <ski_> > let return = repeat; join ((a:_):ass) = a : join (map tail . takeWhile (not . null) $ ass); join _ = []; ma >>= f = join . map f $ ma; guard b = if b then return () else [] in [0,3,6,9] >>= \x -> [1,5,8] >>= \y -> guard (x < y) >>= \_ -> return (x+y)
07:11:33 <lambdabot>  [1]
07:11:43 --- join: HairyDude (n=pwb@cpc4-sket1-0-0-cust922.swan.cable.ntl.com) joined #haskell
07:12:05 <HairyDude> is it possible to use DrIFT to make types?
07:12:42 <dino-> Does that sound normal to anyone? That let l = B.readFile "bigassfile" >>= length . B.words  should be horrendously slower than using the Prelude readFile/words ? (where B is Data.ByteString.Char8)
07:13:09 <HairyDude> not lazy enough?
07:15:38 <quicksilver> dino-: depends how big bigass is
07:15:41 <dino-> 1M
07:15:48 <quicksilver> 1M? now that is odd
07:15:49 <dino-> 972K or something.
07:15:51 <ski_> hmm
07:15:55 <quicksilver> that's not bigass at all
07:15:59 <quicksilver> that's like really tiny :)
07:16:25 <quicksilver> there are differences, though
07:16:38 <quicksilver> B.readFile keeps around the whole file in a big chunk
07:16:42 --- part: Gu1 left #haskell
07:16:54 <quicksilver> whereas the prelude version lets it be GC'ed bit by bit
07:17:02 <quicksilver> dino-: try Lazy Bytestring?
07:17:19 <dino-> Part of why I went for ByteString in the first place is I want it strict.
07:17:37 <quicksilver> nod
07:17:38 <dino-> I want to be able to output '.' chars to stderr as each file is being processed of a large group.
07:17:52 <dino-> Which, of course, doesn't sequence nice for me with the lazy read.
07:18:12 <dino-> I think
07:18:13 <quicksilver> well depends what you mean by processed
07:18:21 <quicksilver> if processed actually does something and uses the result
07:18:28 <quicksilver> then that will sequence just fine
07:18:45 <quicksilver> if it doesn't then strictifying the file doesn't really help :P
07:18:48 <dino-> I have a list of FilePath's, I want to get the number of words in each one. Each time one is done, print a '.'
07:18:53 <quicksilver> all that does is sequence the file reads
07:19:02 <quicksilver> it doesn't sequence the processing :)
07:19:17 <quicksilver> so then it has to hold all the files in memory
07:19:24 <quicksilver> until you get around to actually doing the counting
07:19:40 <dino-> ok
07:19:53 --- join: mjk (i=kvirc@218.59.115.234) joined #haskell
07:22:04 <dino-> I'm trying to gather up all the results of this counting into a list. Later I'll need to see them all to figure out column width for output.
07:22:21 --- join: obsethryl (n=opus@unaffiliated/obsethryl) joined #haskell
07:25:40 --- quit: der_igel ("Leaving")
07:26:09 <ski_> > let return = repeat; join ((a:_):ass) = a : join (map tail . takeWhile (not . null) $ ass); join _ = []; ma >>= f = join . map f $ ma; guard b = if b then return () else [] in [1,5,8] >>= \y -> [0,3,6,9] >>= \x -> guard (x<y) >>= \() -> return (x+y)
07:26:10 <lambdabot>  [1,8,14]
07:26:28 <ski_> hm .. so order seems to matter for some reason ..
07:27:10 --- quit: mjk ("KVIrc 3.2.6 Anomalies http://www.kvirc.net/")
07:27:33 --- part: Peddro left #haskell
07:29:20 --- join: scw (i=b92103@bsd5.csie.ntu.edu.tw) joined #haskell
07:29:41 --- join: der_igel (n=der_igel@brsg-4db2d38b.pool.einsundeins.de) joined #haskell
07:31:42 <therp> my simply and stupid unification is presumable doing redundant work too often, any off-the-shell unification "libraries" I can use instead?
07:31:47 --- quit: kuribas ("ERC Version 5.0.2 $Revision: 1.726.2.11 $ (IRC client for Emacs)")
07:33:23 <dino-> I guess I can't use this in any case. It's like 2.5x slower
07:34:24 --- quit: der_igel ("Leaving")
07:42:41 --- quit: dirkjah ("CGI:IRC (Ping timeout)")
07:45:43 <glguy> Would anyone happen to know of an existing functional doubly connected edge list library?
07:46:18 --- join: lizhn (n=chatzill@222-23.dorm.ccu.edu.tw) joined #haskell
07:47:27 --- part: Thunder left #haskell
07:47:45 <dino-> I wonder if there's any value in using openFile, hGetContents, hClose for this.
07:48:55 --- join: der_igel (n=der_igel@brsg-4db2d38b.pool.einsundeins.de) joined #haskell
07:50:47 <dino-> Wow! When I do { h <- openFile "bigtext" ReadMode; content <- hGetContents h; let l = length . words $ content; hClose h; putStrLn $ show l } ...
07:50:57 <dino-> I get 0
07:50:58 <dino-> bah
07:51:08 <ski_> don't use 'hClose' on a handle you've used 'hGetContents' on ..
07:51:50 <ski_> 'hGetContents' will do a 'hClose' itself, lazily .. so you shouldn't do it yourself
07:51:52 <earthy> *unless* you've forced the contents
07:52:16 --- join: kosmikus (n=andres@gentoo/developer/kosmikus) joined #haskell
07:52:23 <dino-> I see.
07:52:23 <dylan> hmm, how much does it cost to buy a trusted SSL certificate?
07:52:35 <earthy> dylan: depends
07:53:03 <earthy> http://www.cacert.org/ is fairly cheap
07:53:03 <ski_> earthy : if you force the whole contents, doesn't the forcing of the final '[]' 'hClose' the handle ?
07:53:05 <lambdabot> Title: Welcome to CAcert.org
07:53:25 <earthy> ski: yeah, and that is exactly when the extra hClose doesn't kill you :)
07:53:44 <dino-> Ok, I get similar time as with Prelude.readFile now. I wonder if that's what's really going on in there anyway: (\x -> openFile x ReadMode >>= hGetContents) or similar.
07:54:00 <ski_> better to avoid extra 'hClose', imo ..
07:54:08 <dino-> ski_: thank you
07:54:31 <earthy> dylan: however, a 'commercial' license is pricey
07:55:11 <ski_> (if copy-on-write semantics was implemented in 'hGetContents', it would probably be an error to use 'hClose' then, i think ..)
07:55:14 --- quit: amiddelk ("Cya later")
07:55:49 <quicksilver> dylan: bout $100, in practice
07:55:52 <earthy> ski: hm. yah
07:56:01 <quicksilver> dylan: some places will give them for free to opensource organisation, though
07:56:03 <ski_> (anyway, one should think of 'hGetContents' as calling 'hClose', so that's why one doen't need to do it oneself .. only complication is that it call it lazilly :)
07:56:07 <ski_> @spell lazilly
07:56:09 <lambdabot> lazily Lilly lazuli labially hazily
07:56:30 <earthy> ofcourse, there are other contexts in which forcing the result garnered from hGetContents is useful
07:56:52 <quicksilver> in most of those cases you're probably better of not using it in the first place
07:56:57 <earthy> such as when you get from a child process and want to wait for it ending
07:57:02 <dino-> quicksilver: Where readFile will do, you mean?
07:57:04 * quicksilver is deeply suspicious of unsafe lazy IO
07:57:08 <quicksilver> dino-: readFile is as bad/worse
07:57:16 <dino-> oh, when you don't want the lazy at all
07:57:30 --- quit: rashakil ("Leaving")
07:57:44 <earthy> dino-: basically, you never want IO to be lazy at all
07:58:00 * therp just recognizes how important strictness actually is for the performance of Haskell.
07:58:43 <quicksilver> if I was writing an app that didn't care about performance, I'd use strict whole-file IO
07:58:55 <quicksilver> if I was writing an app that did care, I'd do my own IO
07:59:06 <quicksilver> and make my own decisions about when to read the next chunk
07:59:22 * earthy nods
08:00:26 <quicksilver> having said that, readFile getContents are convenient in throwaway programs and shortlived scripts, if you understand the caveats
08:00:45 --- join: Muad_Dib (n=muad_dib@sd511609f.adsl.wanadoo.nl) joined #haskell
08:01:20 <dino-> Ok, but that brings me back to using Data.ByteString.Char8's readFile. When I want to call words on the result of that: unbelievably slow.
08:02:18 <quicksilver> dino-: I"m a bit baffled by that, I must admit
08:02:20 <dino-> Any alternative to that?
08:02:24 <quicksilver> dino-: I suggest a haskell-cafe posting
08:02:27 --- quit: malcolmw ("got to go...")
08:02:33 <quicksilver> dino-: you could ask dons or dcoutts, but I think they're asleep :)
08:02:39 <norpan> hmmm, bytestring is strict so the method of reading it in shouldn't matter, right?
08:03:01 <quicksilver> norpan: that doesn't really follow
08:03:09 <Philippa> "don't care but want sane memory usage" is the main use case for lazy IO
08:03:09 <dino-> That's what I should be using, right? The Char8 sub-module?
08:03:16 * ski_ wonders whether the file is huge ..
08:03:22 <quicksilver> ski_: 1M, roughly
08:03:28 <quicksilver> ski_: not very big really
08:03:29 <norpan> quicksilver: well, it'
08:03:41 <norpan> it will allocate an array for all of it and read it in strictly
08:03:42 <dino-> ski_: 952k
08:03:48 <Philippa> for values of sane where running a 10 gigabyte file through your code on a 32bit system is viable
08:03:49 <quicksilver> norpan: but only once it starts
08:04:07 <quicksilver> norpan: it might not read in when you thing it does
08:04:15 <Philippa> try a lazy bytestring?
08:04:18 <quicksilver> norpan: it will read in (all at once) once you try to do something with it
08:04:24 <norpan> yes, exatcly
08:04:26 <norpan> exactly
08:04:41 <dino-> Philippa: yeah, I'll try that. Someone else mentioned that earlier as well. I forget whom.
08:04:44 <norpan> so try another operation, like length
08:05:20 --- join: hrgh (n=ulf@nl-219-237.netlogon.liu.se) joined #haskell
08:05:50 <dylan> quicksilver: what places have them for $100?
08:06:10 <quicksilver> dylan: godaddy.com
08:06:17 <dylan> ah.
08:06:19 <quicksilver> dylan: (probably not the only place)
08:06:49 <earthy> godaddy is somewhat expensive on the renewals by the way, usually
08:06:54 <earthy> at least, with domain names they are
08:07:03 <dino-> mm, very fast, B.length
08:07:04 --- part: chub left #haskell
08:07:16 <quicksilver> dylan: IIRC, comodo is cheap-ish, too
08:07:40 <quicksilver> dino-: B.length is O(1) for strict bytestrings, yes :)
08:07:42 <quicksilver> dino-: it knows how long its buffers are...
08:07:46 <dino-> Maybe I should try B.split ' '
08:08:15 <dino-> I see, yeah.
08:09:16 --- join: ikegami-- (n=ikegami@29.41.138.210.xn.2iij.net) joined #haskell
08:10:01 --- quit: jewel (Read error: 110 (Connection timed out))
08:10:22 <dino-> Also much faster than B.words. Interesting.
08:14:31 <quicksilver> now that's very off
08:14:32 <quicksilver> odd
08:14:40 <quicksilver> I thought B.words *was* split ' '
08:15:24 <Saizan> > words "foo\tbar"
08:15:26 <lambdabot>  ["foo","bar"]
08:15:27 <dino-> Actually, split gives me a bigger list. Probably because adjacent spaces are counted separately. Where words is looking for space breaks between things of any length.
08:15:32 <glguy> split ' ' probably treats "a  b" differently
08:15:38 <dino-> exactly
08:15:54 <quicksilver> I'm still surprised by "much faster" though
08:16:23 <dino-> 10x faster
08:16:54 <quicksilver> if you can produce a relatively small demonstration of that, I think you should post it to the -cafe
08:17:05 <dino-> I certainly can.
08:19:00 <lizhn> does 'B' mean ByteString?
08:19:22 <dino-> lizhn: Yes  import qualified Data.ByteString.Char8 as B
08:19:42 --- join: brannon (n=brannon@lnc.usc.edu) joined #haskell
08:19:45 <lizhn> dino: thx
08:19:47 <dino-> So it doesn't collide with the same-named functions in the Prelude.
08:20:00 --- join: chessguy (n=chessguy@66.33.255.68) joined #haskell
08:20:18 --- quit: Botje (Read error: 54 (Connection reset by peer))
08:20:19 --- quit: meester (Remote closed the connection)
08:20:25 --- quit: brannon (Remote closed the connection)
08:20:58 <chessguy> hi haskellers
08:21:26 --- join: Plareplane (n=Plarepla@69-11-115-214.sktn.hsdb.sasknet.sk.ca) joined #haskell
08:23:26 --- join: Botje (n=Brownies@dD576403D.access.telenet.be) joined #haskell
08:24:31 --- join: cptchao1 (n=cptchaos@d115152.adsl.hansenet.de) joined #haskell
08:26:36 --- join: laz0r (n=laz0r@port-87-234-144-134.dynamic.qsc.de) joined #haskell
08:27:16 <laz0r> hi, erm, if i would like to see the definition of foldl, where would i look?
08:27:23 <rahikkala> @src foldl
08:27:24 <lambdabot> foldl f z xs = lgo z xs
08:27:24 <lambdabot>     where lgo z []     =  z
08:27:24 <lambdabot>           lgo z (x:xs) = lgo (f z x) xs
08:27:31 <laz0r> ah, thank you
08:27:45 <int-e> @src Data.List
08:27:45 <lambdabot> Source not found. And you call yourself a Rocket Scientist!
08:27:57 <Saizan> @source Data.List
08:27:57 <lambdabot> http://darcs.haskell.org/packages/base/Data/List.hs
08:28:29 <rahikkala> Also http://haskell.org/onlinereport/ , in this case http://haskell.org/onlinereport/list.html
08:28:30 <lambdabot> Title: The Haskell 98 Language Report
08:28:30 <int-e> oh right.
08:28:34 <int-e> thanks Saizan
08:29:25 <quicksilver> laz0r: although, that's a rather odd way to define it, incidentally :)
08:29:47 <quicksilver> laz0r: most of us probably wouldn't bother with 'lgo' especially if the purpose was just to explain how it works
08:30:04 --- quit: the_dormant ("Leaving")
08:32:01 --- join: swiert (n=saonteu@dslb-084-063-006-212.pools.arcor-ip.net) joined #haskell
08:32:19 --- quit: seancorfield ()
08:34:20 --- part: ADEpt left #haskell
08:34:37 <therp> I'm asked to not walk on the grass in an organization email of a conference. I guess the only place where such a conference could be is England. And so it is.
08:35:02 <laz0r> quicksilver, actually i wondered about that too, but its ok, i figured it out... i just wanted to compare it to a definition of foldr in the wikibook im currently reading
08:35:08 <quicksilver> laz0r:  :)
08:35:36 --- quit: der_eq (Read error: 104 (Connection reset by peer))
08:35:45 --- join: der_eq (n=eq@dslb-088-070-018-056.pools.arcor-ip.net) joined #haskell
08:36:24 --- quit: hrgh ("leaving")
08:36:47 --- nick: lizhn -> lazist
08:40:41 --- quit: cptchaos (Read error: 110 (Connection timed out))
08:43:08 --- join: prb (n=prb@c-24-22-188-196.hsd1.wa.comcast.net) joined #haskell
08:48:05 --- quit: der_igel ("Leaving")
08:50:26 --- quit: dvekravy (Read error: 104 (Connection reset by peer))
08:50:30 --- join: dvekravy (i=dvekravy@real.wilbury.sk) joined #haskell
08:52:47 --- nick: pstickne_ -> pstickne
08:58:10 --- join: bos (n=bos@adsl-69-107-67-47.dsl.pltn13.pacbell.net) joined #haskell
09:00:08 --- quit: lazist (Remote closed the connection)
09:00:10 --- join: der_igel (n=der_igel@brsg-4db2d38b.pool.einsundeins.de) joined #haskell
09:01:33 --- quit: shawn_ ("This computer has gone to sleep")
09:03:33 <Saizan> ?seen kolmodin
09:03:33 <lambdabot> kolmodin is in #darcs, #gentoo-haskell and #haskell. I last heard kolmodin speak 1d 9h 35m 48s ago.
09:05:53 --- quit: xs (Remote closed the connection)
09:06:20 --- join: korcs (n=g@241-120-16-213.pandsl.hu) joined #haskell
09:06:33 <ikegami--> hello
09:07:48 <ikegami--> i notice that ghc's POSIX library of Haskell may not have a feature of 'sticky bit'
09:09:07 <ikegami--> actually, ghc's System.Posix has a datatype 'FileMode', but i couldn't find stickyMode::FileMode
09:09:54 --- quit: ihope (Read error: 104 (Connection reset by peer))
09:10:07 <ikegami--> therefore I wrote a short FFI snippet and, my problem was solved
09:10:37 <ikegami--> maybe POSIX does not support sticky bit, i don't know
09:11:30 --- join: __xs__ (n=pi@82.152.216.238) joined #haskell
09:11:56 --- join: sm (n=sm@pool-71-104-94-179.lsanca.dsl-w.verizon.net) joined #haskell
09:12:05 <ikegami--> anyone has an interest about sticky bit issue? :-)
09:12:14 --- nick: __xs__ -> xs
09:13:13 <ski_> foldl f = lgo
09:13:16 <ski_>     where ...
09:13:35 <dmwit> foldl f z [] = z
09:13:52 <dmwit> foldl f z (x:xs) = foldl f (f z x) xs
09:14:48 --- quit: xs (Remote closed the connection)
09:15:42 --- join: sioraiocht (n=rtharper@syru197-007.syr.edu) joined #haskell
09:16:26 --- quit: sioraiocht (Client Quit)
09:16:37 --- join: sioraiocht (n=rtharper@syru197-007.syr.edu) joined #haskell
09:20:27 --- quit: Excedrin (Remote closed the connection)
09:20:47 --- quit: der_igel (Read error: 104 (Connection reset by peer))
09:22:20 <quicksilver> ikegami--: pretty sure stick bits aren't in POSIX
09:22:32 --- join: der_igel (n=der_igel@brsg-4db2d38b.pool.einsundeins.de) joined #haskell
09:22:44 <ikegami--> quicksilver: good point!
09:22:56 <ikegami--> I didn't know it
09:23:02 --- quit: tstewart ()
09:23:21 <ikegami--> thanks
09:24:10 --- join: Excedrin (i=Excedrin@gateway/tor/x-201d799d923befc9) joined #haskell
09:24:11 --- quit: miez (Read error: 110 (Connection timed out))
09:24:24 <ikegami--> now I rewrite /bin/test in Haskell for a joke on April Fool
09:24:35 --- join: __xs__ (n=pi@82.152.216.238) joined #haskell
09:25:09 --- nick: __xs__ -> xs
09:26:43 <ikegami--> and the '-k' option of /bin/test, which tests whether file is sticky or not, is not easy to write in Haskell (needs FFI)
09:27:09 --- quit: crathman_ ("Chatzilla 0.9.77 [Firefox 2.0.0.3/2007030919]")
09:27:39 <ikegami--> i need a small C function: mode_t stickyMode (void) { return S_ISVTX; }
09:28:28 <ikegami--> however, Haskell FFI is very useful!
09:29:09 <quicksilver> haskell FFI is nice and simple
09:29:10 <quicksilver> for simple things
09:29:13 <quicksilver> I like that very much
09:30:33 --- join: zarvok (i=ccasingh@ENIACONWIRES.RES.cmu.edu) joined #haskell
09:30:55 --- join: crathman (n=chatzill@69.15.198.171) joined #haskell
09:31:35 <ikegami--> now I can add some options to /bin/Test, which is written in Haskell
09:31:59 <ikegami--> even /bin/test has over 30 options
09:32:53 --- join: reilly (n=rfh@66.159.231.18) joined #haskell
09:33:08 <ikegami--> I think it's interesting idea that every commands in /bin is rewritten in Haskell
09:33:52 <Igloo> ikegami--: Is there not even a function for it in System.Posix somewher?
09:34:49 <kpreid> when I looked, there wasn't one
09:35:45 <ikegami--> Igloo: I refer /bin/test of GNU coreutils 6.9, and only '-k option (check sticky bit)' needs FFI
09:36:38 <ikegami--> Igloo: other options can be written with System.Posix and some with System.IO, System.Directory
09:36:39 <Igloo> Hmm, it would be nice to propose a patch for the unix package in that case
09:37:35 <twb> Why am I still here?
09:37:37 --- part: twb left #haskell
09:37:47 <glguy> > let poly_eval = flip foldl 0 . (((+) .) . (*)) in poly_eval 3 [2,2,1]
09:37:49 <lambdabot>  25
09:38:16 --- quit: der_igel (Read error: 104 (Connection reset by peer))
09:39:43 <mauke> ikegami--: you could use hsc2hs
09:40:14 <chessguy> glguy:  that's a nice one
09:40:18 <sioraiocht> zomg TOO MANY EMAILS
09:40:23 <chessguy> took me a minute to figure out what you were doing
09:40:25 <sioraiocht> ...wrong window
09:40:26 <sioraiocht> sorry
09:40:41 <int-e> @pl \x l -> sum (zipWith (*) (repeat x) l)
09:40:42 <lambdabot> (sum .) . zipWith (*) . repeat
09:40:43 <chessguy> (and i still have no idea how it works)
09:41:07 <int-e> argh
09:41:31 <chessguy> @type (sum .) . zipWith (*) . repeat
09:41:34 <lambdabot> forall a. (Num a) => a -> [a] -> a
09:41:44 <glguy> > let poly_eval x cs = foldr ((. (* x)) . (+)) 0 cs in poly_eval 3 [1,2,2]
09:41:46 <lambdabot>  25
09:41:46 <int-e> repeat is wrong anyway.
09:41:58 <quicksilver> I"m still not happy enough with the (f .) . g . h idiom to use it in real code
09:42:06 <quicksilver> I suppose it's all familiarity and subjective
09:42:09 <ikegami--> mauke: thanks, now I'm looking the manual of hsc2hs
09:42:15 <int-e> @pl \x l -> sum (zipWith (*) (repeat iterate (x*) 1) l)
09:42:16 <lambdabot> (sum .) . zipWith (*) . flip (repeat iterate . (*)) 1
09:42:21 <quicksilver> but I'm quite happy with f x . g y . h z
09:42:25 <quicksilver> and don't much like (f .) .
09:43:09 <mauke> ikegami--: basically, you use stickyMode = #{const S_ISVTX}
09:43:20 <ski_> :t \x -> repeat iterate x
09:43:23 <lambdabot>     Couldn't match expected type `t1 -> t'
09:43:23 <lambdabot>            against inferred type `[(a -> a) -> a -> [a]]'
09:43:36 <araujo> morning
09:43:42 <quicksilver> actually, in general, I suppose I'm not all that happy with pointfree forms which take more than one paramter in any but the most obvious way
09:44:15 <chessguy> araujo!
09:44:22 <araujo> chessguy, hola!
09:44:29 --- join: PupenoR (n=pupeno@2002:c87b:b75b:0:240:f4ff:fe6b:7650) joined #haskell
09:44:33 <chessguy> que hay?
09:44:59 <glguy> I generally dont use pointfree code like the above outside of #haskell
09:45:01 <chessguy> @type (f .) .
09:45:03 <lambdabot> parse error (possibly incorrect indentation)
09:45:12 <chessguy> @type (?f .) .
09:45:15 <lambdabot> parse error (possibly incorrect indentation)
09:45:20 <glguy> ?type ((f .) .)
09:45:23 <lambdabot> Not in scope: `f'
09:45:26 <ski_> :t \f -> ((f .) .)
09:45:29 <lambdabot> forall b c a a1. (b -> c) -> (a1 -> a -> b) -> a1 -> a -> c
09:45:32 <quicksilver> chessguy: (f .) . composes in the second paramter, in some sense
09:45:35 <araujo> chessguy, no mucho ... despertandome :-)
09:45:40 <vincenz> @pl \f -> ((f .) .)
09:45:41 <lambdabot> (.) . (.)
09:45:50 <vincenz> araujo: hola, que tal
09:45:52 <quicksilver> tis the famous boobie combinator
09:45:56 <araujo> vincenz, hola!
09:46:04 <chessguy> @quote casado
09:46:05 <lambdabot> chessguy says: mejor cansado que casado!
09:46:06 <vincenz> de donde eres?
09:46:10 <araujo> haha
09:46:13 <ikegami--> mauke: aha, very short!
09:46:20 <araujo> vincenz, venezuela :-)
09:47:11 <vincenz> me gusta isla marguertia
09:47:53 <glguy> ugh, I can't focus today
09:48:04 <glguy> I think that my allergy medicine is affecting me
09:48:11 <chessguy> vincenz cree que puede conversar con nosotros :)
09:48:27 --- join: ddarius (n=Derek@208.180.182.107) joined #haskell
09:49:28 <araujo> vincenz, haha
09:49:34 <araujo> vincenz, have you been there?
09:49:41 <vincenz> araujo: indeed I have
09:49:45 --- join: clanehin (n=clanehin@cpe-069-134-236-134.nc.res.rr.com) joined #haskell
09:49:48 <araujo> Remember we have #haskell.es
09:49:52 --- join: eamelink (i=eamelink@opaal.eamtec.nl) joined #haskell
09:49:54 <vincenz> chessguy: I thought you didn't know me
09:50:46 <araujo> vincenz, hah, nice
09:52:26 <chessguy> vincenz: i don't
09:52:50 <vincenz> Then refrain from the personal comments
09:52:51 <vincenz> :)
09:53:37 <ikegami--> mauke: it works. thanks. I prefer to hsc2hs
09:53:57 --- quit: johnnowak ()
09:55:44 --- join: russo_ (n=russo@dslb-088-073-104-153.pools.arcor-ip.net) joined #haskell
09:56:55 --- quit: sioraiocht ()
09:59:33 <Igloo> Does anyone know a pwd-equivalent for cygwin that will give a path starting c:/?
10:00:03 <vincenz> \cygdrive\c
10:00:03 <vincenz> ?
10:00:14 <vincenz> something to that extent
10:00:21 <ndm> Igloo: can't you write one in haskell in about a line?
10:00:40 <ndm> i had to re-implement which in Haskell, since the one that comes with cygwin always goes barmy for me
10:01:06 <Igloo> ndm: I guess I'll have to
10:01:19 <vincenz> Igloo: oh sorry, I misinterpreted your question, I thought you were asking where c:/ was located in cygwin
10:01:27 * ndm thinks a complete set of console utilities in Haskell would be handy
10:01:55 <ndm> i currently use unix-tools, but a haskell reimplementation of most would be trivial
10:02:22 <ndm> is there any way to create a NaN in haskell without divide by zero?
10:02:39 --- quit: russo (Connection timed out)
10:02:41 <ndm> or alternatively, are there any other predefined Haskell values which have Ord which isn't a proper ordering?
10:05:54 <Igloo> ndm: Why without division by zero?
10:06:12 --- join: MarcWeber (n=marc@pD9E0BED3.dip.t-dialin.net) joined #haskell
10:06:15 <ndm> Igloo: catch models division by zero as a pattern match failure
10:06:19 <ddarius> sqrt (-1)
10:06:22 <emu> > (1/0) < 1
10:06:23 <lambdabot>  False
10:06:23 <ndm> break2 = sizeFM $ delFromFM (unitFM nan ()) nan
10:06:25 <ndm>     where nan = 0 / 0
10:06:34 --- join: delYsid (n=user@debian/developer/mlang) joined #haskell
10:06:36 <int-e> > let x = 2**100000; y = 3**10000 in x-y
10:06:37 <lambdabot>  NaN
10:06:41 <doserj> > sqrt (-1.0)
10:06:42 <lambdabot>  NaN
10:06:43 <ndm> Igloo: that above example causes finite map to crash with a pattern match error
10:06:51 <int-e> > let x = 2**100000 in x-x -- tsk, gets optimized to 0.
10:06:52 <lambdabot>  0.0
10:07:12 <ndm> doserj: hmm, thats still not great (catch demands non-negative for square root), but may be better
10:07:50 * ndm likes the fact that he can crash FiniteMap :)
10:08:26 <ddarius> Oh, ndm.  One thing that struck me is that it seems that you should be citing quite a bit of abstract interpretation work.
10:08:46 --- join: sioraiocht (n=rtharper@syru197-007.syr.edu) joined #haskell
10:08:51 <ndm> ddarius: ah, quite possibly - do you have any particular reference for Haskell/functional languages?
10:09:30 <ndm> there is plenty of strictness stuff, but i haven't seen anything on shape analysis or anything in a functional language
10:09:40 <ddarius> ndm: The only paper I can think of off hand that I think directly uses Haskell and abstract interpretation is too specific for you (I think it's a strictness analysis thing.)
10:09:52 <ddarius> Exactly.
10:09:56 <ndm> ddarius: if you have the name of that paper, i can follow up its references
10:10:14 <ndm> ddarius: probably worth mentioning strictness analysis in the paper anyway, as it is _the_ analysis for haskell
10:10:41 <ddarius> For abstract interpretation in general you could, among others, cite Cousot Cousot.
10:11:02 <ddarius> Actually, I think there's a paper that relates type checking and abstract interpretation that may use Haskell or another functional language.
10:11:13 --- join: savor (n=savor@unaffiliated/savor) joined #haskell
10:11:38 <ndm> ddarius: remember anything names/authors of that?
10:12:25 <ddarius> I think I may be able to find it.  I only have about 20 more minutes, so if I don't find it now I'll email or @tell you it if I find it later.
10:13:02 <ddarius> Cousot & Cousot paper if you want to cite that http://www.di.ens.fr/~cousot/COUSOTpapers/POPL77.shtml
10:13:05 <lambdabot> Title: P. Cousot & R. Cousot, Abstract interpretation: a unified lattice model for stat ...
10:13:38 <ndm> ddarius: thanks :)
10:14:10 <ndm> i read the neilsen*2 and hankin book on static analysis - so i know plenty of static anlaysis, but it does definately need a citation for abstract analysis
10:14:46 --- quit: prb ()
10:14:56 --- join: seancorfield (n=seancorf@corp.macromedia.com) joined #haskell
10:15:15 <ski_> not (diagonal . map diagonal . transpose = diagonal . map diagonal)
10:17:00 * sioraiocht o.O
10:17:10 --- join: Excedrin_ (i=Excedrin@gateway/tor/x-f5038aedc9ee62e3) joined #haskell
10:17:43 <ddarius> ndm: http://www.haskell.org/haskellwiki/Research_papers/Compilation#Strictness probably includes the paper I was thinking of for strictness analysis, if not it definitely includes some.
10:17:46 <lambdabot> Title: Research papers/Compilation - HaskellWiki, http://tinyurl.com/yst9wl
10:18:13 --- join: whaleofconfusion (n=whaleofc@pool-151-203-148-154.wma.east.verizon.net) joined #haskell
10:18:28 --- join: mnislaih (n=pepe@81.202.139.46) joined #haskell
10:18:35 <ndm> ddarius: thanks
10:18:49 <ndm> it also has one on strictness analysis
10:19:07 <ski_> @check let diag ((a:_):ass) = a : diag (map tail . takeWhile (not . null) $ ass); diag _ = [] in \asss -> (diag . map diag . transpose $ asss) == (diag . map diag $ asss :: [Int])
10:19:09 <lambdabot>  Falsifiable, after 13 tests: [[[-5,-7,-4,-1,1,7,5],[]],[[-4,-7,-3,-2,-1],[-7...
10:19:19 --- join: monochrom (n=trebla@toronto-hs-216-138-220-146.s-ip.magma.ca) joined #haskell
10:19:32 --- join: acpx (n=ac@s55920c51.adsl.wanadoo.nl) joined #haskell
10:20:17 <ski_> this is why the (potentially finite) stream monad is not commutative
10:20:51 --- join: sebell (i=sebell@nat/ibm/x-80ad8fd1d4c4f0fa) joined #haskell
10:20:54 <ddarius> http://www.di.ens.fr/~cousot/COUSOTpapers/POPL97.shtml
10:20:55 <lambdabot> Title: P. Cousot, Types as Abstract Interpretations
10:21:27 <ddarius> I haven't read this, but it may also be good, it uses ML http://citeseer.ist.psu.edu/602127.html
10:21:31 <lambdabot> Title: An Experiment in Type Inference and Veri (ResearchIndex)
10:22:07 <ndm> ddarius: perfect
10:22:15 <mattam> its mostly unreadable
10:22:22 <ddarius> Anyways, I'm off.
10:22:24 <ndm> ddarius: a recent paper, on a functional language - i'll definately cite it - i may read the abstract ;)
10:22:49 <ddarius> Types as Abstract Interpretation is pretty relevant and uses the (eager) lambda calculus.
10:23:24 <ndm> neat, thats a good one
10:23:44 <mattam> really this one shouldn't be referenced, just have a look at it :)
10:24:03 <ski_> ddarius : hm, which paper was about strictness analysis ?
10:24:09 <mattam> if you have to explain it you will be in deep trouble
10:24:32 --- quit: sabakas1 (Remote closed the connection)
10:24:51 <ndm> mattam: i'll take a brief look, but you never have to explain a reference in a conference paper
10:25:15 <ndm> in a thesis its a different matter
10:25:18 <mattam> well, you may have to if you meet cousot
10:25:39 <ndm> hehe, i'm sure he understands his paper ;)
10:25:41 <mattam> that's what i meant
10:25:52 <mattam> yeah, exactly :)
10:25:56 --- join: sabakas1 (n=solapus@66.90.121.129) joined #haskell
10:26:55 <ndm> i'll print a copy now, and see if it does the goods or not
10:27:23 --- quit: swiert ()
10:28:45 --- quit: Excedrin (Remote closed the connection)
10:29:57 --- quit: kosmikus ("leaving")
10:30:01 --- quit: gh_ (Remote closed the connection)
10:31:55 --- join: prb (n=prb@c-24-22-188-196.hsd1.mn.comcast.net) joined #haskell
10:31:57 <phoniq> what's the emacs setup of choice for haskell?
10:32:15 <phoniq> haskell-mode with shim?
10:40:32 --- quit: eamelink ("Leaving")
10:41:28 <emu> how is shim doing
10:42:32 <ndm> mattam: that paper is entirely impenetrable, it just goes silly quite quicly
10:43:20 <mattam> indeed
10:43:36 <ndm> i'll cite the older one, at least that made sense
10:43:43 <ndm> this one may be some cryptic code for a joke
10:44:05 --- quit: ddarius (Read error: 110 (Connection timed out))
10:44:05 <monochrom> try to know the content of what you cite. maybe you don't read it directly but you have to learn its content from somewhere.
10:44:13 <mattam> well, it's surely a code for "all your types are belong to us"
10:44:56 <mattam> submitting to ICFP ?
10:45:20 <monochrom> e.g., one may cite the original monad papers, never read it but learned monad somewhere else.
10:47:15 <monochrom> There is a joke among the community of digital signal processing.  Everyone cites the original paper that gave the fast fourier transform algorithm, but how many have read it :)  They all learned the algorithm from textbooks written after that paper.
10:47:23 --- quit: vincenz ("leaving")
10:47:23 --- quit: ekidd ()
10:47:38 --- join: vincenz (n=vincenz@pc-david.dacya.ucm.es) joined #haskell
10:47:41 --- quit: chris2 ("Leaving")
10:48:08 --- nick: vincenz -> [vincenz]
10:49:06 <monochrom> Cousot's papers and talks are quite cryptic.  Dialogues in person are normal.  Someone who has met him told me this.
10:49:19 <mattam> it is certainly best this way. source papers are as often badly written as others in my small experience
10:50:03 --- join: stepcut (n=user@ip68-107-76-154.sd.sd.cox.net) joined #haskell
10:50:34 <mattam> man, ghc takes ages to compile
10:51:09 --- join: dfeuer (n=topolog@wikimedia/Dfeuer) joined #haskell
10:53:11 <monochrom> The Cousot experience is quite surreal, I'm told.  Talks are cryptics but dialogues are fine.  So, you go to his talk, it's all unreadable math.  Then you ask a question, and suddenly he makes a lot of sense.  Then he continues the talk, and it's back to Martian.  The mode switch is quite surreal.
10:54:04 <mattam> Yes i've seen that happen :-)
10:54:59 --- join: dataangel (n=prophet@146.113.67.54) joined #haskell
10:55:16 <ndm> mattam: yes, i am submitting to ICFP
10:56:30 --- join: arjanb (i=borganis@borganism.student.utwente.nl) joined #haskell
10:56:34 <ndm> hmm, are there any Haskell types that are in Eq but not Ord?
10:56:52 <int-e> no.
10:56:56 <int-e> Ord requires Eq
10:57:09 <ndm> int-e: my question is the other way round
10:57:13 <mattam> The point is that he's the abstract one and his students do the concretion of his ideas somehow. That's how his course on AI is done: he does the theory, they show how it can be applied successfully (which require that you have grasped the theory too).
10:58:10 <int-e> ndm: hah. hmmm.
10:58:19 <bos> ndm: Bool?
10:58:27 <ndm> @instances Bool
10:58:28 <lambdabot> Couldn't find class `Bool'. Try @instances-importing
10:58:45 <ndm> bos: it is an instance of ord, for example the <= operator is implies ;)
10:58:52 <bos> oh, huh.
10:58:59 <int-e> ndm: Complex
10:59:06 <monochrom> "haskell types" as in those provided by the standard?
10:59:18 <bos> yes, looks like all standard types in Eq are also in Ord
10:59:28 <bos> even () is in Ord, which is just weird.
10:59:36 <bos> > () > ()
10:59:38 <lambdabot>  False
10:59:47 --- join: ddarius (n=Derek@208.180.182.107) joined #haskell
10:59:51 <ndm> int-e: well found, thanks :)
11:00:03 <mattam> so you can sort lists of units :)
11:00:08 <ndm> int-e: is that the only one?
11:00:24 <bos> Complex is a bit different because it's a typeclass
11:00:36 <hpaste>  LPhas pasted "(no title)" at http://hpaste.org/1198
11:00:52 <monochrom> If you allow the FFI, certain pointer types are Eq but not Ord
11:00:52 <mattam> Option has one ?
11:01:11 <mattam> err Maybe
11:01:12 <ndm> monochrom: thats a good one, comlex numbers are quite difficult
11:01:59 <monochrom> Oh damn I misread, the pointer types are Ord.
11:02:54 <monochrom> But yeah, Complex Double is Eq but not Ord.
11:02:55 --- quit: michiel (Remote closed the connection)
11:02:56 <int-e> ndm: it's the only one I can think of (aside from obvious derivatives like [Complex] or Array i Complex)
11:03:10 <ndm> int-e: thanks
11:04:06 <monochrom> Handle is Eq and not Ord :)
11:04:14 <int-e> (and I realize that Complex is missing a type argument there)
11:04:14 * monochrom is doing an exhaustive search :)
11:04:31 <Botje> exhausted eyt?
11:04:49 --- quit: roconnor (Read error: 104 (Connection reset by peer))
11:04:55 <monochrom> IOException
11:04:56 <ndm> i'm just doing an exhaustive hoogle database manip
11:05:15 <Cheery> do you guys have some method for chaining things? like: a ++ b ++ c, without the (++)s
11:05:25 <kpreid> Cheery: concat
11:05:43 --- join: meester (n=meester@a80-100-23-153.adsl.xs4all.nl) joined #haskell
11:05:49 <kpreid> Cheery: most operators have list versions when appropriate
11:05:50 <dataangel> Is there a good explanation somewhere of haskell's memory model? Like how long does it keep the results of lazy evaluation of a list before it drops it to let it be recomputed the next time it comes up, etc.?
11:06:21 <kpreid> ndm: IORef is Eq but not Ord
11:06:39 <ndm> i have a list now, i'll just post it
11:07:08 <monochrom> Fun.
11:07:46 --- join: Orphi (n=chatzill@host86-130-27-118.range86-130.btcentralplus.com) joined #haskell
11:08:38 * monochrom is an organic Hoogle :)
11:08:49 <dataangel> brb
11:08:50 --- quit: dataangel (Remote closed the connection)
11:09:10 --- quit: dfeuer (No route to host)
11:09:11 <Orphi> is there a way to make GHCi / a GHC-compiled program crash if it uses for than X bytes of RAM?
11:09:37 <Orphi> I just ran a program and it almost killed my PC by exhausting all available virtual memory :-}
11:09:52 <sieni> well, I guess the program just aborts if it runs out of memory
11:10:03 <monochrom> Yes. There is a way of "+RTS something" to say the heap must never exceed X.
11:10:21 <Orphi> I see... any idea what the 'something' is?
11:10:25 --- join: bluestorm_ (n=bluestor@mna75-1-81-57-39-150.fbx.proxad.net) joined #haskell
11:10:25 <kpreid> Orphi: or you could use your OS's memory limit
11:10:29 * Orphi starts flicking through the GHC manual
11:10:29 --- join: wy (i=wy@rrdhcp216-537.redrover.cornell.edu) joined #haskell
11:10:33 <ndm> http://neilmitchell.blogspot.com/2007/03/eq-but-not-ord.html
11:10:35 <lambdabot> Title: Neil Mitchell's Haskell Blog: Eq but not Ord
11:10:38 <sieni> Orphi: what about ulimit -v?
11:10:47 --- nick: Excedrin_ -> Excedrin
11:11:05 <Orphi> what's ulimit?
11:11:20 <Excedrin> -M<size> Sets the maximum heap size (default unlimited)  Egs: -M256k -M1G
11:11:23 <wy> I'm trying to switch to Windows version of Haskell. But I got the error the 'impossible' happens when I tried to run the program wrote in Linux
11:11:47 <Orphi> Excedrin: ah... that sounds like what I want.
11:12:01 <Excedrin> ./somebinary +RTS '-?' will spit out all of the valid RTS options
11:12:12 <Orphi> also worth knowing :)
11:12:29 <Orphi> FWIW... I did a sorting benchmark
11:12:39 <Orphi> quicksort took 500 ms... insertion sort almost killed the PC o_O
11:12:58 <ndm> wy: from the compiler? can you give the full error message
11:13:00 <ndm> @paste
11:13:01 <lambdabot> Haskell pastebin: http://hpaste.org/new
11:13:01 <monochrom> Thou hast very leaky insertion sort indeed.
11:13:10 <Orphi> er... yeah
11:13:13 <wy> I'm wondering if it's possible to use Haskell under Windows
11:13:14 <ndm> wy: ^^^ paste it if its too long
11:13:21 <ndm> wy: yes, i do all the time, and am right now
11:13:27 <Orphi> I'm not completely convinced I shouldn't have used the strict version of fold...
11:13:31 --- join: kowey (n=kowey@4aa54-4-82-234-151-151.fbx.proxad.net) joined #haskell
11:13:31 <wy> : panic! (the 'impossible' happened)
11:13:31 <wy>   (GHC version 6.6 for i386-unknown-mingw32):
11:13:31 <wy> 	loadObj: failed
11:13:31 <ndm> wy: Haskell is 100% supported on windows
11:13:50 <ndm> wy: is that running a linux binrary? or compiling?
11:13:59 <ndm> wy: how do you provoke that?
11:14:06 <wy> I'm using emacs and running ghci just on the source
11:14:33 <Orphi> I don't have the source with me, but it was something like > isort = foldl insert []
11:14:47 --- join: dataangel (n=prophet@146.113.67.54) joined #haskell
11:14:49 <wy> ndm, I'm wondering if my set up is wrong. I just unzipped the package of ghc6.6
11:14:58 <ndm> wy: why not use the installer?
11:15:03 <Jaak> @src sort
11:15:04 <ddarius> :t insert
11:15:04 <lambdabot> sort = sortBy compare
11:15:06 <lambdabot> forall a. (Ord a) => a -> [a] -> [a]
11:15:08 <ndm> thats what i do, and its very reliable
11:15:25 <wy> ndm, Maybe I should try the installer
11:15:29 <ddarius> > foldl' insert [] [100,99..0]
11:15:29 <Jaak> @src sortBy
11:15:30 <lambdabot>      Occurs check: cannot construct the infinite type: a = [a]
11:15:30 <lambdabot>       Expected...
11:15:31 <lambdabot> sortBy cmp = foldr (insertBy cmp) []
11:15:36 <Jaak> there
11:15:42 <wy> ndm, does it set some environment variable other than PATH?
11:15:47 <sioraiocht> okay
11:15:55 <ndm> wy: no
11:16:00 --- quit: chessguy ("Leaving")
11:16:04 <sioraiocht> ghci runs my code, but when i try and compile, i get
11:16:05 <sioraiocht> usr/bin/ld: Undefined symbols:
11:16:05 <sioraiocht> _stmzm2zi0_ControlziMonadziSTM_check_closure
11:16:06 <ndm> wy: but it may play with the registry slightly, although i didn't think so
11:16:08 <sioraiocht> ...why?
11:16:17 <ndm> sioraiocht: did you pass --make ?
11:16:40 <sioraiocht> no...
11:16:43 <Orphi> anyhow... a while back a wrote a quicksort that swaps to insert sort when the list becomes "small"
11:16:48 <wy> ndm, I'm installing
11:16:54 <Orphi> but my mistake: using the length function ;)
11:16:57 <sioraiocht> and it's just one script, with 3 imports
11:17:09 <sioraiocht> ndm: that worked
11:17:14 <sioraiocht> ndm: what does that do?
11:17:26 <Saizan> it links the packages you imported in the binary
11:17:29 <sioraiocht> ah
11:17:34 <ndm> sioraiocht: that makes it link properly, always do --make (Yhc is always in --make mode)
11:17:50 <int-e> Orphi: merge sort works better for linked lists
11:18:16 <Orphi> int-e: I had expected this... but a benchmark showed it as SLOWER than quicksort... for no obvious reason
11:18:25 <ski_> > foldl' (flip insert) [] [100,99..0]
11:18:26 <lambdabot>  [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,2...
11:18:27 <mightybyte> @src FilePath
11:18:28 <lambdabot> type FilePath = String
11:18:58 <Orphi> @src Data.List.sort
11:18:58 <lambdabot> Source not found. I've seen penguins that can type better than that.
11:19:05 <Orphi> ...?! o_O
11:19:07 <sioraiocht> thanks guys, I'm not used to compiling my code :)
11:19:22 <wy> ndm, the same problem...
11:19:34 <wy> ndm, do you use emacs ?
11:19:42 <ndm> wy: no, i use textpad and winhugs
11:19:50 <ndm> wy: does it work when you run things from the command line?
11:20:33 <wy> ndm, I haven't tried yet
11:21:02 <wy> ndm, too bad. emacs froze
11:21:24 <ndm> wy: try the command line, if it seems to not be Emacs fault, then report it as a bug
11:21:28 <sioraiocht> is there anyway I get a function to loop forever so that its thread doesn't die?
11:21:32 <ndm> possibly report it as a bug anyway
11:21:37 <ddarius> ndm: The relevance of the Eq not Ord... ?
11:21:44 <Saizan> ?src forever
11:21:44 <lambdabot> Source not found. The more you drive -- the dumber you get.
11:21:48 <ndm> ddarius: I can crash FiniteMap
11:21:58 <ndm> instance Ord Errno where compare _ _ = EQ
11:22:00 <ndm> break3 = sizeFM $ delFromFM (unitFM (Errno 1) ()) (Errno 2)
11:22:01 <Cheery> why does it yell when I do something like this? > instance StyleElement [Import] where
11:22:05 <mightybyte> Is it possible to use guards to tokenize strings?
11:22:15 <Cheery> class StyleElement a
11:22:17 <Saizan> sioraiocht, just call it again at the end
11:22:22 <monochrom> You can get a function to block forever so that its thread doesn't die.  Create an MVar and wait on it.
11:22:26 <ndm> ddarius: you just have to prevert the Ord function, and the example is shorter if you don't have to introduce a new data type
11:22:38 <monochrom> block forever is cheaper than loop forever
11:22:47 <Cheery> So, why can't I give such instance of my class StyleElement for a list of type Import?
11:22:55 <ndm> anyway, me off home - bye
11:22:58 <sioraiocht> Saizan: it forks off threads, I want 20, not an infinite number ;)
11:23:36 --- quit: ndm ("Chatzilla 0.9.77 [Firefox 2.0.0.3/2007030919]")
11:24:31 --- join: longarms2 (n=jumperjm@A027243.N1.Vanderbilt.Edu) joined #haskell
11:24:31 <Orphi> Cheery: AFAIK, you can write an instance for ALL lists, not just not for one specific type of list...
11:24:50 --- quit: obsethryl (Read error: 110 (Connection timed out))
11:24:53 * Orphi waits to be contradicted
11:25:13 <ddarius> If you do, you can't make an instance for any particular list of X
11:25:40 <Cheery> > instance StyleElement a => StyleElement [a] where
11:25:41 <lambdabot>  Parse error
11:25:49 <Cheery> that works.
11:26:00 <Cheery> but it does not do exactly what I'm looking for
11:26:24 <Cheery> Import requires to be handled differently than say, other instance of the same class
11:26:51 <Saizan> mmh, what's the error?
11:27:13 <Cheery> Illegal instance declaration for `StyleElement [Import]'
11:27:27 <Cheery> (The instance type must be of form (T a b c)
11:27:36 <Cheery> where T is not a synonym, and a,b,c are distinct type variables)
11:27:36 <Cheery>     In the instance declaration for `StyleElement [Import]'
11:27:39 <Orphi> instance Foo (Tree a) where  -- should work
11:27:49 <Orphi> instance Foo (Tree Int) where  -- wont' work
11:27:50 --- join: SyntaxNinja (n=ijones@gw-1.galois.com) joined #haskell
11:28:11 <Cheery> Orphi: why?
11:28:26 <Orphi> that's apparently how the rules work
11:28:26 --- quit: wy ("Leaving")
11:28:30 <Orphi> if I'm remembering this right...
11:28:43 <Saizan> i think it's a restrictive rule to make type inference decidable
11:28:49 <Saizan> or something like that
11:29:07 <Saizan> have you tried with -fglasgow-exts?
11:29:07 <Orphi> in fact yeah - it says in right there in the error message; T a b c, where a, b and c are type VARIABLES, not specific types
11:29:23 <Orphi> you'll probably have to play with newtype :(
11:29:24 <Cheery> tried, said same
11:29:48 <Orphi> newtype Foo = Bah Int      and then        instance Thing Bah    might work
11:30:03 <Cheery> are you sure?
11:30:10 <Orphi> no
11:30:12 <Orphi> lol
11:30:12 <Saizan> instance Thing Foo
11:30:15 <jyasskin> Cheery: You may want -fundecidable-instances (or one of the other two -fblah-instances flags)
11:30:35 --- quit: jgrimes_ ("Leaving")
11:30:41 <Orphi> ...uh, yeah, what Saizan said :$
11:30:43 <Cheery> heha, maybe that Foo -thing goes. :)
11:31:46 <Orphi> so in your case, it's... let me see.... newtype ListImport = [Import], and then instance StyleElement ListImport where...
11:32:15 <Orphi> gah... newtype ListImport = MkListImport [Import]
11:32:24 <Saizan> but it's quite ugly
11:32:28 <Orphi> indeed
11:32:36 <Saizan> -fallow-undecideable-instances ftw
11:32:44 <Cheery> unnamed.lhs:25:21: parse error in data/newtype declaration
11:32:50 <Orphi> and it won't magically make [Import] behave differently; you have to manually tag on MkListImport to get the different behaviour.
11:32:51 <Saizan> s/undecideable/undecidable/
11:33:17 <Orphi> otherwise, yeah, bring on the experimental type system extensions! :-}
11:33:24 <Cheery> :P
11:33:55 <Cheery> {-# OPTIONS -fallow-undecideable-instances #-}
11:33:59 <jyasskin> Cheery: You can also say (roughly) class HasListStyleElement ; instance HasListStyleElement Import; instance HasListStyleElement a => StyleElement [a] where ...;
11:34:05 <Orphi> hmm... rank-2 polymorphism, multiparameter type classes, functional dependencies, GADTs, polymorphic components, existantial quanitification...
11:34:08 * Orphi feels ill
11:35:15 <Orphi> ...now that's what I call thinking! heh
11:35:15 <Saizan> MPTC are in mtl, i won't count them as "experimental" or anything
11:35:31 <Cheery> except the option -thing does not fix it
11:35:33 <Orphi> mtl?
11:35:40 <jyasskin> See http://www.haskell.org/ghc/docs/latest/html/libraries/base/Text-Printf.html#t%3AIsChar
11:35:42 <lambdabot> http://tinyurl.com/2gflfv
11:35:55 <Saizan> Orphi: Control.Monad and co.
11:36:21 --- quit: Laney ("( www.nnscript.de :: NoNameScript 4.02 :: www.XLhost.de )")
11:36:21 <Orphi> to me, anything not in Haskell 98 is "experimental" ;)
11:36:31 <Orphi> let's face it, Haskell 98 is pretty powerful on its own...
11:36:43 <jyasskin> Particularly the "instance IsChar c => PrintfArg [c]"
11:37:19 * Orphi destroys a priceless ELO classic with his bad singing
11:37:25 <Cheery> I think I stop hitting myself to head with a keyboard and go on, it's not too big trouble to not be able to do that
11:37:30 <Saizan> Orphi: yeah, but it requires some strange class encoding like in this case
11:37:45 <Igloo> Orphi: Sure, and sed is Turing complete :-)
11:38:09 <Orphi> POV-Ray is Turing complete... I'm still trying to replace it's language with Haskell 98 ;)
11:38:32 <Cheery> Orphi: cool
11:38:50 <monochrom> Postscript can do ray-tracing.
11:39:02 <Cheery> I've been wondering in what sense it is turing complete
11:39:08 <Orphi> seriously... Haskell seems to attract bizzare type system extensions like anything. I've yet to see much explanation of what all this stuff is for!
11:39:40 <Orphi> Postscript can most certainly do ray-tracing. Now try to rasterise it on a HP LaserJet 6P...!
11:39:58 <Orphi> (the users weren't amused)
11:40:00 <monochrom> I think it's due to a combination of the two Simons and the one Oleg.
11:40:47 <Saizan> orphi, ofr example, if Monad was a MPTC we could have a Set monad
11:41:21 <monochrom> I now think the idea of type classes attracts lots of extension dreams.
11:41:41 <Orphi> I have a Haskell book here, and virtually everybody involved in its production works at Oxford Uni. I should get over there! lol
11:42:09 <monochrom> Study under Richard Bird. You will come out reborn.
11:42:22 <Orphi> 3 guesses who edited this book :P
11:42:53 <Orphi> and then 3 guesses what the book is... after all, the Haskell bookshelf is hasn't "large"
11:43:07 <Orphi> grr... my typing sucks tonight :(
11:43:16 --- quit: Ytinasni (Read error: 111 (Connection refused))
11:43:37 <ddarius> monochrom: It doesn't help that the Haskell masses swarm upon new extensions like vultures as soon as they are available.
11:44:10 --- quit: eddyp_ ("Leaving")
11:44:38 <Orphi> ...there are Haskell masses?
11:45:48 --- quit: bos (Read error: 110 (Connection timed out))
11:46:30 <Orphi> random question: if I somehow succeeded in writing a Haskell to Java compiler, would anybody care?
11:46:51 <monochrom> Haskell extensions are more conservative than other community's extensions. By this I mean the former receives quite some rigour while the latter are just based on delusive intuition. Consequently the mass feels more confident, and objective there is less grey area ==> less need to debate.
11:46:57 <ski_> Orphi : java or jvm bytecode ?
11:47:06 <Orphi> Java source
11:47:09 <monochrom> s/objective/objectively/
11:47:49 * SamB wonders why his system is writing to disk so much...
11:47:50 <Orphi> monochrom: I gather the Haskell' guys are currently debating FDs vs ATs
11:48:13 <SamB> Orphi: really?
11:48:21 <Orphi> apparently...
11:48:33 <SamB> I was kinda just waiting to get the chance to run them head to head ;-)
11:48:34 <Orphi> myself I like ATs more... but no one has ever implemented them
11:48:57 <Orphi> [...although if my Haskell to Java compiler ever happens... muhuhuhuh!]
11:49:14 <dino-> That thing I was talking about earlier, hideous Data.ByteStream.Char8.words performance. Seems like it all stems from the B.splitWith isSpace
11:49:15 <SamB> we have ATs, but ATs are not so great compared to AT synonyms
11:49:27 <dino-> If I change that to B.split ' ', tremendously faster.
11:49:35 <SamB> (only in GHC 6.7, mind you, but still...)
11:49:46 <SamB> and AT synoyms we haven't got yet
11:49:53 <SamB> I found that out the hard way
11:50:00 <monochrom> There are some debates. Note that the level is higher. We don't debate "should we have GC? should we have foldl?".  The Python people use only subjective intuition and therefore they debate obvious things, for example.
11:50:01 <Orphi> ...and again I'm feeling hopelessly lost...
11:50:04 <Saizan> AT?
11:50:12 <Saizan> ah, associated types?
11:50:16 <SamB> Saizan: yes
11:51:01 <jyasskin> Orphi: For jvm bytecode, yes. Being able to integrate with the large number of existing libraries there would be really handy.
11:51:13 <SamB> personally, I am in the "both for now" camp, but I'm fine with fundeps not being standardized for at least the near future
11:51:30 <Orphi> jyasskin: my plan was to make a program that dumps out Java source code
11:51:37 <Orphi> then you compile it with javac as normal
11:51:44 <SamB> (i.e., until we get a feel for what AT Synonyms let us do and what they do not let us do)
11:51:49 <Orphi> and if I can make a clean way to call existing Java code - and backwards...
11:52:11 <Saizan> i think there's yet some project to build to jvm bytecode
11:52:21 <SamB> Orphi: it is called the FFI
11:52:35 <Orphi> Saizan: yeah, probably...
11:52:49 <Orphi> my main motivation is to be able to experiment with running stuff an parallel and so on
11:53:06 <SamB> can't you already do that in Haskell?
11:53:13 <Orphi> SamB: I'll be very surprised if you can call *Java* with FFI
11:53:36 <monochrom> GHC threading may be more efficient than Java threading.
11:53:42 <SamB> Orphi: oh, well, you probably need to write an addendum to the FFI addendum
11:53:53 <SamB> to talk about the Java-specific aspects of it
11:54:08 <Orphi> SamB: I'm thinking more it's probably fundamentally impossible to call Java from *any* natively compiled language...
11:54:16 <SamB> heh
11:54:20 <kowey> Orphi: have you seen lambdavm? http://www.cs.rit.edu/~bja8464/lambdavm/
11:54:21 <SamB> of course it isn't
11:54:23 <lambdabot> Title: LambdaVM - The Haskell to Java Translator
11:54:33 <Orphi> nope
11:54:36 * Orphi checks it out
11:54:54 <SamB> anyway I was assuming you'd be doing this with your hs2java compiler
11:55:22 <SamB> that doesn't seem like a very nice name
11:55:27 <SamB> "lambdavm"
11:55:38 <SamB> it in no way indicates that JVM is involved
11:55:39 <Orphi> I was thinking "Haskell over Java" - HoJ
11:56:18 * SamB wonders whether JNI would permit calling Java from Haskell directly
11:56:44 * Orphi wonders what JNI is - and then quickly decides it's probably better not to know
11:56:45 <SamB> (that is, without having to have "main" implemented in Java)
11:56:45 --- quit: dolio (Read error: 104 (Connection reset by peer))
11:56:52 <SamB> Orphi: Java Native Interface
11:57:07 <SamB> that sounds kinda relevant, doesn't it?
11:57:15 <Orphi> I used to program stuff in Java... but it's just such an annoying language to use. heh.
11:57:21 <Orphi> so many flaws to work round
11:57:32 --- quit: tsmith__ ("Leaving")
11:57:37 <Orphi> I haven't kept up to date with the technology much
11:57:45 <SamB> well JNI is, afaik, a C API
11:58:11 <Orphi> I know you can call C (and probably others) *from* Java. I'd just be surprised if you can go the other way...
11:58:47 --- join: maskd (n=int@unaffiliated/maskd) joined #haskell
11:59:13 <Orphi> anyway, Haskell is a wonderful language, but there's an annoying amount of stuff it can't do.
11:59:18 <Orphi> Java can do most of that stuff
11:59:24 <Orphi> so if I could convert one to the other...
11:59:33 --- quit: mahogny (Read error: 60 (Operation timed out))
11:59:44 <phoniq> you can call java from c
11:59:56 <Orphi> [of course, whether this project will ever get beyond an early draft is another matter entirely. lol!]
12:00:01 <SamB> what can Java do that Haskell cannot do?
12:00:10 <Cheery> Orphi: there's an annoying amount of stuff you don't actually need when toying with haskell
12:00:25 <Orphi> well, let me see... graphics, sound, database access...
12:00:34 <Excedrin> SamB: run in a browser?
12:00:48 --- join: dolio (n=dolio@nr10-216-68-185-39.fuse.net) joined #haskell
12:00:49 <Cheery> sure, you lack those
12:00:53 <SamB> Excedrin: what browser does Java run in?
12:00:57 <SamB> Orphi: heh
12:01:07 <Excedrin> SamB: IE?
12:01:17 <Cheery> Orphi: but those who have them lacks higher level stuff from some reason
12:01:19 <SamB> sound might be nice
12:01:19 <Igloo> Orphi: Haskell has GLUT/Gtk2, ALUT, and various database libraries
12:01:26 <SamB> I'd like it if Linux would support that
12:01:38 <SamB> well, I mean, it can go boing and such
12:01:50 <SamB> maybe ALUT works
12:02:01 <Orphi> I'm currently attempting to survive Gtk2hs
12:02:05 <Orphi> it's very hard work
12:02:14 * SamB blames GTK
12:02:18 <Orphi> (mind you, GUI programming usually is...)
12:02:33 <Cheery> game deployment systems, proper web tools, proper UI programming tools, etc.
12:02:50 <SamB> I want Qt bindings so that gtk2hs will have some competition...
12:03:01 <SamB> Cheery: games? you don't write games in Java afaik.
12:03:06 <Orphi> I'm told somebody implemented Quake in Haskell... I don't know how that's physically possible ;)
12:03:17 <Igloo> SamB: What issues does gtk2hs have that you think cmpetition would solve?
12:03:17 <SamB> and what are "UI programming tools"?
12:03:18 --- join: procyon112 (i=Procyon@nat/microsoft/x-84894ca181f79786) joined #haskell
12:03:24 --- join: crathman_ (n=chatzill@69.15.198.171) joined #haskell
12:03:34 <Igloo> Orphi: Googling for frag Haskell should find it
12:03:39 <ski_> haskell can run in the browser at end of http://www.cs.chalmers.se/Cs/Research/Functional/Fudgets/demoform.html, iirc
12:03:42 <lambdabot> Title: Fudgets - Demo Form, http://tinyurl.com/yt4eg4
12:03:47 <Cheery> SamB: well, java has simple set of stuff you can use to describe GUIs
12:04:05 <Orphi> yeah, Ive seen the web page for frag; I still don't 'get' how it works.
12:04:07 <Cheery> but most other languages do have much more limited and primitive
12:04:12 <SamB> Igloo: well, the part where I feel resentful about not being able to compare it with Qt maybe.
12:04:32 <ski_> @where frag
12:04:32 <SamB> Cheery: explain it?
12:04:33 <lambdabot> http://www.haskell.org/haskellwiki/Frag
12:04:48 <hpaste>  Procyon112 pasted "Is there an idiom to simplify this?" at http://hpaste.org/1199
12:05:06 --- quit: crathman (Connection timed out)
12:05:11 --- nick: crathman_ -> crathman
12:05:12 <procyon112> Any pointers? ^^^
12:05:37 <Orphi> no - this is Haskell, not C
12:05:41 <Orphi> ;) ;)
12:05:42 <Cheery> SamB: Just swing yourself to tree with java and you'll see.
12:06:02 <Orphi> sorry about that... lol
12:06:21 <SamB> Cheery: you lost me at "swing"
12:06:39 --- quit: crathman (Client Quit)
12:06:42 <SamB> last I tried using programs that used that, it took a ton of RAM
12:06:49 --- join: pierre- (n=pierre@89.112.11.108) joined #haskell
12:06:51 --- join: lekro (i=lekro@pd9e0346f.dip0.t-ipconnect.de) joined #haskell
12:07:25 <SamB> procyon112: there is a sort of idiom
12:08:16 <procyon112> SamB: I figured there was :)
12:08:38 --- quit: Orphi ("Chatzilla 0.9.77 [Firefox 2.0.0.3/2007030919]")
12:09:01 <SamB> procyon112: but, you better handle the case where neither is simple *before* that part
12:09:12 <Cheery> the Yampa in that frag -thing seems to be the key point on making it reasonable to write a game on haskell
12:09:29 <Cheery> I guess I should look into it since I'm interested about doing games in general
12:09:51 --- join: ohmega- (n=ohmega@sonata.csbnet.se) joined #haskell
12:09:58 <procyon112> SamB: Yes.. I left that out.  I wanted to express the root of the question only.
12:10:02 <hpaste>  SamB annotated "Is there an idiom to simplify this?" with "a sort of idiom, maybe not so great *here*" at http://hpaste.org/1199#a1
12:10:19 <Cheery> uuh, arrows
12:10:21 <SamB> procyon112: the important part being to do that above this
12:10:49 <ddarius> There are plenty of ways of doing games in Haskell.  Games aren't especially special programs.
12:11:10 <sioraiocht> is there anyway to convert IO () to STM a
12:11:20 <procyon112> SamB: ahh... I figured the solution would be obvious ;)
12:11:25 <procyon112> SamB++
12:11:32 <ddarius> sioraiocht: Not safely.
12:11:34 <monochrom> arrows are not scary!
12:11:37 <Cheery> ddarius: do you know how many ways there has been used?
12:11:46 <sioraiocht> ddarius: thanks..
12:11:50 <Cheery> And what do they commonly involve?
12:11:52 <SamB> yeah, I think games are some of the least-special programs
12:12:08 <SamB> though I suppose if you have some kind of reasonable AI they are a lot more special
12:12:22 <ddarius> procyon112: You could also use case as well, but overall, there probably isn't a reason not to use your current version if the case analysis is this simple.
12:12:54 <ddarius> Cheery: You can more or less write them the way you would in any other language to begin with.
12:13:27 <Cheery> I don't know, you can do, but what's the point of doing it exactly like with imperative languages?
12:13:28 --- join: gh_ (n=gh@4va54-5-88-163-244-1.fbx.proxad.net) joined #haskell
12:13:40 <procyon112> ddarius: Case just moves the pattern match... doesn't really simplify the problem.  In my example, the call is simple enough to ignore factoring it out, but in my real problem, that call to "func" is actually a few lines of code.
12:13:45 <SamB> ddarius: the lack of global mutable state may have a dramatic effect on the style of the code
12:13:48 --- join: alec (i=alec@139.140.174.142) joined #haskell
12:13:53 <ddarius> Haskell tends to be nicer than them.
12:14:18 --- join: tizoc_[w] (n=user@r190-64-42-247.dialup.adsl.anteldata.net.uy) joined #haskell
12:14:19 <SamB> Cheery: Haskell lets you make your own imperative language to write your game in ;-P
12:14:21 <ddarius> SamB: If only Haskell was actually lacking global mutable state, but even without it that's not all that significant an effect.
12:14:31 <SamB> you can even use more than one, and they can be related
12:14:42 <Cheery> ddarius: well, it does so, but it amplifying if one finds out better ways while doing that :-)
12:14:44 <ddarius> procyon112: It leads to func x y being written only once.
12:15:09 <ski_> procyon112 : one possibility could be to factor out 'func', i.e. '.. where func x y = ..x..y..'
12:15:40 --- quit: doserj ("Leaving")
12:15:59 <ddarius> But I only mentioned that because there's nothing that makes programming games in Haskell harder than programming them in other languages, because at the very least you can program them the same way.
12:16:15 <Cheery> well, one thing does
12:16:30 <ddarius> Yampa and related FRP techniques often have (small) games as examples.
12:16:39 <Cheery> you require more from them, since after you've learnt haskell, you get a weird attitude
12:16:42 <procyon112> ski_: Yeah, I did that.  I'll paste the real code to give an example of how it scales up to messiness :)
12:16:43 <ddarius> There was a game writing library FunGen
12:17:05 <Cheery> FRP?
12:17:16 <ddarius> Functional Reactive Programming
12:18:25 <hpaste>  procyon112 annotated "Is there an idiom to simplify this?" with "Example of real world case" at http://hpaste.org/1199#a2
12:19:02 <Excedrin> is something like http://www.terracotta.org/ easy in Haskell?
12:19:03 <lambdabot> Title: Home - Open Terracotta - Terracotta
12:19:51 <Excedrin> (it's obviously easy in Erlang, and apparently possible with Java)
12:20:00 --- quit: sioraiocht ()
12:20:01 <Cheery> ddarius: what does it mean in practise?
12:20:53 <ddarius> Excedrin: What is it?
12:21:14 <ski_> procyon112 : i believe one often calls a simpler 'unifyVar :: Var -> Expr -> M Expr' (or whatever types you are using)
12:21:23 <ddarius> Cheery: Reify time, and process events as streams of signals, reacting to them.
12:21:48 --- join: GeoBes1 (n=root@ip72-195-130-215.ri.ri.cox.net) joined #haskell
12:21:56 --- quit: GeoBes1 (Client Quit)
12:22:29 <monochrom> There used to be GUM. It's GHC patched to spread over a cluster, i.e., Control.Parallel.par calls PVM to spawn a process elsewhere.
12:23:13 <Cheery> seems and looks like interesting.
12:23:26 --- quit: mnislaih ()
12:23:37 <Cheery> And, it actually looks like something I were going at myself on my own workbench :-)
12:23:43 <Excedrin> ddarius: distributed clustering stuff for Java, lets any Java app be distributed across a cluster
12:23:59 <Excedrin> I'd like to use CAL with Terracotta to get a sort of Haskell meets Erlang meets Java thing...
12:24:03 <hpaste>  ddarius annotated "Is there an idiom to simplify this?" with "my unify" at http://hpaste.org/1199#a3
12:24:18 <monochrom> The upshot was that the GUM people also came up with Control.Parallel.Strategies so you never call par yourself.
12:24:56 <hpaste>  procyon112 annotated "Is there an idiom to simplify this?" with "Prettier Code" at http://hpaste.org/1199#a4
12:24:59 <ddarius> @google Haskell Ports distributed
12:25:01 <lambdabot> http://citeseer.ist.psu.edu/479359.html
12:25:02 <lambdabot> Title: Implementation of Port-based Distributed Haskell - Huch, Stolz (ResearchIndex)
12:25:43 <Excedrin> that sounds great, is it usable?
12:26:19 <procyon112> ddarius++  Thanks... I'll look at that.
12:27:32 --- join: beelsebob (n=tatd2@82.152.206.196) joined #haskell
12:29:00 --- quit: Excedrin (Remote closed the connection)
12:29:17 --- quit: pierre- (Read error: 104 (Connection reset by peer))
12:30:37 --- quit: tizoc[w] (Connection timed out)
12:31:24 --- nick: tizoc_[w] -> tizoc[w]
12:31:34 --- join: Excedrin (i=Excedrin@gateway/tor/x-a13c362cfadb63c6) joined #haskell
12:34:32 --- join: abcde` (n=hello@host86-149-57-108.range86-149.btcentralplus.com) joined #haskell
12:37:05 <hpaste>  ddarius annotated "Is there an idiom to simplify this?" with "more complete code" at http://hpaste.org/1199#a5
12:40:02 --- join: LordBrain (n=jc@71.16.211.2) joined #haskell
12:40:02 --- join: JoshTriplett (n=josh@unaffiliated/joshtriplett) joined #haskell
12:40:33 <JoshTriplett> Does any good Haskell physics engine exist?  I've searched around, and I can't find anything other than hODE.
12:40:58 <JoshTriplett> (Not implying that hODE doesn't qualify as "good"; I just want to evaluate multiple options.)
12:41:58 <LordBrain> hmmmm
12:42:03 <Cheery> I've not found any
12:42:30 <LordBrain> i have only found version 1 of the FFI, is there any later relavent documents?
12:42:52 <Cheery> if you don't need it too soon, I'd propose you toy with the idea of doing it yourself
12:43:23 <LordBrain> maybe FFI 2 sneak peeks?
12:43:25 <LordBrain> haha
12:43:47 <SamB> LordBrain: that does seem to be the version you get to from http://haskell.org/haskellwiki/Definition
12:43:48 <lambdabot> Title: Language and library specification - HaskellWiki
12:43:48 <JoshTriplett> Cheery: Yeah, I thought about that.
12:44:28 <Cheery> JoshTriplett: what kind of physics stuff you'd need to do?
12:44:53 <sieni> We at #haskell don't pee on our hands. Thus: version 1 of the FFI is already perfect.
12:45:24 <JoshTriplett> Cheery: I've looked at Jiggle with an eye towards a Haskell implementation of those concepts.
12:45:33 <JoshTriplett> Cheery: I don't need deformable body physics.
12:45:45 <JoshTriplett> Cheery: Rigid bodies with some joints/constraints would do the trick.
12:45:46 --- join: Zr40 (n=Zr40@zr40.xs4all.nl) joined #haskell
12:45:57 <JoshTriplett> Cheery: And the ability to apply forces.
12:46:27 <Cheery> what kind of program you have which needs it all?
12:46:33 --- join: mnislaih (n=pepe@81.202.139.46.dyn.user.ono.com) joined #haskell
12:46:46 <monochrom> "Version 1" means "Version Right".
12:47:04 <JoshTriplett> Cheery: A few different applications.  I'd like to use it to write a rocket simulator, and I'd like to use it to implement a game idea I've had for a while.
12:47:11 <ski_> ddarius : bah, untyped :)
12:47:36 <Cheery> ic.
12:47:56 <LordBrain> this seems to be a good start page for FFI stuff http://haskell.org/haskellwiki/GHC/Using_the_FFI
12:47:56 --- join: digitaleric (n=eric@wireless.acm.jhu.edu) joined #haskell
12:47:58 <lambdabot> Title: GHC/Using the FFI - HaskellWiki
12:48:19 <JoshTriplett> Cheery: The fo