The REFC fingerprint allows vectors to be encoded into < 1316258351 218980 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :and decoded from single scalar cell values. < 1316258351 945545 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Gah < 1316258354 801266 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :oerjan: Point or Delta :-P < 1316258375 118442 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAaaaaaaaaaaaa < 1316258382 179106 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :why not just have points... < 1316258395 208277 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :and then special functions that treat one point as a delta. < 1316258403 283802 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :s/special// < 1316258408 116322 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric ::δ < 1316258417 291346 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Why don't we just have one type of data < 1316258420 789623 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :And functions that treat it specially < 1316258420 962787 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :itidus21: that's not what we usually call S < 1316258425 315613 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Oh right, because this isn't Tcl < 1316258434 518155 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :oops :Δ < 1316258447 698696 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :oerjan: ok sorry. < 1316258452 886286 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :yeah but they're essentially the same thing the only difference is that you have operations that have an operand that treats the point as a delta. < 1316258462 90734 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :itidus21: sadly greek letters count as letters, so no. < 1316258463 912691 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :yeah but they're essentially the same thing the only difference is that you have operations that have an operand that treats the string as a list. < 1316258468 590248 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :lol < 1316258502 190278 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :otherwise everyone would be using real λ in haskell by now < 1316258511 249463 :Taneb!~nathan@host-78-146-164-99.as13285.net JOIN :#esoteric < 1316258529 620702 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :(mappend :: Point -> Point -> Point) point delta < 1316258530 847278 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :bahahahaha < 1316258532 551599 :Taneb!~nathan@host-78-146-164-99.as13285.net PRIVMSG #esoteric :Hello! < 1316258570 609563 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :ho lle < 1316258575 68665 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :hmmm, booleans are monoids yes? < 1316258590 914279 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :CakeProphet: in four different ways :P < 1316258593 21408 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :but perhaps not in Haskell yes? < 1316258605 815280 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :oerjan: makes me wonder why there is no typeclasses for monoids like that. < 1316258611 845600 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :wait, six < 1316258613 836824 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :like a typeclass for &&, ||, etc < 1316258624 896523 :derdon!~derdon@p5DE88F13.dip.t-dialin.net QUIT :Remote host closed the connection < 1316258626 322456 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :what < 1316258636 627030 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :nevermind. < 1316258641 294107 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :basically I just don't like newtypes. < 1316258649 266065 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :and would prefer having Monoid classes with more than one mappend. < 1316258651 188124 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :&&, ||, /=, ==, const and const id are all monoid operations for Bool < 1316258667 42412 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :er wait < 1316258671 842310 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :um < 1316258672 365524 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :scratch those const ones < 1316258675 150196 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :isn't mempty `mappend` ... yeah < 1316258680 441566 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :they're just semigroups < 1316258700 52431 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :╔╦═══╗ < 1316258700 711336 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :╚╩═══╝ < 1316258709 522685 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :^celebrate < 1316258709 540670 :fungot!~fungot@momus.zem.fi PRIVMSG #esoteric : \o| |o| |o/ \m/ \m/ |o/ \o/ \o| \m/ \m/ \o| |o| |o/ < 1316258710 139388 :myndzi\!myndzi@c-67-168-184-168.hsd1.wa.comcast.net PRIVMSG #esoteric : |   |   |    `\o/´    |   |   |    `\o/´    |   |   | < 1316258710 211828 :myndzi\!myndzi@c-67-168-184-168.hsd1.wa.comcast.net PRIVMSG #esoteric : >\  |\  >\     |      >\ /'\ /`\     |     /'\  |\ /< < 1316258710 229891 :myndzi\!myndzi@c-67-168-184-168.hsd1.wa.comcast.net PRIVMSG #esoteric :               /'\                (_|¯`\ < 1316258710 230092 :myndzi\!myndzi@c-67-168-184-168.hsd1.wa.comcast.net PRIVMSG #esoteric :             (_| |_)                   |_) < 1316258720 744222 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :itidus21: i have no idea what haskell considers those chars as < 1316258730 238270 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :oerjan: box-drawing character duh. < 1316258732 819570 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :i just got inspired playing around with character map < 1316258741 233830 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :only useful for drawing boxes. < 1316258759 813198 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :CakeProphet: well yes but are they legal operator characters? :P < 1316258778 117865 :Taneb!~nathan@host-78-146-164-99.as13285.net PRIVMSG #esoteric :Somebody's made another brainfuck derivative < 1316258785 113223 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :does Haskell even allow Unicode aside from a few special cases? < 1316258785 360754 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :♫♪ ♫ < 1316258785 985602 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :> let a ╔ b = a + b in 2 ╔ 2 < 1316258786 718881 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric : 4 < 1316258790 910743 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :yay :P < 1316258799 240872 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :oh < 1316258800 669936 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :okay. < 1316258809 940797 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :haskell has full unicode support < 1316258818 610243 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :goood. < 1316258822 89155 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :> let æßð = "yes" in æßð < 1316258822 782347 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric : "yes" < 1316258825 780244 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :CakeProphet: at least ghc uses the unicode character classifications to decide. somehow. < 1316258843 510248 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :╔ is an operator that takes uh two.... uh... somethings and TURNS RIGHT, < 1316258849 45013 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :> let æßð = "yes"; (→) = const in æßð → "a" < 1316258849 745559 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric : : parse error on input ` < 1316258851 547812 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :sharply. < 1316258852 424058 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Aw. :/ < 1316258860 404840 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :> let æßð = "yes"; → = const in → æßð "a" < 1316258861 102037 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric : : parse error on input ` < 1316258862 847717 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric ::| < 1316258870 956492 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :you could also have it turn one thing right by being postifx. < 1316258904 473078 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :(car╔) < 1316258912 553553 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :> let a ▲ b = a + b in 2 ▲ 2 < 1316258913 586330 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric : 4 < 1316258946 899729 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :elliott: there you go, your delta-application function. :) < 1316258956 260028 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :obviously with type Point -> Delta -> Point < 1316258959 393568 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :where type Delta = Point < 1316258962 341530 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :It is cheerfully describes it as Black Up-Pointing Triangle < 1316258999 696240 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :cheerfully < 1316259021 506565 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :> let a ∆ b = a * b in 3 ∆ 5 < 1316259022 676443 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric : 15 < 1316259032 380685 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :thats another one < 1316259044 489413 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :> let x → y = x in 2 < 1316259045 187239 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric : : parse error on input ` < 1316259047 585751 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :cheerfully described as "Increment" < 1316259072 970613 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :> (sin :: Double → Double) 2 < 1316259073 667398 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric : 0.9092974268256817 < 1316259074 14071 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :now I just need a unicode keyboard so I can sanely program with these operators. < 1316259077 709792 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :ah. < 1316259091 398228 :Taneb!~nathan@host-78-146-164-99.as13285.net PRIVMSG #esoteric :My chair has speakers in it < 1316259099 838158 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :it wasn't illegal, just taken. < 1316259111 387361 :Taneb!~nathan@host-78-146-164-99.as13285.net PRIVMSG #esoteric :I am going to play some Queen music < 1316259113 42860 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :i didnt mean to define all of these things < 1316259124 606454 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :i hope im not making a mess of lambdabot < 1316259146 766243 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :haha... < 1316259165 566368 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :there should be a Haskell IDE or somesuch in which you can assign numpad keys to unicode characters < 1316259170 649650 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :itidus21: > let doesn't actually define things permanently < 1316259172 959608 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :with some kind of graphical bank displayed. < 1316259178 285890 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :oerjan: thats good < 1316259190 558522 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :at least i have kind of opened the possibility of the unicodes :D < 1316259198 349412 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :you need @let for ... slightly more permanent, but not really. < 1316259199 501521 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :beginning with my /\ tomfoolery < 1316259265 839805 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :also other nice features like automatically inserting type signatures, renaming functions globally across multiple files, etc. < 1316259285 599691 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :but the unicode bank would actually make unicode operators convenient < 1316259293 613882 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :my zanyness can come in handy < 1316259378 557476 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :today's http://www.mezzacotta.net/postcard/ has a nice disclaimer < 1316259490 543832 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :*(no, the picture is not broken) < 1316259507 985131 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :yes, it is < 1316259513 628710 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :depending on your definition of broken < 1316259532 766925 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :oerjan: only four more IWC strips left ;D < 1316259548 262660 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :^ul ((A)S:^):^ < 1316259548 438038 :fungot!~fungot@momus.zem.fi PRIVMSG #esoteric :AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA ...too much output! < 1316259613 488011 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :other Haskell IDE ideas: builtin (un)?pl, (un)?do, djinn, shell (which obviously includes ghci), hoogle, documentation viewer stuff < 1316259658 666065 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :CakeProphet: there is a way to plug lambdabot into ghci. ostensibly. < 1316259676 628156 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :ACTION starts pondering other potential uses of unicode characters. < 1316259701 337131 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :itidus21: maybe you could use them to write in strange languages < 1316259727 498554 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :oerjan: ah yes that would work I think. though also a source-code transform version of each would be neat. < 1316259742 92745 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :so you right-click on a type signature, run djinn, and it spits out a function definition < 1316259756 289220 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :right-click on a function and then transform via do/pl < 1316259765 362691 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :...more useful for do than pl < 1316259772 915682 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :oerjan: not really ostensibly, IIRC it's even maintained still. < 1316259773 997588 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :as you may not necessarily want what pl gives you. :P < 1316259781 747092 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :CakeProphet: djinn is not very useful in practice at all. < 1316259790 613580 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :eh, still < 1316259795 143629 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :I guess it's nice if you want to generate large swathes of the Prelude, but apart from that. < 1316259796 437896 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :if it ever does become useful in practice. < 1316259800 825128 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :"ever does"? < 1316259805 388479 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :..yes < 1316259808 450157 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :It's not some collection of hacks; it's a defined, immutable algorithm. < 1316259808 468060 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :like, if they improve it. < 1316259815 577959 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Do you know how djinn works? < 1316259820 616384 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :not specifically. < 1316259838 604311 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :"For the curious, Djinn uses a decision procedure for intuitionistic < 1316259838 780164 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :propositional calculus due to Roy Dyckhoff. It's a variation of < 1316259838 798026 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Gentzen's LJ system." < 1316259853 4897 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :It's just Curry-Howard. < 1316259868 417504 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :okay, but that's not to say it couldn't be improved. < 1316259873 809147 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :... < 1316259891 803464 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :You would like it to just make shit up if that fails? < 1316259910 690324 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :well no, but if it had access to more functions < 1316259914 921786 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :What. < 1316259923 235313 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :to plug in... in the correct place. < 1316259928 38247 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :I'm sure this makes sense. :P < 1316259968 350898 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :djinn does have a way to define data types. they just cannot be recursive. < 1316259974 331151 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :@list djinn < 1316259974 545091 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :djinn provides: djinn djinn-add djinn-del djinn-env djinn-names djinn-clr djinn-ver < 1316259978 275673 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :@djinn-env < 1316259978 528307 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :data () = () < 1316259978 546217 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :data Either a b = Left a | Right b < 1316259978 546372 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :data Maybe a = Nothing | Just a < 1316259978 546480 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :data Bool = False | True < 1316259978 546587 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :data Void < 1316259980 446255 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :type Not x = x -> Void < 1316259982 356129 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :class Monad m where return :: a -> m a; (>>=) :: m a -> (a -> m b) -> m b < 1316259984 445235 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :class Eq a where (==) :: a -> a -> Bool < 1316259986 424715 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :class Applicative f where pure :: a -> f a; (<*>) :: f (a -> b) -> f a -> f b; (*>) :: f a -> f b -> f b; (<*) :: f a -> f b -> f a < 1316259992 754252 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :I'm honestly impressed djinn can even do typeclasses. < 1316260003 491403 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :well I don't mean define data types. I mean if it had a collection of functions and their type information < 1316260020 496479 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :it could decide that a function has the correct type to satisfy the proof, so to speak. < 1316260043 134893 :Taneb!~nathan@host-78-146-164-99.as13285.net PRIVMSG #esoteric :brb < 1316260045 999918 :Taneb!~nathan@host-78-146-164-99.as13285.net QUIT :Quit: what a big quitter he is, eh? < 1316260050 648292 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :well that would be equivalent to having some extra axioms in the logic. < 1316260062 305675 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :so probably possible in principle < 1316260074 103856 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :oerjan: I'm pretty sure you'd have to modify the search procedure for each new axiom. < 1316260093 182179 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :yes, and it would make it more practical as you could say "write a program for this type and here's a function, module, etc to use" < 1316260095 391468 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :so the answer to the question "can djinn do lists if we special-case it to do lists" is... yes! < 1316260121 925458 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :elliott: it would still be limited to non-recursive types i think < 1316260137 545713 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :yeah, I just couldn't think of a type :P < 1316260139 919781 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric ::t (((. head . uncurry zip . splitAt 1 . repeat) . uncurry) .) . (.) . flip < 1316260140 656315 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :forall b c a. (b -> a -> c) -> (b -> a) -> b -> c < 1316260155 87738 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :also there are other problems. < 1316260157 512519 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :ambiguity... < 1316260178 398504 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :but a sufficiently sophisticated djinn could list a bunch of alternatives and have the user decide which one to insert. < 1316260178 750447 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :elliott: in fact you can in principle already do this with @djinn as it stands - just add your axioms as extra a1 -> a2 -> parts < 1316260201 29077 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :well, those cannot be polymorphic i guess. < 1316260206 14877 :nooga!~nooga@maverick.aircity.pl QUIT :Ping timeout: 252 seconds < 1316260210 17379 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :oerjan: wasn't that obvious? :P < 1316260218 879912 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :you can also define any data type by just including the relevant function as its only field. < 1316260288 53403 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :yeah < 1316260314 17534 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :@djinn Monad m => m (m a) -> m a < 1316260314 35706 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :-- f cannot be realized. < 1316260332 216607 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :...something tells me the monad support is rather limited < 1316260355 487327 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :heh < 1316260357 681488 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :@djinn Monad m => a -> m a < 1316260357 855408 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :f = return < 1316260379 288519 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :@src join < 1316260379 461147 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :join x = x >>= id < 1316260426 685215 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :@djinn Monad m => (a -> m b) -> m a -> m b < 1316260427 42114 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :f a b = b >>= a < 1316260548 944617 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :hm is there a way to tell GHC to use irrefutable patterns for a datatype by default? < 1316260841 133843 :twice11!~twice11@lenny32.physik.fu-berlin.de PRIVMSG #esoteric :elliott: None I know of, as irrefutable patterns destroy the ability of matching multiple patterns. < 1316260864 235659 :twice11!~twice11@lenny32.physik.fu-berlin.de PRIVMSG #esoteric :Depending on what you try to do, you could replace your datatype by a newtype. < 1316260885 894199 :twice11!~twice11@lenny32.physik.fu-berlin.de PRIVMSG #esoteric :As newtypes are single-constructor only, matches on them are inherently irrefutable. < 1316260917 634501 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :i assume the useful case would be single-constructor, multiple fields < 1316260925 343241 :twice11!~twice11@lenny32.physik.fu-berlin.de PRIVMSG #esoteric :newtype a tuple. < 1316260934 710920 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :doesn't work. < 1316261022 654573 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :twice11: There's only one constructor. < 1316261044 225737 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Newtyping a tuple isn't viable, the whole reason I'm using this in place of a tuple is that it's strict and unboexd :-) < 1316261046 663968 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :unboxed < 1316261096 409948 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :also this would be tricky, what about case (x, (y:z)) of ... where the tuple does this by default, but it would still be wierd to error out if the second element is an empty list... < 1316261098 189266 :twice11!~twice11@lenny32.physik.fu-berlin.de PRIVMSG #esoteric :oerjan: Doesn't work? For me it certainly does. < 1316261103 779073 :twice11!~twice11@lenny32.physik.fu-berlin.de PRIVMSG #esoteric :newtype Test = Test (Int,Bool, String) deriving Show < 1316261110 646060 :twice11!~twice11@lenny32.physik.fu-berlin.de PRIVMSG #esoteric :main = print \$ Test (3,True,"why?") < 1316261111 763139 :Sgeo!~Sgeo@ool-ad034d00.dyn.optonline.net QUIT :Ping timeout: 260 seconds < 1316261115 682366 :twice11!~twice11@lenny32.physik.fu-berlin.de PRIVMSG #esoteric :compiles + runs < 1316261122 745358 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :twice11: doesn't work to achieve a useful irrefutable pattern default < 1316261154 215023 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :I'm sure oerjan knows what he's talking about, having written half the Haskell Report. :p < 1316261235 191251 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :case Test (1, True, "") of Test (_, _, (x:xs)) -> ... would still error out too early. < 1316261276 621800 :twice11!~twice11@lenny32.physik.fu-berlin.de PRIVMSG #esoteric :In this case, the match on the list would need to be irrefutable, though, not the match on the type "Test". < 1316261329 822187 :twice11!~twice11@lenny32.physik.fu-berlin.de PRIVMSG #esoteric :Of course there is no way to make the match on members of a data type irrefutable by just playing around with the data type. < 1316261330 341759 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :> case (1, True, "") of ~(_, _ x:xs) -> "testing" < 1316261331 40199 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric : : Parse error in pattern < 1316261339 798029 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :> case (1, True, "") of ~(_, _, x:xs) -> "testing" < 1316261340 528275 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric : "testing" < 1316261394 228594 :twice11!~twice11@lenny32.physik.fu-berlin.de PRIVMSG #esoteric :OK, I'm not gonna split hairs here, but the "~" character is obviously "recursive", applying to all sub-patterns too. < 1316261398 785202 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :"hough, not the match on the type "Test". < 1316261398 803528 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : Of course there is no way to make the match on members of a data type irrefutable by just playing around with the data type." < 1316261400 875562 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :I was thinking more a flag. < 1316261403 628 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Erm < 1316261404 404051 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Like INLINE < 1316261408 3748 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :A declaration < 1316261412 613364 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Admittedly INLINE doesn't change semantics < 1316261415 222919 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :But LANGUAGE does :P < 1316261437 655280 :twice11!~twice11@lenny32.physik.fu-berlin.de PRIVMSG #esoteric :So like "data Test = Test Int Bool String {#-IRREFUTABLE-#}"? < 1316261446 611744 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :twice11: it's not clear what should be the semantics if someone _did_ provide a way to make irrefutable default patterns < 1316261450 822924 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Something like < 1316261454 260296 :twice11!~twice11@lenny32.physik.fu-berlin.de PRIVMSG #esoteric :So that matches on the string fields would be irrefutable. < 1316261454 278324 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :{#- IRREFUTABLE Test -#} < 1316261459 65257 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :data Test = Test Int Bool String < 1316261460 885475 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Then a match < 1316261463 442432 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :f (Test ...) = ... < 1316261464 496534 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :would actually be < 1316261466 981832 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :f ~(Test ...) = ... < 1316261475 738239 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :So I could say: < 1316261479 829910 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :{#- IRREFUTABLE Point -#} < 1316261482 614153 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :infix 0 :@ < 1316261482 632188 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :data Point = (:@) {-# UNPACK #-} !Value {-# UNPACK #-} !Value deriving (Eq, Ord, Show) < 1316261505 776518 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Erm, {-# ... #-} not {#- ... -#} of course. < 1316261572 94267 :MSleep!~fyrc@or-67-238-31-252.dhcp.embarqhsd.net NICK :MDude < 1316261574 10151 :twice11!~twice11@lenny32.physik.fu-berlin.de PRIVMSG #esoteric :for the top-level match, newtype-of-tuple provides the required irrefutability: < 1316261587 375719 :twice11!~twice11@lenny32.physik.fu-berlin.de PRIVMSG #esoteric :data Test2 = Test2 Int Bool String deriving Show < 1316261591 757726 :twice11!~twice11@lenny32.physik.fu-berlin.de PRIVMSG #esoteric :foo1 (Test _) = True < 1316261594 886785 :twice11!~twice11@lenny32.physik.fu-berlin.de PRIVMSG #esoteric :foo2 (Test2 _ _ _) = True < 1316261598 201826 :twice11!~twice11@lenny32.physik.fu-berlin.de PRIVMSG #esoteric :foo3 ~(Test2 _ _ _) = True < 1316261608 836411 :twice11!~twice11@lenny32.physik.fu-berlin.de PRIVMSG #esoteric :foo1 and foo3 can be called with "undefined". < 1316261626 834051 :hagb4rd|zzZ!~perdito@koln-d932d3ef.pool.mediaWays.net JOIN :#esoteric < 1316261646 502626 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :twice11: but you can actually define any variables in foo1 < 1316261649 670638 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :*cannot < 1316261655 965693 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :twice11: But not the required unpacking or strictness. < 1316261657 571301 :twice11!~twice11@lenny32.physik.fu-berlin.de PRIVMSG #esoteric :right, so I was cheating. < 1316261660 824742 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :If I didn't need them, I would just use a tuple. < 1316261678 774318 :twice11!~twice11@lenny32.physik.fu-berlin.de PRIVMSG #esoteric :elliott: I guess "unboxed tuples" are too limited for you. < 1316261702 885659 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Definitely. Also ugly. :p < 1316261807 910184 :twice11!~twice11@lenny32.physik.fu-berlin.de PRIVMSG #esoteric :foo4 (Test (_,_,_)) can not be called with undefined (of course), so I just moved the refutability by introducing a non-refutable futile further layer of indirection. < 1316261823 297613 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :I love how cabal, when a package fails to build, just builds a random other number of them before reporting the error. < 1316261835 893890 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :twice11: Clearly we just need an infinite stack of irrefutability. < 1316262024 146097 :twice11!~twice11@lenny32.physik.fu-berlin.de PRIVMSG #esoteric :elliott: Do you want irrefutability for performance or for being able to pass undefined? < 1316262084 668633 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Performance. Not that I expect it'll help much or perhaps even at all... I'd just like to try everything before actually having to replace my fungespace :-P < 1316262130 739629 :twice11!~twice11@lenny32.physik.fu-berlin.de PRIVMSG #esoteric :So saying !Point instead of Point and relying of ghc's worker split-off would do the job nicely. < 1316262147 45640 :twice11!~twice11@lenny32.physik.fu-berlin.de PRIVMSG #esoteric :No, I don't know a way of getting the bang everywhere. < 1316262151 622919 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Well, sed. < 1316262167 944174 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Preferably I'd like to localise the Horrific Cthulian Directives, though. :p < 1316262180 542384 :twice11!~twice11@lenny32.physik.fu-berlin.de PRIVMSG #esoteric :Also, !Point is a pattern does not work... < 1316262203 357032 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :~(a :@ b) would do it. < 1316262235 353784 :twice11!~twice11@lenny32.physik.fu-berlin.de PRIVMSG #esoteric :Modifying actual patterns instead of type signatures would be even more ugly. < 1316262264 842311 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :You can say !Point as a type? < 1316262288 13795 :twice11!~twice11@lenny32.physik.fu-berlin.de PRIVMSG #esoteric :No. < 1316262295 139242 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Aw. That would be nice. < 1316262312 764714 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Fun Haskell-derivative feature number 9999: Strictness polymorphism. < 1316262327 910763 :twice11!~twice11@lenny32.physik.fu-berlin.de PRIVMSG #esoteric :That's what I meant when I wrote "!Point is a pattern", wanted to type "!Point in a pattern" and meant "!Point in a signature". < 1316262332 97886 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Right. < 1316262367 103205 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :To expand on that feature: Every type is, by default, takes either "strict" or "lazy". It then passes this on to all the types mentioned in its definition that don't have an explicit override. < 1316262399 929391 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :So you can define lists once and get lazy lists with lazy elements, spline-strict lists with lazy elements, element-strict lists with lazy splines, ... < 1316262523 791975 :oerjan!oerjan@tyrell.nvg.ntnu.no QUIT :Quit: leaving < 1316262701 777739 :itidus21!~itidus21@120.147.173.44 QUIT :Quit: Leaving < 1316263054 647791 :Taneb!~nathan@host-78-146-164-99.as13285.net JOIN :#esoteric < 1316263062 836340 :Taneb!~nathan@host-78-146-164-99.as13285.net PRIVMSG #esoteric :Hello! < 1316263315 598031 :itidus21!~itidus21@120.147.173.44 JOIN :#esoteric < 1316263468 246406 :Taneb!~nathan@host-78-146-164-99.as13285.net PRIVMSG #esoteric :Does anyone else do Project Euler? < 1316263598 62448 :itidus21!~itidus21@120.147.173.44 QUIT :Client Quit < 1316263821 933604 :itidus21!~itidus21@120.147.173.44 JOIN :#esoteric < 1316263853 520953 :itidus21!~itidus21@120.147.173.44 QUIT :Client Quit < 1316264207 616848 :itidus21!~itidus21@120.147.173.44 JOIN :#esoteric < 1316264343 901232 :Taneb!~nathan@host-78-146-164-99.as13285.net QUIT :Remote host closed the connection < 1316264505 890737 :Taneb!~nathan@host-78-146-164-99.as13285.net JOIN :#esoteric < 1316264546 67867 :Jafet!~Jafet@unaffiliated/jafet PRIVMSG #esoteric :The thing that isn't a project and has nothing to do with Euler < 1316264612 59153 :Taneb!~nathan@host-78-146-164-99.as13285.net PRIVMSG #esoteric :That has nothing to do with my question < 1316264629 768141 :cheater!~cheater@ip-2-200-243-76.web.vodafone.de PRIVMSG #esoteric :what is the keyboard combination to change readline to vi mode and emacs mode? < 1316264638 413959 :Jafet!~Jafet@unaffiliated/jafet PRIVMSG #esoteric :elliott: data Lazy a = Lazy a; data StrictList a = SNil | SCons !a (StrictList a); type LazyList a = StrictList (Lazy a) < 1316264683 314678 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Jafet: Cute. But doesn't let you parameterise spline strictness. < 1316264729 993925 :Jafet!~Jafet@unaffiliated/jafet PRIVMSG #esoteric :data ElliottIsAFag s a = SNil | SCons !a !(spn (ElliotIsAFag spn a)) < 1316264744 677669 :Jafet!~Jafet@unaffiliated/jafet PRIVMSG #esoteric :...I think that would work. < 1316264760 829742 :Jafet!~Jafet@unaffiliated/jafet PRIVMSG #esoteric :s/s /spn / < 1316264764 67876 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Congratulations, you've proved that strict languages admit explicit laziness < 1316264787 26600 :Jafet!~Jafet@unaffiliated/jafet PRIVMSG #esoteric :Damn, I was trying to prove the converse. < 1316264788 66170 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :The idea with this is that you wouldn't have to define all that, and also wouldn't have to pack/unpack Lazy values (i.e. the reason laziness is awful in strict languages) :P < 1316264834 819606 :Jafet!~Jafet@unaffiliated/jafet PRIVMSG #esoteric :You can usually fix that with more polymorphism. < 1316264846 909353 :Jafet!~Jafet@unaffiliated/jafet PRIVMSG #esoteric :POLYMOARPHISM < 1316264953 743172 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Go on then < 1316264984 285706 :Jafet!~Jafet@unaffiliated/jafet PRIVMSG #esoteric :The Prelude does not have polymoarphism. < 1316265004 722927 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Implement yer own < 1316265009 693179 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :I guess you mean < 1316265013 554051 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :data Lazy a = Lazy a < 1316265020 693708 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :data Strict a = Strict !a < 1316265032 446999 :Jafet!~Jafet@unaffiliated/jafet PRIVMSG #esoteric :Also, you can't unbox that !a. < 1316265041 71188 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :class O o where pack :: a -> o a; unpack :: o a -> a < 1316265043 501609 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :instance O Lazy < 1316265045 593828 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :instance O Strict < 1316265057 253369 :Jafet!~Jafet@unaffiliated/jafet PRIVMSG #esoteric :More like Num a => Num (Lazy a) < 1316265065 241520 :Jafet!~Jafet@unaffiliated/jafet PRIVMSG #esoteric :Repeat 9001 times < 1316265073 359530 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :data List o a = Nil | Cons !(o a) !(o (List o a)) < 1316265082 830801 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Jafet: who cares about the prelude < 1316265088 425021 :Jafet!~Jafet@unaffiliated/jafet PRIVMSG #esoteric :And don't have pack or unpack, just roll both into cast < 1316265100 529515 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Jafet: Anyway, one problem there is that yo uca'n't override strictness of the element type < 1316265109 978321 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :You need to define your own newtype that discards its argument < 1316265112 78815 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Which is lame < 1316265129 823760 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Compare (List! Int~) < 1316265136 268342 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :i.e. spline-strict list of lazy integers < 1316265145 438040 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :(List! Int) == fully strict list because the ! is passed on < 1316265150 228130 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :I dunno, it sounds interesting :-P < 1316265166 463971 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :(List Int!) -- polymorphic on spline strictness but with strict elements < 1316265188 626907 :Jafet!~Jafet@unaffiliated/jafet PRIVMSG #esoteric :Programming with splines sure is < 1316265206 168947 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Sure is what < 1316265255 426725 :Jafet!~Jafet@unaffiliated/jafet PRIVMSG #esoteric :,,,smooth? Visually appealing? < 1316265264 338630 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Totes < 1316265285 633012 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :The other nice thing is that functions become the automatic "correct" strict implementation < 1316265294 69776 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :As in you don't need to rewrite map for efficiency on strict lists < 1316265343 825559 :itidus21!~itidus21@120.147.173.44 QUIT :Read error: Connection timed out < 1316265346 701650 :Jafet!~Jafet@unaffiliated/jafet PRIVMSG #esoteric :How would it be more efficient? < 1316265368 803697 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Than what? < 1316265371 621202 :itidus21!~itidus21@120.147.173.44 JOIN :#esoteric < 1316265380 429539 :Jafet!~Jafet@unaffiliated/jafet PRIVMSG #esoteric :map on a non-strict list. < 1316265390 720993 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :It wouldn't, it'd just be properly strict < 1316265392 712039 :sllide!~jari@ip565eb113.direct-adsl.nl JOIN :#esoteric < 1316265405 285204 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :I guess that Haskell stuff gtes you the same, but really nobody wants to write in that < 1316265443 757929 :Jafet!~Jafet@unaffiliated/jafet PRIVMSG #esoteric :That would suck, actually, since you'd need a stack or a reversal. < 1316265507 254257 :Jafet!~Jafet@unaffiliated/jafet PRIVMSG #esoteric :Either way, it's a linear amount of extra space. < 1316265591 249147 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Jafet: What would suck? < 1316265612 436914 :Jafet!~Jafet@unaffiliated/jafet PRIVMSG #esoteric :map on strict lists. < 1316265645 50298 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Jafet: Well, I'm not saying strict languages are a party. < 1316265656 108262 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :But people do map over strict lists quite an awful lot In The Real World, it has to be said. :p < 1316265670 199053 :Jafet!~Jafet@unaffiliated/jafet PRIVMSG #esoteric :It's kind of egregious when a strict solution uses more space than the lazy one. < 1316265687 53833 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :But the main thing is that I could write !(Value,Value) as a type, dammit, rather than defining my own fucking tuples. < 1316265691 679133 :Jafet!~Jafet@unaffiliated/jafet PRIVMSG #esoteric :Well, you save a bit of space from unboxing, but it's not enough. < 1316265710 70971 :Jafet!~Jafet@unaffiliated/jafet PRIVMSG #esoteric :(#,#) < 1316265752 84722 :Jafet!~Jafet@unaffiliated/jafet PRIVMSG #esoteric :Do you need strict tuples that often, or do you just want unboxed tuples < 1316265770 648139 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :infix 0 :@ < 1316265770 704218 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :data Point = (:@) {-# UNPACK #-} !Value {-# UNPACK #-} !Value deriving (Eq, Ord, Show) < 1316265771 724011 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :I want these < 1316265786 353928 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Except without the part where I reimplement tons of things for them and the constructor/destructor syntax isn't as nice as (a,b) < 1316265795 777952 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Unboxed tuples wouldn't even remotely work, I need to return these things < 1316265803 585632 :Jafet!~Jafet@unaffiliated/jafet PRIVMSG #esoteric :Well, you can fix the tuple type system while you're at it. < 1316265810 145151 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Tuple type system? < 1316265846 741908 :Taneb!~nathan@host-78-146-164-99.as13285.net QUIT :Read error: Connection reset by peer < 1316265862 633224 :Jafet!~Jafet@unaffiliated/jafet PRIVMSG #esoteric :So you can write tail (a,b,c...) and get (b,c...) < 1316265876 541786 :elliott!~elliott@unaffiliated/elliott NICK :Clippy < 1316265880 93709 :Jafet!~Jafet@unaffiliated/jafet PRIVMSG #esoteric :Then init (x,y,z,w) = (x,y,z) < 1316265882 54444 :Clippy!~elliott@unaffiliated/elliott PRIVMSG #esoteric :It looks like you're writing HLists. < 1316265884 797212 :Clippy!~elliott@unaffiliated/elliott PRIVMSG #esoteric :- Bow to Oleg < 1316265887 756844 :Clippy!~elliott@unaffiliated/elliott PRIVMSG #esoteric :- Continue futility < 1316265890 331747 :Clippy!~elliott@unaffiliated/elliott PRIVMSG #esoteric :- Bug the GHC developers < 1316265891 902204 :Clippy!~elliott@unaffiliated/elliott NICK :elliott < 1316265939 282698 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Everyone loves Clippy. < 1316265952 255294 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :If you disagree, reconsider your opinions. < 1316265972 800557 :Jafet!~Jafet@unaffiliated/jafet PRIVMSG #esoteric :Eh pops up at the right time and doesn't afraid of anything. < 1316265988 845253 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Except rejection. < 1316265991 221267 :Jafet!~Jafet@unaffiliated/jafet PRIVMSG #esoteric :@google openoffice.org clippy < 1316265992 337650 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :http://www.oooforum.org/forum/viewtopic.phtml?t=50110 < 1316266004 558059 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Finally I can switch to Linux. < 1316266117 349206 :Jafet!~Jafet@unaffiliated/jafet PRIVMSG #esoteric :http://www.oooforum.org/forum/viewtopic.phtml?t=22401 < 1316266126 254106 :Jafet!~Jafet@unaffiliated/jafet PRIVMSG #esoteric :10% of people actually want it. < 1316266194 378654 :Jafet!~Jafet@unaffiliated/jafet PRIVMSG #esoteric :That's probably more people than the people who want, say, auto-turn-everything-that-could-possibly-be-interpreted-as-a-date-into-a-date-even-American-so-called-dates in spreadsheets. < 1316266232 174172 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Really, American dates aren't that bad. PDPs had integers like that, you know. < 1316266245 477342 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :I wonder if PDPs were fast at handling American dates. < 1316266386 60322 :sebbu!~sebbu@unaffiliated/sebbu QUIT :Read error: Connection reset by peer < 1316266524 585295 :sebbu!~sebbu@ADijon-152-1-16-223.w83-194.abo.wanadoo.fr JOIN :#esoteric < 1316266524 613240 :sebbu!~sebbu@ADijon-152-1-16-223.w83-194.abo.wanadoo.fr QUIT :Changing host < 1316266524 631235 :sebbu!~sebbu@unaffiliated/sebbu JOIN :#esoteric < 1316266715 713803 :ais523!~ais523@unaffiliated/ais523 JOIN :#esoteric < 1316267153 112685 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :something that came up at my job, and people might have ideas on here: what's the easiest (ideally fully-automated) way to get all the email sent to a gmail account into an mbox file or equivalent easily machine-readable format? < 1316267165 291749 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :I'm assuming it involves IMAP somewhere < 1316267254 590735 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :ACTION goes and checks CPAN < 1316267256 162424 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :step one < 1316267256 874634 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :imap < 1316267259 171658 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :step two < 1316267260 218634 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :done < 1316267266 670629 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :gmail has imap interface, so just enable it and... use a client < 1316267270 452159 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :a standard imap client < 1316267273 92201 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :yep, I'm wondering where to get an appropriate IMAP client < 1316267283 347792 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :using Evolution is obviously silly < 1316267285 112877 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :fetchmail :-) < 1316267292 534386 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :note: joke. joke. joke. no. joke. < 1316267297 971568 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :I thought it might be < 1316267312 7848 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :ais523: At least do Maildir rather than mbox. < 1316267322 960481 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :what's the difference? < 1316267330 575970 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Maildir isn't useless. < 1316267358 612557 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :well, the application is: I want to perform an operation on the text and subject line of every email emailed to a particular gmail account < 1316267368 195643 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :It has a file per message and actually supports more than one application accessing a file without like totally rewriting it. < 1316267368 213792 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :(using gmail wasn't my choice here, and seems a little inappropriate for the task) < 1316267382 151200 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :It's easy to implement, http://en.wikipedia.org/wiki/Maildir#Technical_operation < 1316267388 214361 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :there's only the one application accessing the account < 1316267390 864242 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :ais523: bayes has code for this :-) < 1316267393 300197 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :it's dedicated for the one task only < 1316267398 887007 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :though you'd have to ask comex if he has a copy of it < 1316267400 252447 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :and it's Python < 1316267401 826969 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :elliott: aha, it probably does < 1316267409 463731 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :well, I forget what bayes operated on < 1316267412 906662 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :language isn't really important, although I don't like Python < 1316267414 468584 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :might have been imap, might have been mbox < 1316267421 285517 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :but python has imap too so that's like three extra lines < 1316267424 698977 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :ais523: i don't either but it worked at the time < 1316267425 941195 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :`log language < 1316267433 668742 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :ais523: I'm really surprised Bayes worked, really < 1316267439 124171 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :`log language < 1316267446 287621 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :elliott: the same is true of most programs < 1316267447 879493 :HackEgo!foobar@codu.org PRIVMSG #esoteric :2007-08-19.txt:22:24:16: Gurami: my favorite language for web development is english - I requie all web users to phrase queries in plain english, then I write my answer out in cursive german, which an OCR program will scan, and translate to english, then feed back to the user. < 1316267447 897438 :HackEgo!foobar@codu.org PRIVMSG #esoteric :2005-07-16.txt:07:25:12: that's interesting though.. I wonder what a programming language would look like if the ancient egyptians had computers < 1316267455 919118 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :I'm surprised my quick hacks to OCaml's parser this morning worked < 1316267460 791587 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :and to its main evaluation loop < 1316267465 921784 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :did Bayes ever actually do well at the AAA? < 1316267475 658313 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :it played perfectly, but I don't remember if that translated into real success < 1316267476 376898 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :`log really important < 1316267476 538093 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :the AAA collapsed before it had much of a chance, IIRC < 1316267479 610635 :HackEgo!foobar@codu.org PRIVMSG #esoteric :2008-04-04.txt:19:06:07: but it's really important in sed < 1316267483 764123 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :`log really important < 1316267487 34028 :HackEgo!foobar@codu.org PRIVMSG #esoteric :2011-09-17.txt:13:51:16: `log really important < 1316267491 97866 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :`log really important < 1316267494 378345 :HackEgo!foobar@codu.org PRIVMSG #esoteric :2010-01-25.txt:22:02:48: If it was really important for me to get clang running, I probably would have tried it in the VM. But for kicks, it's hey, let's try cygwin!! < 1316267503 365793 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :`log really important < 1316267506 641976 :HackEgo!foobar@codu.org PRIVMSG #esoteric :2010-10-16.txt:15:01:08: catseye: is the windows partition really important? i'd have just upgraded the ubuntu install < 1316267520 51388 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :ACTION sidles away < 1316267542 689057 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :ais523: hmm, partnerships weren't stripped of personhood, right? < 1316267557 982662 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :...never mind :P < 1316267558 506344 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :`log personhood < 1316267561 719738 :HackEgo!foobar@codu.org PRIVMSG #esoteric :2010-10-20.txt:00:04:00: trees have personhood < 1316267563 386047 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :yes, they were < 1316267566 866670 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :`log personhood < 1316267569 943167 :HackEgo!foobar@codu.org PRIVMSG #esoteric :2010-10-20.txt:00:04:00: trees have personhood < 1316267573 448394 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :I know I tried to argue that they were still nonetheless players < 1316267578 429596 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :hmm, I thought that was ruled R101-violating < 1316267578 778534 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :`log personhood < 1316267578 990109 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :until someone explicitly deregistered them < 1316267581 724987 :HackEgo!foobar@codu.org PRIVMSG #esoteric :2010-09-12.txt:07:51:52: Does U.S. Law, which might contain legal fictions (corporate personhood, for example), constitute a fictitious world? < 1316267591 648392 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :but I think it was decided that the undefinition of concepts caused partnerships to cease to exist < 1316267593 564392 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :seems an easy way to circumvent R101; depersonalise something, abuse it, then repersonalise it < 1316267596 361347 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :ais523: heh < 1316267601 516319 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :`log nomic < 1316267604 977668 :HackEgo!foobar@codu.org PRIVMSG #esoteric :2010-09-17.txt:05:44:25: Less so culturally, but very much so economically. < 1316267618 1142 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :`log \bnomic\b < 1316267620 12648 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :nice abuse of nomic < 1316267621 280436 :HackEgo!foobar@codu.org PRIVMSG #esoteric :2007-12-28.txt:00:17:49: Small world, I guess. I conclude that everyone here is interested in Nomic. < 1316267633 81283 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :egrep recognises \b? nice < 1316267648 970645 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :`log recogni < 1316267652 640587 :HackEgo!foobar@codu.org PRIVMSG #esoteric :2008-05-08.txt:15:36:17: Monticello recognizes your monkey patches and even version controls them < 1316267663 6847 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :elliott: ooh, that sounds useful < 1316267678 924038 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :`log recogni < 1316267681 653178 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :ais523: I'm sure Feather's VCS could do that < 1316267682 208667 :HackEgo!foobar@codu.org PRIVMSG #esoteric :2007-04-17.txt:02:37:31: if the filesystem recognizes content types... then it can be smart about handling them. audio is typically large, and edited infrequently... while a swap file stays roughly the same most of the time, but will be written and read from frequently. < 1316267682 523598 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :I was planning to diff my unpacked OCaml directory against the original, ignoring files that didn't exist in both, to find my monkeypatches < 1316267688 983216 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :elliott: Feather has a VCS? < 1316267691 653244 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :do you mean @'s VCS? < 1316267693 433411 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Monticello is a Smalltalk thing, so presumably? < 1316267701 27137 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :oh, I see < 1316267703 816788 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :`log VCS < 1316267707 248344 :HackEgo!foobar@codu.org PRIVMSG #esoteric :2010-03-01.txt:11:58:55: one thing I've been thinking about recently is designing my own VCS < 1316267716 163892 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :haha, it begins < 1316267718 433556 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Ha, what does that scarf know about VCSes. < 1316267720 454267 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :He should try scapegoat. < 1316267724 42077 :ais523!~ais523@unaffiliated/ais523 NICK :scarf < 1316267724 912585 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :It'll beat whatever crappy idea HE has. < 1316267727 349897 :scarf!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :heh < 1316267729 616596 :scarf!~ais523@unaffiliated/ais523 NICK :ais523 < 1316267744 494294 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :ACTION abuses `log < 1316267753 931050 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :`log < 1316267755 800535 :HackEgo!foobar@codu.org PRIVMSG #esoteric :2011-03-16.txt:02:53:07: indeed, it is impossible to give an answer inadvertently < 1316267756 411689 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :?tell scarf I'm from the future! Turns out your VCS sucks. Actually it wiped out half the human population. Thanks a bunch. < 1316267756 585073 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Consider it noted. < 1316267779 814646 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :ACTION leaves lesions and trauma on `log < 1316267784 359531 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :elliott: you're getting sg and feather muddled again < 1316267793 956779 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :anyway, I'm pretty sure I know what a Feather program is < 1316267799 233971 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :ais523: the folly is pretending all these concepts can be separated < 1316267809 813957 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :it's a sequence of program fragments that, when run, transform a Feather interpreter into a new state < 1316267821 436681 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :I'm not sure if output is possible, but luckily it's an esolang, so I don't really mind < 1316267850 214599 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :`log ton < 1316267854 42664 :HackEgo!foobar@codu.org PRIVMSG #esoteric :2010-04-19.txt:16:38:52: -!- Tritonio_GR has quit (Read error: Connection reset by peer). < 1316267862 478814 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :`log fuckton < 1316267865 654966 :HackEgo!foobar@codu.org PRIVMSG #esoteric :2010-03-13.txt:18:25:41: pikhq: Y'know, I'm starting to think that metric fucktons aren't even a real unit! < 1316267874 905181 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :yes they are < 1316267887 683604 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :blasphemy < 1316267901 404985 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :jk,, < 1316267930 341856 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :`log fuckton < 1316267933 526889 :HackEgo!foobar@codu.org PRIVMSG #esoteric :2010-10-17.txt:17:57:02: pikhq: I think we are up for a FUCKTON of flashbacks. < 1316267986 515700 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :why are people always addressing pikhq with the word fuckton i wonder < 1316268015 48974 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Always=two. < 1316268018 531108 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :lets take another dip < 1316268018 704292 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Two=infinity. < 1316268020 968504 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :`log fuckton < 1316268021 491497 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Zero, one, infinity. < 1316268024 272984 :HackEgo!foobar@codu.org PRIVMSG #esoteric :2011-09-17.txt:13:58:50: `log fuckton < 1316268028 240441 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :`log fuckton < 1316268031 646819 :HackEgo!foobar@codu.org PRIVMSG #esoteric :2011-09-12.txt:03:52:40: As per how many files, roughly a metric fuckton. < 1316268057 315059 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :so it seems gregor's faith in that metric is stable < 1316268066 797178 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :ok my sample size was too small < 1316268093 975934 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :`log fuckton < 1316268097 41060 :HackEgo!foobar@codu.org PRIVMSG #esoteric :2009-06-18.txt:21:10:58: pikhq: metric fuckton? < 1316268119 189990 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :wtf.. some freeeaky pattern there < 1316268138 249803 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :gestures < 1316268826 684292 :Taneb!~nathan@host-78-146-164-99.as13285.net JOIN :#esoteric < 1316269079 989653 :hagb4rd|zzZ!~perdito@koln-d932d3ef.pool.mediaWays.net NICK :hagb4rd < 1316269746 44167 :Taneb!~nathan@host-78-146-164-99.as13285.net QUIT :Read error: Connection reset by peer < 1316270124 781318 :Patashu!~Patashu@c122-106-155-219.carlnfd1.nsw.optusnet.com.au QUIT :Ping timeout: 258 seconds < 1316270355 706802 :Taneb!~nathan@host-78-146-164-99.as13285.net JOIN :#esoteric < 1316272384 325557 :derrik!~xix@143.122.191.90.dyn.estpak.ee JOIN :#esoteric < 1316272531 753470 :Taneb_!~nathan@host-78-146-164-99.as13285.net JOIN :#esoteric < 1316272676 804981 :sebbu2!~sebbu@unaffiliated/sebbu JOIN :#esoteric < 1316272688 752240 :Taneb!~nathan@host-78-146-164-99.as13285.net QUIT :Ping timeout: 252 seconds < 1316272880 659896 :sebbu!~sebbu@unaffiliated/sebbu QUIT :Ping timeout: 252 seconds < 1316273106 769956 :Taneb_!~nathan@host-78-146-164-99.as13285.net QUIT :Ping timeout: 252 seconds < 1316273898 376926 :sebbu2!~sebbu@unaffiliated/sebbu NICK :sebbbu < 1316273960 474861 :calamari!~calamari@ip72-211-146-193.tc.ph.cox.net JOIN :#esoteric < 1316275162 991002 :Gregor!foobar@codu.org PRIVMSG #esoteric :`pastelogs fuckton < 1316275168 679683 :HackEgo!foobar@codu.org PRIVMSG #esoteric :http://codu.org/projects/hackbot/fshg/index.cgi/raw-file/tip/paste/paste.3409 < 1316275235 65140 :Gregor!foobar@codu.org PRIVMSG #esoteric :Welp, I'm the first person to ever say "fuckton" in this channel. < 1316275238 207012 :Gregor!foobar@codu.org PRIVMSG #esoteric :Pretty proud of that. < 1316275247 20603 :Gregor!foobar@codu.org PRIVMSG #esoteric :Also the first person to say "metric fuckton" < 1316275273 682480 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :isn't a metric fuckton slightly smaller than an imperial fuckton? < 1316275284 746843 :Gregor!foobar@codu.org PRIVMSG #esoteric :ais523: According to our own logs, slightly /larger/ < 1316275288 580947 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :ah, aha < 1316275317 730497 :Gregor!foobar@codu.org PRIVMSG #esoteric :`run sed 's/\(.*metric\)/ \1/gi' paste/paste.3409 | paste < 1316275319 386811 :HackEgo!foobar@codu.org PRIVMSG #esoteric :http://codu.org/projects/hackbot/fshg/index.cgi/raw-file/tip/paste/paste.5111 < 1316275352 699435 :Gregor!foobar@codu.org PRIVMSG #esoteric :Looks like about half of all fuckton mentions are qualified. < 1316276888 773067 :sebbbu!~sebbu@unaffiliated/sebbu QUIT :Read error: Connection reset by peer < 1316277037 366383 :sebbbu!~sebbu@ADijon-152-1-16-223.w83-194.abo.wanadoo.fr JOIN :#esoteric < 1316277333 104776 :sebbbu!~sebbu@ADijon-152-1-16-223.w83-194.abo.wanadoo.fr NICK :sebbu < 1316277347 997860 :sebbu!~sebbu@ADijon-152-1-16-223.w83-194.abo.wanadoo.fr QUIT :Changing host < 1316277348 16087 :sebbu!~sebbu@unaffiliated/sebbu JOIN :#esoteric < 1316277995 497931 :ive!~nn@189.179.246.222 JOIN :#esoteric < 1316278003 694918 :Freedom666!~JOHN_DOE@66.242.49.220 JOIN :#esoteric < 1316278056 66090 :Freedom666!~JOHN_DOE@66.242.49.220 PART :#esoteric < 1316278086 701497 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :?hoogle Q [Q a] -> [Q a] < 1316278087 50691 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Language.Haskell.TH appsE :: [ExpQ] -> ExpQ < 1316278087 235978 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Language.Haskell.TH listE :: [ExpQ] -> ExpQ < 1316278087 254313 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Language.Haskell.TH tupE :: [ExpQ] -> ExpQ < 1316278088 444640 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :That won't work >_> < 1316278097 367279 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :?hoogle m [m a] -> [m a] < 1316278097 544635 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Data.List transpose :: [[a]] -> [[a]] < 1316278097 727417 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Control.Monad msum :: MonadPlus m => [m a] -> m a < 1316278097 745556 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Test.QuickCheck oneof :: [Gen a] -> Gen a < 1316278099 541135 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :BUT I MIGHT AS WELL TRY < 1316278133 837509 :derrik!~xix@143.122.191.90.dyn.estpak.ee QUIT :Quit: gone < 1316278161 848746 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :elliott: (Parsec3, Text) -> (Trifecta, ByteString): 6 files changed, 263 insertions(+), 202 deletions(-) < 1316278178 656244 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: Nice < 1316278181 306061 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: I logpinged you repeatedly < 1316278183 366102 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :w/ edwardk comments < 1316278188 660520 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :I noticed < 1316278212 99752 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Nice to know that the tab thing is in the works < 1316278272 330548 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Dang, 12% of this file is imports now < 1316278281 261928 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric ::-D < 1316278289 504850 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: Be thankful, you're not dealing with TH like I am < 1316278294 896672 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :I don't think I've ever had 8 qualified imports in one module < 1316278320 976403 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Gotta love a library where the recommended calling convention for the API functions is "they all take monadic values and return monadic values, except that, if it's a list, it's actually a pure list of monadic values, and..." < 1316278527 164061 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Whoops, make that 214 deletions < 1316278772 728457 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: Can you shoot whoever wrote the cereal package for me, thanks < 1316278792 329928 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :What kind of horrible person adds functions for serialising WordNs for various N in little-endian BUT NOT INTS < 1316278796 275243 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :WHAT AM I MEANT TO DOOOOO < 1316278805 21534 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :(Okay I guess I can just fromIntegral it and it'll be fine but still) < 1316278903 790738 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :elliott: That'd be "Galois Inc." and some others < 1316278994 215280 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: DAMN YOU GALOIS INC. < 1316279000 388183 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :module MC.Protocol.Helpers < 1316279000 698692 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : ( putInt16be < 1316279000 716688 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : , putInt32be < 1316279000 716842 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : , putInt64be < 1316279000 716949 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : , putTextUCS2be < 1316279001 50134 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : ) where < 1316279006 401512 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Finally my code is becoming a mess already < 1316279011 756332 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Just what I always secretly wanted < 1316279961 110587 :azaq23!~derivecto@pD9E34E0C.dip0.t-ipconnect.de JOIN :#esoteric < 1316279962 490596 :azaq23!~derivecto@pD9E34E0C.dip0.t-ipconnect.de QUIT :Changing host < 1316279962 508979 :azaq23!~derivecto@unaffiliated/azaq23 JOIN :#esoteric < 1316280489 319787 :calamari!~calamari@ip72-211-146-193.tc.ph.cox.net QUIT :Quit: Leaving < 1316281682 381918 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :Deewiant: My xmonad.hs has six qualified imports, and they're named using the "1-3-letter all-uppercase cryptic acronyms" style elliott hates. (Though three of them probably have no real business to be qualified.) < 1316281780 125407 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :fizzie: I thought you used so-called ``awesome''. < 1316281793 873859 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :At least I can recognize five of these eight abbreviations out of context < 1316281802 254096 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Also, as far as hating them goes, I realised my style was totally inconsistent and switched to Deewiant's < 1316281806 30871 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Bit of an existential crisis there < 1316281807 289803 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :as BS < 1316281807 308408 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :as BSL < 1316281807 308554 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :as UTF8 < 1316281807 308658 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :as F < 1316281807 308766 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :as IM < 1316281809 832978 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :as IS < 1316281812 309801 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :as PP < 1316281814 762663 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :as TriD < 1316281823 897011 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: I gently request "B" instead of "BS", on behalf of programmers worldwid.e < 1316281825 987487 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :worldwide. < 1316281828 956995 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :I mean come on, BS. < 1316281833 957655 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Also it: is shorter. < 1316281835 697037 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :elliott: I made the plunge a month ago. < 1316281843 646888 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :Deewiant: HT, W, T, DBA, DBC, DBT. < 1316281847 314817 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Actually I just remembered that BSL should be BL < 1316281851 122416 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :fizzie: I hope you've enjoyed your plungerating. < 1316281860 226855 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :elliott: At Least It's Not Lua(tm). < 1316281882 230772 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Anyway, BS is intentional precisely because it's BS < 1316281909 73629 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :UTF8 should probably be BS_UTF8 but meh < 1316281946 239154 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :fizzie: I should probably try out xmonad sometime myself. I mean, there's something to be said for being under fifty lines. < 1316281952 568773 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: What exactly is the BS_UTF8 module < 1316281961 115119 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Data.ByteString.UTF8 < 1316282011 440618 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :I'd go for BUTF8 < 1316282015 273504 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Beautiful eight. < 1316282019 327614 :olsner!~salparot@c83-252-161-133.bredband.comhem.se PRIVMSG #esoteric :Data.BullShit.UTF8 < 1316282021 444709 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Butt F8 < 1316282024 71591 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Meanwhilst, from the land of generated code: < 1316282025 492886 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : 1 -> Control.Monad.ap < 1316282025 804323 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : (Control.Monad.ap < 1316282025 822569 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : (Control.Monad.ap < 1316282025 822720 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : (Control.Monad.ap < 1316282025 822825 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : (Control.Monad.ap < 1316282025 981428 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :elliott: So far I like it, even though my setup (Gnome-2 session running XMonad as the WM, with a gnome-panel instance holding all those indicator schwubblets and a systray) is probably something that would make "real XMonadists" go up in flames. < 1316282026 528553 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : (Control.Monad.ap < 1316282028 416134 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : (Control.Monad.ap < 1316282030 507924 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : (Control.Monad.ap < 1316282032 435213 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : (Control.Applicative.pure CLogin) < 1316282034 568493 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : MC.Protocol.Helpers.putInt32be) < 1316282036 616501 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : MC.Protocol.Helpers.putTextUCS2be) < 1316282038 404105 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : MC.Protocol.Helpers.putInt64be) < 1316282040 717178 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : MC.Protocol.Helpers.putInt32be) < 1316282042 461764 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : Data.Serialize.Put.putWord8) < 1316282044 383403 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : Data.Serialize.Put.putWord8) < 1316282048 390770 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : Data.Serialize.Put.putWord8) < 1316282050 486404 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : Data.Serialize.Put.putWord8 } } < 1316282053 583296 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :Oh no, I messed up the pretty triangle. :( < 1316282056 367529 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :fizzie: Pretty sure PROMINENT XMONAD COMMUNITY MEMBERS(tm) do the Gnome thing too. < 1316282062 338278 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :And yes, you are disgusting. < 1316282081 414625 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Now if you stay quiet for a second, you will hear the sound of Deewiant yelling USE < 1316282083 882157 :DH____!~DH____@unaffiliated/dh----/x-6288474 QUIT :Read error: Connection reset by peer < 1316282087 622730 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :He will then type the asterisk, enabling my use of it < 1316282104 193290 :DH____!~DH____@unaffiliated/dh----/x-6288474 JOIN :#esoteric < 1316282111 989667 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :<*> < 1316282120 960649 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Also he might tell me that it should be get instead of put there and he'd be EXACTLY RIGHT. < 1316282157 750477 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : 1 -> ((((((((Control.Applicative.pure CLogin < 1316282157 808472 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : Control.Applicative.<*> < 1316282157 808547 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : MC.Protocol.Helpers.getInt32be) < 1316282157 808591 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : Control.Applicative.<*> < 1316282157 808635 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : MC.Protocol.Helpers.getTextUCS2be) < 1316282158 160188 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : Control.Applicative.<*> < 1316282159 464427 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : MC.Protocol.Helpers.getInt64be) < 1316282162 218309 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : Control.Applicative.<*> < 1316282163 481134 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : MC.Protocol.Helpers.getInt32be) < 1316282165 828558 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : Control.Applicative.<*> < 1316282169 736254 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : Data.Serialize.Get.getWord8) < 1316282171 832371 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : Control.Applicative.<*> < 1316282176 860182 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : Data.Serialize.Get.getWord8) < 1316282176 878301 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : Control.Applicative.<*> < 1316282177 855571 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : Data.Serialize.Get.getWord8) < 1316282179 763668 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : Control.Applicative.<*> < 1316282181 590188 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : Data.Serialize.Get.getWord8) } } < 1316282183 902089 :copumpkin!~pumpkin@unaffiliated/pumpkingod PRIVMSG #esoteric :ACTION sighs < 1316282185 497938 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Isn't it pretty? < 1316282188 423499 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :elliott: Do you need those brackets < 1316282191 505460 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :I also have a dzen2-for-each-monitor statusbars thing fed by a separate proggie that receives status updates via DBus, and the XMonad.Layout.IndependentScreen thing that makes workspaces local per screen (as in Awesome), which I guess are non-conventional things to do also. < 1316282192 271537 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :elliott: Also btw henceforth when I use first/second if you yell at me about arrows I'll say they're from Data.Bifunctor < 1316282195 312992 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :The sauna. -> < 1316282205 430017 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: (a) This is GHC printing its generated splice code < 1316282208 528146 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :All this is from TH < 1316282212 113539 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: (b) Okay < 1316282218 926717 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :copumpkin: Do you have a highlight on applicative or something < 1316282223 277924 :copumpkin!~pumpkin@unaffiliated/pumpkingod PRIVMSG #esoteric :nope < 1316282230 626865 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Or were you just expressing general disapproval of my beautiful exhibits < 1316282256 711281 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :elliott: And if you can find me an (&&&) outside Control.Arrow I can drop arrows entirely < 1316282269 436284 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric ::t (&&&) < 1316282270 952126 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :forall (a :: * -> * -> *) b c c'. (Arrow a) => a b c -> a b c' -> a b (c, c') < 1316282273 323683 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Hayoo time < 1316282280 644988 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :\f g -> bimap f g . join (,) < 1316282311 500865 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :It exists in various places IIRC but nowhere nice :-P < 1316282318 349005 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :http://hackage.haskell.org/packages/archive/data-aviary/latest/doc/html/Data-Aviary-Functional.html#v:(&&&) < 1316282318 367026 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :http://hackage.haskell.org/packages/archive/uulib/latest/doc/html/UU-Util-Utils.html#v:split < 1316282320 428883 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :http://hackage.haskell.org/packages/archive/pointless-haskell/latest/doc/html/Generics-Pointless-Combinators.html#v:(/\) < 1316282321 616877 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :http://hackage.haskell.org/packages/archive/Agda/latest/doc/html/Agda-Utils-Tuple.html#v:(/\) < 1316282323 668738 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :http://hackage.haskell.org/packages/archive/hamusic/latest/doc/html/Music-Analysis-PF.html#v:split < 1316282326 688753 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Yes, exactly < 1316282328 44475 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :I suggest the Agda or hamusic one. :p < 1316282332 62664 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: Well, hmm < 1316282333 54262 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Yes, exactly not :-P < 1316282350 151044 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :http://hackage.haskell.org/package/pointless-haskell-0.0.5 does not look so bad, though it depends on haskell98 and duplicates a lot of edwardk packages ;-) < 1316282369 185222 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Yes, the duplication is the main problem :-P < 1316282371 595212 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :uulib is apparently the parsing library? I assumed it'd just be a grab-bag of Utrecht-style insanity < 1316282384 829492 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Oh, data-aviary is just a set of combinator birds < 1316282388 393622 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :That's not so bad, is't? < 1316282392 709889 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Though it certainly has all the stupid names. :p < 1316282405 849610 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Oh, Data.Aviary.Functional: "This is for reference (obviously) and is not intended for use." < 1316282417 81738 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: In conclusion, I recommend depending on Agda < 1316282424 282685 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Not hamusic? < 1316282431 894770 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: It uses the older Haddock CSS < 1316282433 662693 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :I don't like that < 1316282460 198892 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: More seriously though, I might just make my own package of "Arrow shit except specialised to functions" < 1316282465 45289 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Since I want it, too < 1316282475 343779 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :The question is where to put them, module-wise :P < 1316282479 144743 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Data.Function.Extra is gross < 1316282480 696698 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Make it a "tuple helpers" instead < 1316282488 380073 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: What about arrowchoice < 1316282489 106371 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :And add Trifunctors etc < 1316282493 400771 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Nobody uses arrowchoice < 1316282505 623377 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: But okay, tuple helpers sounds decent < 1316282508 881285 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Data.Function.Tuple? < 1316282513 598207 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Data.Tuple already exists < 1316282521 541778 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Data.Tuple.ElliottsExtrasEmporium < 1316282528 475062 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Yes, which is why I'm trying to think of logical other names < 1316282541 462217 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :I meant that I'd put it under Data.Tuple < 1316282550 599438 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Data.Tuple.Combinators? < 1316282560 139720 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :That seems reasonable, if a little long < 1316282568 839207 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :That's not long < 1316282574 884111 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :System.Console.Terminfo.PrettyPrint is long < 1316282578 74677 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Your mind is warped by the trifecta < 1316282584 403958 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :That's not trifecta < 1316282593 430478 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :s/trifecta/edwardk/ :-P < 1316282610 124232 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :And hey, Data.ListTrie.Patricia.Map.Enum < 1316282615 298112 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :That's long too < 1316282624 440174 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: I'm so glad I put GPipe stuff on the back-burner < 1316282626 757029 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :But it's only ever imported qualified so it doesn't matter for my alignment purposes < 1316282636 980391 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Means I'm not dealing with your awful library :-D < 1316282644 265756 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric ::-( < 1316282652 259736 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :OK, beautiful library with ugly typeclasses. < 1316282665 504881 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Which you haven't fixed yet < 1316282668 658315 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Or where did we end up with that < 1316282672 907286 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Like I said, I put GPipe stuff on the backburner < 1316282678 101372 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Yeah okay < 1316282684 107039 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :It's not hard to fix at all, it's just a lot of tedious work :P < 1316282686 877938 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :I'm just wondering if you'd given up on it or if we were stuck on something else < 1316282698 690691 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: So (&&&) isn't a very nice name < 1316282709 340049 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :I don't care about the name < 1316282716 434335 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :You probably care about whether it's infix or not < 1316282723 64841 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Not that much < 1316282726 285869 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :I'm fine with bimap instead of *** < 1316282731 597853 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :I think, at least < 1316282741 406395 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :I haven't used either *** or &&& lately < 1316282744 847812 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :What type does (\f g -> bimap f g . join (,)) actually come out to < 1316282761 900354 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :\f g -> bimap f g . join (,) :: (c -> b) -> (c -> d) -> c -> (b, d) < 1316282869 508287 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :(Same as with (***)) < 1316282897 469224 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Oh, I thought it'd end up with some funky bifunctor crap in the type < 1316282911 159314 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :The (,) makes it be a pair < 1316282919 924585 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :And that's the only bifunctor crap there could be < 1316282946 845424 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric : Brainlove adds a few more commands to brainfuck in order to make it easier to program in. < 1316282948 990552 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :oh dear < 1316282950 124249 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :ais523: augh < 1316282952 216963 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :?hoogle showHex < 1316282952 632615 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Numeric showHex :: Integral a => a -> ShowS < 1316282963 842478 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :> showHex 99 "a" < 1316282964 934188 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric : "63a" < 1316283010 816053 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :it seems to be BF + one register that can be copied to/from tape + until loop + instruction that makes while/unless into if/unless < 1316283089 120659 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :I always think of http://i.imgur.com/6Ybge.jpg when elliott says "augh" < 1316283100 367403 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Fairly accurate < 1316283158 703918 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Has anyone here who is Deewiant used lazy bytestrings < 1316283168 734942 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Yes < 1316283172 171007 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Excellent < 1316283183 490590 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: I take it doing the equivalent of getContents for a lazy bytestring isn't a Done Thing < 1316283196 212233 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :It's only that, I just realised that cereal only works on bytestrings < 1316283200 552846 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :And the data is variable length < 1316283207 8360 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :So I have no idea how many bytes to read < 1316283207 202650 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :So < 1316283207 979609 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Yeah < 1316283215 95844 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :I could do my own buffering but I'd rather it be more automatic < 1316283216 497688 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Oh hmm < 1316283218 750843 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Constructors < 1316283218 769253 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Fail String < 1316283218 769404 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :The parse failed. The String is the message describing the error, if any. < 1316283218 769509 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Partial (ByteString -> Result r) < 1316283219 696646 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Supply this continuation with more input so that the parser can resume. To indicate that no more input is available, use an empty string. < 1316283223 140870 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Done r ByteString < 1316283225 867412 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :The parse succeeded. The ByteString is the input that had not yet been consumed (if any) when the parse succeeded. < 1316283228 444773 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Yeah okay this should work < 1316283235 167228 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Glad I could help < 1316283236 520299 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :I'll still have to keep my own buffer but that's pretty good < 1316283241 215128 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: You're very welcome < 1316283258 812960 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: To thank you for your help, here's a horrible function: http://sprunge.us/ASLM < 1316283270 691067 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Actually that's probably the prettiest TH code I've written yet < 1316283271 351152 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Looks fine to me < 1316283276 812882 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :The average identifier length far exceeds 1 < 1316283282 389099 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: Quick, what does it do, tell me in ten seconds < 1316283283 611292 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Compare to trifecta < 1316283285 977286 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :No cheating < 1316283298 703443 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Also no looking at the function body which makes it obvious :-P < 1316283310 34992 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Too late, I already looked before you asked < 1316283330 138056 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Dammit < 1316283341 707626 :copumpkin!~pumpkin@unaffiliated/pumpkingod QUIT :Quit: Computer has gone to sleep. < 1316283343 718145 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : let x = 0 of type UNSIGNED byte < 1316283343 890259 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : while (x = read byte from stream) does not equal 127: < 1316283344 90178 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : select based on value of (x >> 5): < 1316283344 110545 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : case 0: read byte from stream < 1316283344 110716 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : case 1: read short from stream < 1316283344 979552 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : case 2: read int from stream < 1316283346 717986 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : case 3: read float from stream < 1316283348 888623 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : case 4: read string (UCS-2) from stream < 1316283350 802893 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : case 5: read short, byte, short from stream; save as item stack (id, count, damage, respectively) < 1316283352 525003 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com JOIN :#esoteric < 1316283353 769007 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : case 6: read int, int, int from stream; save as extra entity information. < 1316283355 687025 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : end select < 1316283357 781157 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : end while < 1316283359 710397 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :What a beautiful serialisation. < 1316283361 801921 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :By beautiful, I mean ``augh''. < 1316283590 403636 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :is that pseudocode? or some language I'm not aware of? < 1316283594 102435 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :elliott: (x *> ((:) <\$> y) <* z <*> w) or ((:) <\$> (x *> y) <* z <*> w) or ((:) <\$> (x *> y <* z) <*> w) < 1316283599 974488 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :oh, must be pseudocode because of the "respectively" < 1316283600 812045 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Question mark < 1316283612 817204 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :the only language I can think of that has something even vaguely corresponding to that is COBOL < 1316283615 231093 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :ais523: pseudocode, yeah < 1316283627 80721 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: Um < 1316283633 354927 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :err, pun unintentional < 1316283635 97457 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :?. undo unpl ((:) <\$> (x *> y) <* z <*> w) < 1316283635 287442 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :(((((:)) <\$> (x *> y)) <* z) <*> w) < 1316283638 58022 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :God dammit < 1316283641 241746 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :and probably will be missed unless you know at least a bit of COBOL < 1316283644 899152 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :?. do unpl ((:) <\$> (x *> y) <* z <*> w) < 1316283645 83833 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :(((((:)) <\$> (x *> y)) <* z) <*> w) < 1316283647 341379 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :God dammit < 1316283653 199928 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :?. do unpl ((:) `fmap` (x *> y) <* z `ap` w) < 1316283653 372889 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :(do { b <- ((fmap ((:)) (x *> y)) <* z); a <- w; return (b a)}) < 1316283660 20024 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :?. do unpl ((:) `fmap` (x >> y) <* z `ap` w) < 1316283660 197892 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :(do { b <- ((fmap ((:)) (do { x; y})) <* z); a <- w; return (b a)}) < 1316283685 673925 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :?do let q a b = do x <- a; b; return x in (do { b <- ((fmap ((:)) (do { x; y})) `q` z); a <- w; return (b a)}) < 1316283686 21701 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :let { q a b = do { x <- a; b; return x}} in (do { b <- ((fmap ((:)) (do { x; y})) `q` z); a <- w; return (b a)}) < 1316283688 300599 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :>_<< < 1316283689 893539 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :>_< < 1316283696 908040 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: Yeah, I recommend something that looks nothing like that < 1316283718 180453 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :I'll just take the first option then < 1316283779 354325 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Well, I suppose I could use (:) <\$> between x z y <*> w < 1316283940 867976 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Hey Deewiant, what should I prefix/suffix/whatever field constructors with < 1316283949 350005 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :"string" and "bool" are a bit too close to clashing wit things for comfort < 1316283962 594943 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :f_ prefix is ugly, fInt is hideous, intF/stringF/... are just kinda weird < 1316283969 96000 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Clearly you have the perfect solution < 1316283972 581634 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Some say "don't, import qualified" < 1316283975 616574 :olsner!~salparot@c83-252-161-133.bredband.comhem.se PRIVMSG #esoteric :Deewiant: or something with liftA2 (:) or liftM2 (:), if you haven't already been there < 1316283981 46309 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: Hmm, that might actually be a good idea here < 1316284008 701497 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Yeah, that should work < 1316284019 905770 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Although "TF." is a bit long a prefix < 1316284026 822466 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :I don't want F., that's reserved for Foldable < 1316284719 951083 :Taneb!~nathan@host-78-146-164-99.as13285.net JOIN :#esoteric < 1316284806 769576 :Taneb!~nathan@host-78-146-164-99.as13285.net PRIVMSG #esoteric :How about GHost? < 1316284826 270195 :Taneb!~nathan@host-78-146-164-99.as13285.net PRIVMSG #esoteric :I'm not sure why I said that < 1316285391 546508 :copumpkin!~pumpkin@unaffiliated/pumpkingod JOIN :#esoteric < 1316286251 526286 :Taneb!~nathan@host-78-146-164-99.as13285.net NICK :Taneb|Hovercraft < 1316286274 127531 :oerjan!oerjan@tyrell.nvg.ntnu.no JOIN :#esoteric < 1316286298 163265 :Zuu!~zuu@unaffiliated/zuu QUIT :Ping timeout: 244 seconds < 1316286758 694930 :Taneb|Hovercraft!~nathan@host-78-146-164-99.as13285.net NICK :Taneb < 1316287354 987395 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :the Taneb has landed < 1316287419 275214 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :One feature idea I have for Haskell, is ability to define equivalence classes where you can specify that it should assume everything listed there is equivalent to each other. If the name of an equivalence class is mentioned, it will select whichever one has a matching type (or kind), and if more than one has, it selects one arbitrarily. The equivalence class has its own fixity. < 1316287469 762920 :Taneb!~nathan@host-78-146-164-99.as13285.net PRIVMSG #esoteric :What does anyone think of Salesman? < 1316287477 582486 :Taneb!~nathan@host-78-146-164-99.as13285.net PRIVMSG #esoteric :I'm trying to get opinions and feedback of it < 1316287487 227088 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :*MWAHAHAHA* < 1316287491 796789 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :Taneb: OK I will read it < 1316287496 819434 :Taneb!~nathan@host-78-146-164-99.as13285.net PRIVMSG #esoteric :http://esoteric.voxelperfect.net/wiki/User:Taneb/Salesman < 1316287599 635568 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :OK. Although, examples should be given, and a line break in the description of command 3 < 1316287877 274413 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :hmm, the joys of orthogonality: IMAP has a pair of commands that returns a message's UID, one takes a sequence number as argument, the other takes a message's UID as argument < 1316287916 275788 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :So it takes a message's UID and returns the message's UID? < 1316287925 401792 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :yep < 1316287928 619031 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :the id-eal command < 1316287949 257034 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :Does it return some sort of an error for a nonexistent message? < 1316287951 692750 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :the Perl library I'm reading actually has a wrapper for that command that actually sends it across the network < 1316287958 567110 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :umm, I think so < 1316287962 751014 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :but I'm not sure from the docs < 1316287962 769067 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :Then it's not so id-eal. < 1316288062 807913 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :@hoogle Set key -> key -> Maybe key < 1316288063 337961 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Did you mean: Set Key -> Key -> Maybe Key /count=20 < 1316288063 356175 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Prelude asTypeOf :: a -> a -> a < 1316288063 356313 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Data.Dynamic dynApply :: Dynamic -> Dynamic -> Maybe Dynamic < 1316288087 420998 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :elliott: < 1316288090 63799 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :> chr 42 < 1316288090 733801 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric : '*' < 1316288103 603424 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :that could be a useful command for monadic chaining < 1316288125 720391 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :hm < 1316288128 853141 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric ::t guarding < 1316288129 724434 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Not in scope: `guarding' < 1316288150 15286 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :i think someone suggested that once... < 1316288171 193243 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :@hoogle (x -> Bool) -> x -> m x < 1316288171 536389 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Prelude until :: (a -> Bool) -> (a -> a) -> a -> a < 1316288171 554636 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Data.IntMap filter :: (a -> Bool) -> IntMap a -> IntMap a < 1316288171 711196 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Data.Foldable find :: Foldable t => (a -> Bool) -> t a -> Maybe a < 1316288180 679498 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :@hoogle MonadPlus m => (x -> Bool) -> x -> m x < 1316288180 854786 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Prelude until :: (a -> Bool) -> (a -> a) -> a -> a < 1316288181 35350 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Data.IntMap filter :: (a -> Bool) -> IntMap a -> IntMap a < 1316288181 203529 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Data.Foldable find :: Foldable t => (a -> Bool) -> t a -> Maybe a < 1316288215 497659 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :^ord * < 1316288215 667889 :fungot!~fungot@momus.zem.fi PRIVMSG #esoteric :42 < 1316288220 626258 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :Unfortunately it doesn't do the inverse. < 1316288228 163937 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :?ty \x s -> fmap (const x) \$ guard (Data.Set.member x s) < 1316288228 888787 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :forall a (f :: * -> *). (Functor f, Ord a, MonadPlus f) => a -> S.Set a -> f a < 1316288234 890367 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :^show ord < 1316288234 908664 :fungot!~fungot@momus.zem.fi PRIVMSG #esoteric :>>,[[-<+2>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>[<[-]+>->+<[<-]]]]]]]]]]>]<2[>+6[<+8>-]<-.[-]<]+32.[-]>>,] < 1316288248 208441 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :fizzie: hm shouldn't be _too_ hard < 1316288263 927799 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: Can't type dem numbers either < 1316288348 69334 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :> map chr [fromIntegral (minBound :: Char)..] < 1316288348 748184 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric : No instance for (GHC.Real.Integral GHC.Types.Char) < 1316288348 920736 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric : arising from a use of... < 1316288355 565257 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Oops < 1316288359 397638 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :> map chr [ord (minBound :: Char)..] < 1316288360 270426 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric : "\NUL\SOH\STX\ETX\EOT\ENQ\ACK\a\b\t\n\v\f\r\SO\SI\DLE\DC1\DC2\DC3\DC4\NAK\S... < 1316288365 755655 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Bah < 1316288386 6678 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :hmm, interesting that the backslash-single-character escapes are in a block like that < 1316288419 318058 :Lymee!~moe@unaffiliated/cirno-chan PRIVMSG #esoteric :> text \$ "\NUL" < 1316288437 722148 :Lymee!~moe@unaffiliated/cirno-chan PRIVMSG #esoteric :> ord '\NUL' < 1316288438 465509 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric : 0 < 1316288471 627401 :Lymee!~moe@unaffiliated/cirno-chan PRIVMSG #esoteric :^ord joijio < 1316288471 802521 :fungot!~fungot@momus.zem.fi PRIVMSG #esoteric :106 111 105 106 105 111 < 1316288483 232593 :Lymee!~moe@unaffiliated/cirno-chan PRIVMSG #esoteric :^ord < 1316288486 363262 :Lymee!~moe@unaffiliated/cirno-chan PRIVMSG #esoteric :^ord aa aa < 1316288486 539806 :fungot!~fungot@momus.zem.fi PRIVMSG #esoteric :97 97 32 32 32 97 97 < 1316288504 947150 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :^ord asterisk < 1316288505 119352 :fungot!~fungot@momus.zem.fi PRIVMSG #esoteric :97 115 116 101 114 105 115 107 < 1316288509 687224 :Lymee!~moe@unaffiliated/cirno-chan PRIVMSG #esoteric :> ord '\SQH' < 1316288510 413314 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric : : < 1316288510 560276 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric : lexical error in string/character literal at chara... < 1316288521 69514 :Lymee!~moe@unaffiliated/cirno-chan PRIVMSG #esoteric :> chr 0 < 1316288521 765711 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric : '\NUL' < 1316288522 986610 :Lymee!~moe@unaffiliated/cirno-chan PRIVMSG #esoteric :> chr 1 < 1316288523 682687 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric : '\SOH' < 1316288563 281291 :Lymee!~moe@unaffiliated/cirno-chan PRIVMSG #esoteric :> chr 1 : "ACTION hugs oerjan" ++ [chr 1] < 1316288564 671567 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric : "\SOHACTION hugs oerjan\SOH" < 1316288571 495114 :Lymee!~moe@unaffiliated/cirno-chan PRIVMSG #esoteric :> text \$ chr 1 : "ACTION hugs oerjan" ++ [chr 1] < 1316288572 929463 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric : ACTION hugs oerjan < 1316288577 283855 :Lymee!~moe@unaffiliated/cirno-chan PRIVMSG #esoteric ::( < 1316288771 486301 :Taneb!~nathan@host-78-146-164-99.as13285.net QUIT :Remote host closed the connection < 1316288810 30027 :Taneb!~nathan@host-78-146-164-99.as13285.net JOIN :#esoteric < 1316289061 533356 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :^bf ,[>[->++++++++++<]>[-<+>]<<------------------------------------------------[>+<-],]>.!42 < 1316289061 704459 :fungot!~fungot@momus.zem.fi PRIVMSG #esoteric :* < 1316289066 494946 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :^help < 1316289066 665978 :fungot!~fungot@momus.zem.fi PRIVMSG #esoteric :^ ```; ^def ; ^show [command]; lang=bf/ul, code=text/str:N; ^str 0-9 get/set/add [text]; ^style [style]; ^bool < 1316289077 858719 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :^def chr bf ,[>[->++++++++++<]>[-<+>]<<------------------------------------------------[>+<-],]>. < 1316289078 39348 :fungot!~fungot@momus.zem.fi PRIVMSG #esoteric :Defined. < 1316289081 353646 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :^chr 42 < 1316289081 373800 :fungot!~fungot@momus.zem.fi PRIVMSG #esoteric :* < 1316289083 271565 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :^save < 1316289083 445940 :fungot!~fungot@momus.zem.fi PRIVMSG #esoteric :OK. < 1316289092 641882 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :(Not that elliott can still write any numbers.) < 1316289125 889075 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :(Human interest point: I first did that the wrong way around.) < 1316289139 970118 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :^bf ,[>,]<[>>[-<++++++++++>]<<------------------------------------------------[>+<-]<]>>.!24 < 1316289140 140000 :fungot!~fungot@momus.zem.fi PRIVMSG #esoteric :* < 1316289142 59298 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :Like that. < 1316289172 651069 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :^show chr < 1316289172 708218 :fungot!~fungot@momus.zem.fi PRIVMSG #esoteric :,[>[->+10<]>[-<+>]<2-48[>+<-],]>. < 1316289175 220077 :Taneb!~nathan@host-78-146-164-99.as13285.net QUIT :Remote host closed the connection < 1316289274 899192 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric : The idea with this is that you wouldn't have to define all that, and also wouldn't have to pack/unpack Lazy values (i.e. the reason laziness is awful in strict languages) :P < 1316289301 535968 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :if you could do this with data/codata instead, it might be useful for dependently typed languages... < 1316289384 74379 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :^bf +.,[.,]+.!ACTION still doesn't filter CTCP *shame* < 1316289384 230506 :fungot!~fungot@momus.zem.fi PRIVMSG #esoteric :ACTION still doesn't filter CTCP *shame* < 1316289397 340539 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :"One of these days." < 1316289398 759873 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :how does agda handle this? does it just define most functions twice for lists and streams? < 1316289438 743087 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :fizzie: secretly we all prefer it that way, just don't tell any admins < 1316289528 769631 :augur!~augur@208.58.5.87 QUIT :Remote host closed the connection < 1316289563 491427 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :or make an exception for ACTION < 1316289985 773499 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :If I manage to gather the willpower to actually filter it, maybe checking the first word wouldn't be such a huge hassle, yes. < 1316290141 393914 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Well, we're Plazmaless. :p < 1316290165 829424 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :we're a zolid bunch < 1316290177 680077 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :having a gaz < 1316290228 227914 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :elliott: also, i thought you were the resident agda expert < 1316290257 353120 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :i am? < 1316290269 9048 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :as in you've actually tried it, or something < 1316290308 820726 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :i guess some of the #haskellers might be even more likely < 1316290332 91800 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :(re my data/codata question) < 1316290497 775787 :copumpkin!~pumpkin@unaffiliated/pumpkingod PRIVMSG #esoteric :? < 1316290519 801009 :copumpkin!~pumpkin@unaffiliated/pumpkingod PRIVMSG #esoteric :yeah, you just define functions twice < 1316290530 704119 :copumpkin!~pumpkin@unaffiliated/pumpkingod PRIVMSG #esoteric :you do the same in haskell, fwiw < 1316290556 582441 :copumpkin!~pumpkin@unaffiliated/pumpkingod PRIVMSG #esoteric :the closest thing to a haskell list is a colist in agda < 1316290569 327585 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :yes, but it seems like it would be more annoying the more variations of a list there are < 1316290574 29452 :copumpkin!~pumpkin@unaffiliated/pumpkingod PRIVMSG #esoteric :certainly < 1316290586 858568 :copumpkin!~pumpkin@unaffiliated/pumpkingod PRIVMSG #esoteric :which is why people are especially interested in generics in dependent languages < 1316290597 685664 :copumpkin!~pumpkin@unaffiliated/pumpkingod PRIVMSG #esoteric :the levitation stuff in epigram, for example < 1316290607 583629 :copumpkin!~pumpkin@unaffiliated/pumpkingod PRIVMSG #esoteric :or the ornamentation < 1316291074 815899 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :I want to change rules of Magic: the Gathering cards, I have a lot of ideas. < 1316291112 808867 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :* Each object which is a card has an initial state, which corresponds to what is printed on the card and is immutable. Other objects have no initial state and cannot be given any. < 1316291159 531026 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :* When an object moves from one zone to another, except for stack->play, and phasing, the old object is destroyed and a new object created from the old object's initial state is placed in the new zone. < 1316291205 87358 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :* There is no state-based effect for tokens out of play ceasing to exist. Instead, the above rule applies, which has a similar effect. < 1316291215 145247 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :* Copies of spells on the stack are the same things as tokens. < 1316291251 799576 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :* No state based effects for auras or equipments that are also creatures. Something that is both a creature and an aura still is both things with no conflict. < 1316291274 724319 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :* If a nonexistent object would deal damage, that damage is prevented. < 1316291279 194612 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :hmm, next issue: what if someone sends an HTML email, or GPG-signed email (both quite likely to happen on our systems) < 1316291311 803452 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :ais523: what issue? < 1316291320 252864 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :* Losing due to being unable to draw a card is not a state based effect; it happens immediately. < 1316291331 998067 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :elliott: with the system I'm writing for work < 1316291334 30261 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :(Before state-based effects are checked) < 1316291342 426062 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :what we really want is just to receive plain text as the email body < 1316291343 965454 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :ais523: I mean, why is that an issue? < 1316291351 318895 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :GPG is just cruft above and below the message < 1316291354 482810 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :because I can't exactly run HTML through an OCaml parser < 1316291356 84639 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :But uh < 1316291361 919206 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Grep Python's stdlib for MIME :P < 1316291365 579684 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :ais523: wait, what? < 1316291373 651710 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :whatever you're doing, stop, I don't care who told you to do it < 1316291382 472005 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :elliott: running arbitrary code emailed to me? < 1316291392 678709 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :I believe I already told you to stop < 1316291395 986360 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :nah, I'm not quite that mad < 1316291406 804208 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :I don't really care what it is, I know enough < 1316291424 419921 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :just you telling me to stop won't stop me designing something I'm being paid to do < 1316291442 485105 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :* Mana burn still works (that is one of the rules changed in the new rules; I don't know all the changes) < 1316291455 3751 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :ais523: i can no longer talk to you in good conscience :( < 1316291457 272393 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :gmail being involved is ridiculous enough as it is < 1316291464 519653 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :seriously, though, why are you so upset about this? < 1316291476 250247 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :parsing user input is hard, especially when it comes from students < 1316291484 640812 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric : because I can't exactly run HTML through an OCaml parser <-- just consider it a CHALLENGE < 1316291491 259219 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :you're feeding html mail into the ocaml parser < 1316291494 394988 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :that's never ok :( < 1316291497 29866 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :no, I'm not < 1316291500 158233 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :at least, I don't want to < 1316291511 424371 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :you want to turn it into text then feed it into the ocaml parser which is just as bad < 1316291512 297038 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric ::P < 1316291513 322019 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :* Rules for playing land cards no longer overrides rules for other types. (Existing Artifact Lands will still act as they do; but if you make an Artifact Land with a mana cost, you can now play the card as either an Artifact or as a Land, because the mana cost allows you to do so.) < 1316291513 863066 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :so the challenge is to figure out when I'm sent HTML mail, and look for the plaintext portion, or at worst detag it myself < 1316291524 531630 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :what language? < 1316291541 549100 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :elliott: there's no way you're going to get a yearful of students to get it right when they can't even do CSV right < 1316291551 694373 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :what language are you writing this in, I mean? < 1316291553 89822 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :I'm using Perl for the glue code, but the OCaml parser itself is in OCaml < 1316291563 540407 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :heh < 1316291577 522714 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :ais523: Would it help to convert HTML mail into ANSI escape sequences? < 1316291601 228303 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :zzo38: I'd prefer to convert it into plain Unicode < 1316291603 810018 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :i recall back when i found ocaml, ocamlyacc still was based around a modified yacc in C < 1316291610 178878 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :or even ASCII would do < 1316291637 663582 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :oerjan: nicw < 1316291638 709277 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :nice < 1316291652 40787 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :ais523: OK, that would do, I suppose. Although it loses formatting in case there is any important formatting < 1316291668 986436 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :elliott: it'd be fun to punish the students for sending HTML email, but I really doubt I could get away with that < 1316291677 14006 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :especially because it's basically impossible to do in most webclients < 1316291685 748606 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :ais523: p.s. I want to confess that I've just willingly used git to version control something that I could have put into darcs without much trouble < 1316291688 585514 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :i'm sorry :( < 1316291691 197270 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :zzo38: well, they're meant to be sending programs, and I think I can dispense with syntax highlighting < 1316291700 615859 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :OK < 1316291702 549357 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :elliott: it's OK < 1316291710 267431 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :"especially because it's basically impossible to do in most webclients" -- what, send html mail? :-) < 1316291712 16906 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :git might be utterly broken, but it still works well enough to be usable < 1316291715 385925 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :elliott: send plaintext mail < 1316291718 647297 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :ais523: is it ok if I partly did it for github? :-P < 1316291735 966430 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :ACTION laughs at the question, but doesn't answer < 1316291753 599273 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :oh lame, github's haskell syntax highlighting doesn't recognise template haskell's overloading of the character quoting character < 1316291756 385868 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :i want my money back < 1316291763 17981 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :(TH has the worst syntax imaginable) < 1316291771 459909 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :(character literal in haskell: 'a', '\n') < 1316291777 780634 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :(reference to name foo in template haskell: 'foo) < 1316291784 224079 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :ouch < 1316291793 143350 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :(pop quiz: how do you get a reference to the name x', which is of course perfectly legal?) < 1316291794 747650 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :OCaml uses 'a for type variables < 1316291801 495534 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :(hint: you don't, you have to use mkName manually) < 1316291818 535756 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :oh, and ''Foo is the same at the type level < 1316291823 256320 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :because it wasn't confusing enough < 1316291863 879523 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :elliott: I was really impressed with Kate's syntax highlighting of Perl < 1316291864 844048 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :I recognized that problem immediately when reading about Template Haskell syntax. < 1316291872 319185 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :it managed stuff that confused all the other editors I tried < 1316291891 519854 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :starting things with \$ also doesn't seem very nice, but at least you can use space then < 1316291892 748110 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :ais523: well, the KDE folks need _something_ to win the flamewars with < 1316291901 662489 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :so they got a perl junkie to spend a few weekends on it :P < 1316291923 373147 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :"oh, well, I quite like ema-" "CAN YOUR PRECIOUS EMACS HIGHLIGHT THIS????" < 1316291926 681810 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :I actually downloaded a Perl port of the source for Kate's syntax highlighter < 1316291934 796787 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :for reasons I can't quite remember < 1316291945 771059 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :maybe it'll come in useful some day < 1316291946 933536 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :I happen to think Template Haskell syntax works OK, though, even though there is that problem < 1316291957 327096 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :it works, it just isn't very nice < 1316292001 349823 :monqy!~swell@pool-71-102-215-70.snloca.dsl-w.verizon.net JOIN :#esoteric < 1316292018 505407 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :arcane monqy. how are the curts wronrging. < 1316292019 703755 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :Currently at FreeGeek Vancouver, UNIX-to-UNIX mail doesn't work. The system administrator says he will fix it soon, and that the software already has this capability it only has to be configured. He also says Internet-to-UNIX mail will be configured (UNIX-to-Internet already works). < 1316292032 8172 :monqy!~swell@pool-71-102-215-70.snloca.dsl-w.verizon.net PRIVMSG #esoteric :whats a curt < 1316292032 567321 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :now I need to work out how to send an HTML email, as a test for this thing < 1316292036 369769 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :just to see what it comes up with < 1316292036 883449 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :zzo38: like... UUCP? < 1316292052 108471 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :ACTION tries to work out how to send HTML mail from Evolution < 1316292073 956294 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :ah, there's a dropdown < 1316292086 168814 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :be a bad person: [yes] [no] < 1316292088 113457 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :except < 1316292090 203395 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :as a dropdown < 1316292123 605167 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :indeed < 1316292137 33572 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :you have selected < 1316292140 178057 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :to be a bad person < 1316292143 523851 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :you must now face the consequences :( < 1316292194 459386 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :elliott: Actually, I mean to a different user on the same computer. < 1316292197 95117 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :aha, Evolution sends a plaintext component, then the HTML component after that < 1316292200 751457 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :that's actually really nice behaviour < 1316292224 614065 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :anyone here who uses Thunderbird? could you send me an HTML mail with a bit of formatting in, so I can see how it behaves? < 1316292246 466786 :monqy!~swell@pool-71-102-215-70.snloca.dsl-w.verizon.net PRIVMSG #esoteric :oh no, as i feared, brainlove is Bad < 1316292259 40990 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :hmm, apparently the fucking weather is fucking ...alright < 1316292267 294052 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :i don't know whether to agree or not < 1316292273 591719 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :ais523: I use gmail < 1316292276 91126 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :ais523: can i still send html mail < 1316292297 856282 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :well, that's less useful, because the students /should/ be using their University accounts < 1316292312 872527 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :which means that they should be sending from Thunderbird or Outlook Web Access (*shudder*) < 1316292327 380016 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :and I definitely don't trust OWA to do anything sane, but I was hoping with Thunderbird < 1316292330 236415 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :MC/Protocol.hs:1:1: Error: Unused LANGUAGE pragma < 1316292330 560162 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Found: < 1316292330 578486 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric : {-# LANGUAGE TemplateHaskell #-} < 1316292330 578652 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Why not remove it. < 1316292330 578764 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :because it's not unused, you presumptuous program >:( < 1316292332 308254 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :ais523: "should" < 1316292347 208099 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :elliott: "should" in that we're at least justified if we deny them marks for using something else < 1316292361 181613 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :ais523: deny someone marks for avoiding Outlook Web Access? < 1316292364 839224 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :because those are the only clients they're given on their University account, which is the one they're meant to use < 1316292366 406623 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :you're horrible < 1316292369 715211 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :I don't like the new ais523 < 1316292372 921592 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :hey, I didn't make the rules < 1316292382 906051 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :that's what the Nazis said! < 1316292385 870137 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :how I'd love to say "use mail(1) only" < 1316292391 619482 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :and avoid all these issues < 1316292422 751118 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :I too would say use UNIX mail, if the computer is UNIX you would use it. However, some people might use other program anyways. < 1316292963 138843 :augur!~augur@129.2.129.32 JOIN :#esoteric < 1316293112 177298 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :Did someone tell me before that do-notation with the (x ->) monad does correspond to something in Curry-Howard? Can you please remind me? < 1316293114 293553 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :My inbox has bazillion emails from Thunderbird (it's the quasi-official client in our desktop installation, I think) but so far all of them have been plaintext-only. < 1316293187 87394 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :"Microsoft Office Outlook 12.0" has sent a multipart/alternative message, with a text/plain copy first, and a text/html copy after. That I think is the "usual way". < 1316293290 965486 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :I think what I'll do is parse it, and take the first text/plain part I come across < 1316293292 530434 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :ais523: I sent you some HTML mail just in case < 1316293301 413303 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :I think your spam filter might block it thoug < 1316293301 808407 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :h < 1316293309 325655 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :is it that spammy? < 1316293313 778877 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :It's a masterpiece. < 1316293319 178915 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :I haven't received it, at least < 1316293326 184546 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :"viagra cialis" appears more than once. < 1316293330 223922 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Also there's some Haskell in it. < 1316293334 267314 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :It's pink. < 1316293354 691346 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :I did get one incredibly complicated-looking MIME subpart tree from a student once. < 1316293359 252031 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Wow, the text/plain version is almost not entirely fucked up, too. < 1316293366 16986 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :(Mutt's message-part-viewer shows it as a tree.) < 1316293442 205743 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :hmm, I'm going to send myself some OCaml as an attachment, just to see what content-type it gets < 1316293444 761933 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: So what manner of trifunctory stuff would you want to see in the hypothetical tuple-combinators < 1316293453 484143 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :I'm hoping for text/x-ocaml, but that seems really implausible < 1316293476 268631 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :elliott: trimap, first3/second3/third3 < 1316293496 775253 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :(Do we already have thd/trd and friends in base somewhere?) < 1316293501 480809 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: What signature would trimap have exactly, I'm trying to think of a use-case for this < 1316293509 494049 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Oh < 1316293511 59244 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :For three-ples < 1316293513 537964 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Like bimap but for three < 1316293525 12703 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :hmm, at least the involvement of gmail was the least complex part in all of this < 1316293528 632543 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :I have this kind of belief that using anything more than a tuple is bad. Is that bad of me? < 1316293540 505317 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :It feels like once you get to that point you need to start naming something. < 1316293542 594459 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :s/tuple/pair/ < 1316293546 465266 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Yeah yeah < 1316293547 334460 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :two-ple < 1316293554 304039 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :I think three isn't that bad < 1316293575 59973 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :I think I took a screencap of the complicatedness, but it's hard to find anything when all the names are like "florb.png". < 1316293583 231738 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :?ty Data.Map.splitLookup < 1316293583 928773 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :forall k a. (Ord k) => k -> M.Map k a -> (M.Map k a, Maybe a, M.Map k a) < 1316293593 340029 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: I'd kind of prefer Trifunctor to be in a separate trifunctors package, but that feels like it's a slippery slope towards Kmett package dominance < 1316293602 431256 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Yeah, I know < 1316293610 139264 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Finally we can replicate Control.Arrow specialised to functions with only fifty import < 1316293610 500741 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :s < 1316293674 170167 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :Also there's a "blurg.png". < 1316293678 711976 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :elliott: a 3-item tuple is called a triple < 1316293685 555166 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :given that people here seem to have had issues finding the name < 1316293700 680676 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :I wish I had a nicer name than tuple-combinators < 1316293701 200614 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :Perhaps it should be called a "trubble", because it's nothing but trouble? < 1316293701 897169 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :zzo38: i think i said something about the "decision theorem", which i then failed to google, but it's essentially about proving a -> b by assuming a locally as an axiom and proving b from that, which to me seems similar to what the (x ->) monad allows you to do < 1316293713 539964 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :elliott: Subject: [SPAM?] SPAM: example viagra cialis hexham didgeridoo < 1316293726 430224 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :it seems to have been greylisted and marked as possible spam by one filter and certain spam as another < 1316293726 776395 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :ais523: Yessssssssssssss < 1316293732 809790 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :but not to the extent that it wasn't delivered at all < 1316293735 286710 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :I hope I'm on blacklists now < 1316293743 188400 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :what's with all the GIF images? < 1316293745 283129 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: Yo, better name than tuple-combinators, hit me < 1316293752 637992 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :ais523: Emojis! < 1316293753 682514 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :tumbinators < 1316293754 903965 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Gmail supports them nowadays. < 1316293762 792333 :monqy!~swell@pool-71-102-215-70.snloca.dsl-w.verizon.net PRIVMSG #esoteric :viagra cialis hexham didgeridoo < 1316293765 560791 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :They're even in Unicode! < 1316293773 472837 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :But I doubt you have a font with the PILE OF POO character in it, so I used the images instead. < 1316293780 718315 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :wow, it hit a 7.4 on spam score < 1316293782 983363 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :that's pretty high < 1316293783 156097 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :I neglected to include GOAT. < 1316293791 199125 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :It's a pretty spammy message. < 1316293840 617151 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :strangely, it was knocked down 0.7 for the reputation of your account < 1316293848 316827 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :it'd have been 8.1 from an unrecognised sender < 1316293853 97832 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :oerjan: OK, yes I suppose I can see how that works with do-notations. < 1316293872 649985 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :ais523: haha < 1316293877 812142 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :good to know I have the karma < 1316293903 252022 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :the pharmaceutical-related words make up most of the spam score, it seems < 1316293918 216434 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :zzo38: oh wait now i suddenly remembered and no wonder i couldn't google it, it's called the _deduction_ theorem. http://en.wikipedia.org/wiki/Deduction_theorem < 1316293926 538491 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :also, it seems it has 10 nested blockquotes < 1316293935 167759 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :ais523: One of our departmental "little christmas" parties had (as one of the multitude of activities they usually have) a SPAM competition; there was a console set up on a desk, and you typed a handle and a message, and then it ran SpamAssassin on the message and showed a highscore list of handles and corresponding spam scores. < 1316293949 361827 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :oerjan: Yes, and I think what you describe is also like what is called "fantasy rule" in Hofstadter's book, which I already figured out before, which is why I asked about do-notation, because it seem to do the fantasy rule. < 1316293950 583882 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :haha < 1316293965 125720 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :it might be quite hard to get control of a blacklisted spam domain to bump the score up higher < 1316293980 258219 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: Hmm, wait, isn't bimap a superset of (&&&)'s type < 1316293982 354804 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :although we managed it with Normish, seems the IP had belonged to a spammer before Normish gained it < 1316293988 682636 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :I think it just fed the message as-is to SA, so you got to write all kinds of headers into it. < 1316293990 250164 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :and it took a while to get it off the blacklists < 1316294008 44120 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :elliott: No, it's a superset of (***) restricted to functions < 1316294016 803654 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :(So really, it's disjoint) < 1316294025 167683 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Oh, hmm, right < 1316294035 810474 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :I'm new to this fancy bifunctor shit :-P < 1316294064 57382 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Is there really no way to avoid the explicit (,) in that triple-ampersands implementation? < 1316294066 878966 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :It's soooo inelegant. :p < 1316294088 491818 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :If you can think of a way of going from a to (a,a) without a (,), sure < 1316294109 403306 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :Deewiant: It seem to me, the way would be: join (,) < 1316294114 794510 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Without a (,) < 1316294118 270828 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :zzo38: That's not without a (,) < 1316294133 693800 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :Deewiant: I know. But I don't know why you don't want (,) < 1316294138 947696 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :zzo38: oh there's something possibly relevant in that wp article: "Under the Curry–Howard correspondence, the above conversion process for the deduction meta-theorem is analogous to the conversion process from lambda calculus terms to terms of combinatory logic, where axiom 1 corresponds to the K combinator, and axiom 2 corresponds to the S combinator. Note that the I combinator corresponds to the theorem schema P→P. < 1316294146 622797 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :zzo38: elliott just stated why. < 1316294191 646616 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :Of course you can write (a,a) but I don't know if that counts. < 1316294199 496518 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :and the SKI combinators are ap, return, ask in the (x ->) monad < 1316294236 742310 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :I know return = const so that is K combinator. < 1316294253 896225 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :I have not heard of "ask" < 1316294260 473651 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :thread :: (a -> b) -> (c -> d) -> (a,c) -> (b,d) < 1316294260 647402 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :combine :: (a -> b) -> (a -> c) -> a -> (b,c) < 1316294261 347849 :monqy!~swell@pool-71-102-215-70.snloca.dsl-w.verizon.net PRIVMSG #esoteric :it's from Reader < 1316294264 250052 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: Whaddya think of those names < 1316294269 13536 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :With thread just being defined as bimap ofc < 1316294278 283595 :monqy!~swell@pool-71-102-215-70.snloca.dsl-w.verizon.net PRIVMSG #esoteric :there's a MonadReader instance for (a ->) < 1316294293 441855 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :They sound as arbitrary as the names of the polarities of bfjoust < 1316294304 479939 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: I put thought into those :( < 1316294320 37366 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :"combine" is about as generic a name as possible < 1316294321 608832 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: With the first, you can imagine two completely separate bits of string that you want to meet at the inputs and outputs < 1316294332 930528 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :So you thread them together through two little holes < 1316294338 549015 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :And that threading is the result < 1316294342 905077 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :I can imagine that, or I can imagine something completely different < 1316294348 304821 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Pah < 1316294353 963257 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :forkIO could be called thread :-P < 1316294354 319908 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Gimme nice operator names then :P < 1316294368 57605 :MDude!~fyrc@or-67-238-31-252.dhcp.embarqhsd.net QUIT :Ping timeout: 252 seconds < 1316294370 149117 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :"split" would be good for combine < 1316294375 110117 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :but it's taken by Data.List.Split < 1316294382 857071 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :?ty split < 1316294383 555651 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :forall g. (RandomGen g) => g -> (g, g) < 1316294387 739591 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :?ty Data.Map.split < 1316294388 438623 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :forall k a. (Ord k) => k -> M.Map k a -> (M.Map k a, M.Map k a) < 1316294397 806456 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :But of course I is id, and K is const. < 1316294404 3527 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Hmm, pointless-haskell does < 1316294411 355459 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :(/\) :: (a -> b) -> (a -> c) -> a -> (b, c) < 1316294417 179122 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric ::t join (curry id) < 1316294417 883308 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :forall b. b -> (b, b) < 1316294418 833455 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :(><) :: (a -> b) -> (c -> d) -> (a, c) -> (b, d) < 1316294426 152669 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :?hoogle (><) < 1316294426 208272 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :Deewiant: ^ < 1316294426 325942 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Data.Sequence (><) :: Seq a -> Seq a -> Seq a < 1316294426 509194 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Data.Graph.Inductive.Query.Monad (><) :: (a -> b) -> (c -> d) -> (a, c) -> (b, d) < 1316294429 465249 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Ugh < 1316294442 403335 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :oerjan: s/Deewiant/elliott/ < 1316294448 240458 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :elliott: ^ < 1316294486 167952 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :oerjan: Not the point :-P < 1316294490 126833 :MDude!~fyrc@or-67-238-31-252.dhcp.embarqhsd.net JOIN :#esoteric < 1316294502 219169 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :In[1]:= ?Thread < 1316294502 237566 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :Thread[f[args]] "threads" f over any lists that appear in args < 1316294506 223320 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :That second (><) is the same one though < 1316294506 571648 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :See, that's what "thread" does. < 1316294508 138104 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: Heh, it then goes on to do (\/) :: (b -> a) -> (c -> a) -> Either b c -> a < 1316294529 960591 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :I'd have \/ and /\ the other way around < 1316294530 484553 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :zzo38: ask is a method of MonadReader, which (x ->) belongs to < 1316294539 527036 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :>_< < 1316294549 373360 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :oerjan: OK < 1316294554 7739 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Which logical operator is /\ again < 1316294556 272816 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :I always mix 'em up < 1316294561 99564 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :And < 1316294561 443807 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :The one that's and should be the tuple one :P < 1316294565 101803 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Then it's correct < 1316294568 939671 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Either ~ or, so \/ < 1316294571 765877 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :(,) ~ and, so /\ < 1316294572 285277 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :heh < 1316294581 351406 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Fair enough I guess < 1316294594 779488 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :?hoogle (a -> b) -> (c -> d) -> (a,c) -> (b,d) < 1316294594 952221 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Data.Graph.Inductive.Query.Monad (><) :: (a -> b) -> (c -> d) -> (a, c) -> (b, d) < 1316294597 218899 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric : But of course I is id, and K is const <-- i meant that they are monadic functions from the (x ->) monad < 1316294598 294302 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Hmph < 1316294605 64946 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :?hayoo < 1316294605 235884 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Nobody has a nicer operator name for it? :-P < 1316294605 254105 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Unknown command, try @list < 1316294616 608199 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :?ty (|||) < 1316294617 297672 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :forall (a :: * -> * -> *) b d c. (ArrowChoice a) => a b d -> a c d -> a (Either b c) d < 1316294626 619642 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Hmf < 1316294633 901041 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :OK, so the names are: < 1316294636 870214 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :(><) < 1316294637 218896 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :elliott: |,| ? :-P < 1316294637 391792 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :cross < 1316294639 479886 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :(-asterisk-) < 1316294641 218093 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :pairApply < 1316294644 180415 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :(asteriskasteriskasterisk) < 1316294675 978773 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: I'd go for || were it not taken < 1316294682 345246 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :oerjan: OK. < 1316294689 265482 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: Actually >< is quite brilliant graphically, it shows the two unrelated functions "meeting" in the middle < 1316294692 48866 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :I'd go for |,| if you don't want to override ||| < 1316294693 790277 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Input below/above, output above/below < 1316294703 719948 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Right, >< is fine as well < 1316294705 168005 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :But |,| is not a name in Haskell < 1316294705 288484 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Hmm, /\ does the same < 1316294710 514957 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :It isn't? < 1316294714 44115 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Two separate functions < 1316294716 657319 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :One from the left < 1316294718 50899 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :One from the right < 1316294720 707374 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :And a single output value at the top < 1316294738 117519 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Deewiant: What fixity :-P < 1316294744 75056 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :I'm terrible at fixities < 1316294744 773212 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Always < 1316294750 776916 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Ditto < 1316294753 736634 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :Darn < 1316294756 874576 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :I'll copy Control.Arrow's < 1316294761 602137 :elliott!~elliott@unaffiliated/elliott PRIVMSG #esoteric :But first, I'll sleep. < 1316294778 462917 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :I guess you want . to bind tighter < 1316294795 289606 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :Deewiant: commas are punctuation and cannot be used in operators < 1316294801 811439 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Darn < 1316294814 768633 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :same with semicolons. although not colons... < 1316294909 138754 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :also not brackets or quotes, except ' is generally messed up < 1316295027 362608 :elliott!~elliott@unaffiliated/elliott QUIT :Ping timeout: 260 seconds < 1316295058 787389 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :"Comma is a semi-semicolon", to quote a Perl document. < 1316295068 310520 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :I don't know why but it sounds funny. < 1316295102 784820 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :it's because they were really stretching for mnemonics at that point < 1316295111 422891 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :and pretty much admitted as much < 1316295117 424060 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :> let a |!@#\$%&/=?+\^~*-:. b = a + b in 2 |!@#\$%&/=?+\^~*-:. 2 < 1316295118 54161 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric : 4 < 1316295129 29742 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :oh wait < 1316295138 710007 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :> let a |!@#\$%&/=?+\^~*-:.<> b = a + b in 2 |!@#\$%&/=?+\^~*-:.<> 2 < 1316295139 579157 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric : 4 < 1316295207 716120 :pikhq!~pikhq@71-219-229-69.clsp.qwest.net JOIN :#esoteric < 1316295221 459143 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :I might think a semi-semicolon would be some sort of a "two commas vertically" instead. Haven't found a real character for that from Unicode yet, though of course you can put a "combining comma above" on a comma, like ,̓ that. < 1316295254 12666 :itidus21!~itidus21@120.147.173.44 PRIVMSG #esoteric :`pastelogs fuckton < 1316295260 207432 :HackEgo!foobar@codu.org PRIVMSG #esoteric :http://codu.org/projects/hackbot/fshg/index.cgi/raw-file/tip/paste/paste.21829 < 1316295314 70432 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :35 of every 80 fucktons are metric. < 1316295464 165584 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :The character ' in Haskell is a letter that is neither uppercase nor lowercase. (I think) < 1316295489 954348 :monqy!~swell@pool-71-102-215-70.snloca.dsl-w.verizon.net PRIVMSG #esoteric :letter? < 1316295569 727530 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :Content-Type: text/x-ocaml; < 1316295573 733960 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :oh Evolution I love you < 1316295585 77721 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :although I'm not entirely sure how you figured it out < 1316295599 45921 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :perhaps from the extension, although .ml could mean all sorts of ML-family languages < 1316295688 191697 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric : and are in my /usr/share/mime/text/x-ocaml.ml. < 1316295693 612432 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :(And no other conditions.) < 1316295709 117669 :Deewiant!~deewiant@cs27125254.pp.htv.fi PRIVMSG #esoteric :Shameful < 1316295724 811263 :pikhq_!~pikhq@71-219-250-231.clsp.qwest.net JOIN :#esoteric < 1316295731 281514 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :fizzie: ditto in mine, that must be it < 1316295734 67287 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :I didn't know that file existed < 1316295753 25343 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :it also has "OCaml source code" translated into a lot of languages < 1316295755 448465 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :It's the modern way to do /etc/mime.types. < 1316295809 838117 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :so there's a good chance I will get text/x-ocaml attachments after all < 1316295842 597842 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :I suppose I could just run an OCaml parser over every part of the message (after decoding and deHTMLing) to see which parsed correctly < 1316295876 430861 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :monqy: ' is used for character constants, but also in otherwise alphanumeric identifiers. but because of the former it cannot be used at the beginning of identifiers. < 1316295897 3404 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :use ACME::Don't; < 1316295914 692088 :pikhq!~pikhq@71-219-229-69.clsp.qwest.net QUIT :Ping timeout: 260 seconds < 1316295947 532259 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :I guess it could also be using "file --mime", which has a magic-db contents of http://p.zem.fi/hws1 < 1316295961 214390 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :monqy: "neither uppercase or lowercase" sort of fits to characterize that in haskell, because haskell distinguishes those in meaning at the beginning of identifiers. btw _ is then lowercase. < 1316295961 232449 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :(Do they all really start with "Caml1999"?) < 1316295990 301120 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :I suppose that's for the more compiled file types, not the source. < 1316296018 946571 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :monqy: and : is the only uppercase _operator_ character :P < 1316296052 693179 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :hmm, the author of MIME::Parser is insistent that storing parsed MIME components of email in memory is a security risk in case someone emails you a many-gigabyte attachment < 1316296078 222951 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :I'm getting around it by refusing to parse emails more than a megabyte long, on the basis that that's /quite/ enough for one short OCaml program < 1316296118 141307 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :fizzie: the standard compiled bytecode actually starts with a shebang < 1316296274 437543 :monqy!~swell@pool-71-102-215-70.snloca.dsl-w.verizon.net PRIVMSG #esoteric :: being the only uppercase operator character...is that why all the type/data constructor operators start with : < 1316296314 12485 :monqy!~swell@pool-71-102-215-70.snloca.dsl-w.verizon.net PRIVMSG #esoteric :At least I think I've only seen them ever start with : < 1316296337 667635 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :bleh, a search for "which punctuation marks are uppercase?" gave me no results < 1316296345 176153 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :(with the quotes; without, it gave only irrelevant results) < 1316296355 612423 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :I was hoping for some crazy answer < 1316296411 960946 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :and "uppercase punctuation" gives me just pages which meant to say "uppercase, punctuation" or "uppercase/punctuation" but screwed up the punctuation mark between them < 1316296679 92175 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :Is there any standard function for "foldr (.) id"? < 1316296882 818749 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :monqy: yep, precisely < 1316296898 91086 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric ::t foldr (.) id < 1316296898 965356 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :forall b. [b -> b] -> b -> b < 1316296956 503670 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :@hoogle [b -> b] -> b -> b < 1316296956 851900 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Data.Generics.Schemes everywhere :: (a -> a) -> a -> a < 1316296957 19303 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Data.Generics.Schemes everywhere' :: (a -> a) -> a -> a < 1316296957 37207 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Prelude until :: (a -> Bool) -> (a -> a) -> a -> a < 1316296965 548427 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :zzo38: i don't know of any < 1316296972 686453 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric ::t foldr (\$) < 1316296973 382991 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :forall b. b -> [b -> b] -> b < 1316296984 983447 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric ::t flip (foldr (\$)) < 1316296985 679649 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :forall b. [b -> b] -> b -> b < 1316296995 857851 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :i think that's equivalent < 1316297032 336924 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :I suppose I can define it in my program then. What should it be called? < 1316297043 368669 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :@hoogle f (b -> b) -> b -> b < 1316297043 717954 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Data.Generics.Schemes everywhere :: (a -> a) -> a -> a < 1316297043 925026 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Data.Generics.Schemes everywhere' :: (a -> a) -> a -> a < 1316297043 946243 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Prelude until :: (a -> Bool) -> (a -> a) -> a -> a < 1316297060 350425 :monqy!~swell@pool-71-102-215-70.snloca.dsl-w.verizon.net PRIVMSG #esoteric :compose? composes? composed? < 1316297098 932018 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :@hoogle (a -> m) -> t a -> m < 1316297099 302741 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Prelude (\$) :: (a -> b) -> a -> b < 1316297099 476371 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Prelude (\$!) :: (a -> b) -> a -> b < 1316297099 494269 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Data.Function (\$) :: (a -> b) -> a -> b < 1316297125 42906 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :@hoogle (Monoid m, Foldable f) => (a -> m) -> f a -> m < 1316297125 392765 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Data.Foldable foldMap :: (Foldable t, Monoid m) => (a -> m) -> t a -> m < 1316297125 410708 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Data.Traversable foldMapDefault :: (Traversable t, Monoid m) => (a -> m) -> t a -> m < 1316297125 566294 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Data.Foldable all :: Foldable t => (a -> Bool) -> t a -> Bool < 1316297125 658300 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :Is @hoogle broken? < 1316297135 729817 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric ::t foldMap Endo < 1316297136 427291 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Not in scope: `foldMap' < 1316297148 656587 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric ::t Data.Foldable.foldMap Endo < 1316297149 563975 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :forall a (t :: * -> *). (Data.Foldable.Foldable t) => t (a -> a) -> Endo a < 1316297177 248342 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :hm or is that in the direction < 1316297190 51025 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :zzo38: how so? < 1316297201 135392 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :It makes responses which don't match < 1316297225 716572 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :zzo38: yes it tries to guess if you meant something different if there's no exact match < 1316297240 841743 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric : 12.8 htkallas 9/18 01:07 0+00:00:00 [????????????????] < 1316297246 237588 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :That does not look good. < 1316297260 919429 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :It's supposed to say where my job is running. < 1316297390 774932 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :@hoogle (Arrow a) => [a b b] -> a b b < 1316297390 950862 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Data.Map unions :: Ord k => [Map k a] -> Map k a < 1316297391 126890 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Data.Graph.Inductive.Internal.Heap mergeAll :: Ord a => [Heap a b] -> Heap a b < 1316297391 145761 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Data.Graph.Inductive.Basic grev :: DynGraph gr => gr a b -> gr a b < 1316297412 548300 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :XMonad calls it (well, something a bit like it; in fact it composes ManageHooks) "composeAll". < 1316297467 605149 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :zzo38: what worries me more is that it required me to add the Monoid and Foldable class before it gave anything useful, that's stupid. < 1316297468 650910 :fizzie!fis@iris.zem.fi PRIVMSG #esoteric :But that's possibly because it also has a composeOne, which runs only the first on the list that actually does something. < 1316297477 382549 :sebbu!~sebbu@unaffiliated/sebbu QUIT :Ping timeout: 260 seconds < 1316297520 577839 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :it seems obvious to me that adding those should be a smaller change than modifying the actual type part to something incompatible... < 1316297538 249859 :sebbu!~sebbu@unaffiliated/sebbu JOIN :#esoteric < 1316297611 497542 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :@hoogle (Category a) => [a b b] -> a b b < 1316297611 846144 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Data.Map unions :: Ord k => [Map k a] -> Map k a < 1316297611 864171 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Data.Graph.Inductive.Internal.Heap mergeAll :: Ord a => [Heap a b] -> Heap a b < 1316297611 864333 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Control.Category (.) :: Category cat => cat b c -> cat a b -> cat a c < 1316297680 456611 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric ::t foldr`flip`id < 1316297681 148695 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :forall a a1. (a -> (a1 -> a1) -> a1 -> a1) -> [a] -> a1 -> a1 < 1316297689 471638 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :oops < 1316297714 316425 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :oh right < 1316298143 188364 :ive!~nn@189.179.246.222 QUIT :Ping timeout: 252 seconds < 1316300354 888239 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :data Many a = One a | Many (Many a) < 1316300358 718277 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :I wonder what you could use this for. < 1316300387 444567 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :it seems to just associate an integer count to a value. < 1316300468 293099 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :count (One a) = 1; count (Many a) = 1 + count a < 1316300474 918510 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :like Nat with an extra parameter < 1316300506 803116 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :you could also generalize (1+) to f < 1316300511 526946 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :er, well no < 1316300514 560023 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :also it's isomorphic to that delayed monad thing < 1316300518 55069 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :but you can apply f a number of times. < 1316300535 112192 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :runMany (Many a) = f(runMany a) < 1316300535 544697 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :What delayed monad thing? < 1316300539 291708 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :data Delayed a = Now a | Later (Delayed a) < 1316300551 298180 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :(not sure i have the name right) < 1316300554 542802 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :If you want to apply a number of things, you can also use church numerals < 1316300567 211898 :copumpkin!~pumpkin@unaffiliated/pumpkingod QUIT :Quit: Computer has gone to sleep. < 1316300616 273160 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :data Lol a b = Nothing | Left a | Right b | Both a b | Many (Lol a b) < 1316300617 838898 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :bahahaha < 1316300631 642858 :monqy!~swell@pool-71-102-215-70.snloca.dsl-w.verizon.net PRIVMSG #esoteric :is this abomination your doing < 1316300636 240780 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :yes < 1316300662 468013 :DH____!~DH____@unaffiliated/dh----/x-6288474 QUIT :Ping timeout: 260 seconds < 1316300670 722072 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :I made genCurry i = do { n <- mapM id \$ replicate i (newName "x"); f <- newName "x"; lamE (varP f : map varP n) (appE (varE f) . tupE \$ map varE n); }; < 1316300738 718047 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :type Lol a b = Many ( Maybe (Either (Either a b) (a,b))) < 1316300760 886887 :monqy!~swell@pool-71-102-215-70.snloca.dsl-w.verizon.net PRIVMSG #esoteric :zzo38: mapM id? isn't that the same as sequence? < 1316300777 618642 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :monqy: O, maybe it is. < 1316300814 627518 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :Yes that works < 1316300860 757987 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :zzo38: in fact i think mapM id \$ replicate i = replicateM i < 1316300885 599610 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :yep < 1316300889 777128 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :So, in other words, curry = \$(genCurry 2) < 1316300921 374484 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake PRIVMSG #esoteric :good ol' replicateM < 1316300945 613504 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :OK, I fixed it to use replicateM and it works. < 1316301012 206612 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :s/[\$]/./ technically < 1316301021 271472 :monqy!~swell@pool-71-102-215-70.snloca.dsl-w.verizon.net PRIVMSG #esoteric :I was about to comment on that < 1316301055 523456 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :oerjan: Yes < 1316301119 444660 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :Now I can understand how the "newName" command works. The documentation doesn't say what it is but I figure it out. < 1316301132 210245 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :The document just says the type. < 1316301169 562835 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :i guess it's for inventing a fresh variable name < 1316301192 176620 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :almost like lisp gensym < 1316301192 295204 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :Yes, that is what it does. But you still need to indicate its name anyways! < 1316301219 877535 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :Why does it require you to indicate the name anyways, even though it is always a new name? < 1316301242 717901 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :zzo38: i assume it uses the x as a prefix < 1316301244 485206 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake QUIT :Ping timeout: 260 seconds < 1316301257 822496 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :zzo38: it might help if you want to read core output, perhaps < 1316301270 642783 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :Yes it does use it as a prefix < 1316301329 563456 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :or generated output, there's probably an option for printing it just after the TH step < 1316301378 901843 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :Generated output printing after TH step by -ddump-splices shows the name you specify as prefix, and the other stuff in [] < 1316301394 208253 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :ok < 1316301428 427688 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :But I suppose one other thing, is to tell whether you want uppercase or lowercase, but it should be able to figure that out by itself. < 1316301495 420859 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :might be tricky in some cases < 1316301501 43946 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :But perhaps they don't want one name used in both ways, but it can anyways because it is for type levels and value levels < 1316301560 445051 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :zzo38: but constructors appear both places. < 1316301620 715004 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :If you do something like f = X :: X; then both X are different < 1316301667 624661 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :yes but what about x = X :: X x < 1316301711 844324 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :Then I also think both x are different, too, isn't it? < 1316301731 398578 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :zzo38: i thought you were talking about distinguishing upper and lower case < 1316301802 222355 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :Yes..... < 1316301835 462414 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :But those don't seem to be problem there, if you can use a name in multiple places < 1316301837 348072 :ive!~nn@189.179.246.222 JOIN :#esoteric < 1316301846 109540 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :all of those might be produced from newName "x" if it were to change the case everywhere < 1316301887 26557 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :anyway it probably _could_ decide, since the actual definition site inserted would probably tell what it was < 1316301904 914870 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :oerjan: Say, you have a different function newName' which takes no argument. < 1316301905 725593 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :but it might require some awkward tying of the knots < 1316301930 390210 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :But it could not use newName' for either of the X here. < 1316301949 208427 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :I don't think it could use newName either. < 1316301980 689296 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :oh so newName isn't general for all names? < 1316301986 491725 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :@hoogle newName < 1316301986 821513 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Language.Haskell.TH newName :: String -> Q Name < 1316301986 995413 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Language.Haskell.TH.Syntax newName :: String -> Q Name < 1316301987 13323 :lambdabot!~lambdabot@li85-105.members.linode.com PRIVMSG #esoteric :Language.Haskell.TH.Syntax qNewName :: Quasi m => String -> m Name < 1316302019 295615 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :oerjan: newName can do uppercase or lowercase names, but in the example "x = X :: X x" it couldn't do because X would need to be defined already for that to be accepted < 1316302049 383872 :sllide!~jari@ip565eb113.direct-adsl.nl QUIT :Ping timeout: 258 seconds < 1316302126 58521 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :zzo38: right, so newName requires that you're generating a splice which includes the definition. < 1316302131 346405 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :Actually I suppose there is still some difficulty, that you have [d| data X = \$x; y = \$x; |] the answer is still obvious but the program to determine it might not be entirely simple. < 1316302143 482890 :monqy!~swell@pool-71-102-215-70.snloca.dsl-w.verizon.net PRIVMSG #esoteric :the best part of TH is using mkName to make impossible names, like ones with alphanumeric and operator charaters mixed together < 1316302144 440242 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :oerjan: Yes, because it is the Q monad. < 1316302182 98960 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :But I suppose you can have newVar = newName "name___"; newCon = newName "Name___"; < 1316302198 646585 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :monqy: those actually _work_? < 1316302204 294509 :monqy!~swell@pool-71-102-215-70.snloca.dsl-w.verizon.net PRIVMSG #esoteric :oerjan: I've done it! < 1316302263 576020 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :monqy: in that case, does it work to use the name in a spot with the "wrong" case for it? < 1316302278 500736 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :monqy: /why/ did you do it? < 1316302281 453391 :monqy!~swell@pool-71-102-215-70.snloca.dsl-w.verizon.net PRIVMSG #esoteric :I've never tried, but I'm guessing yes it will work < 1316302295 801474 :monqy!~swell@pool-71-102-215-70.snloca.dsl-w.verizon.net PRIVMSG #esoteric :ais523: bad reasons, naturally < 1316302311 487129 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :zzo38: ok if what monqy says is true then it's likely TH doesn't actually _care_ about the case used < 1316302325 997990 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :Actually it works as long as the *first* character is of the correct case. < 1316302332 698046 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :hmm, idea my supervisor had for sandboxing OCaml (whilst preventing uses we don't want of the standard library): reject all mentions of modules other than Pervasives, combined with rejecting the stuff in Pervasives we don't want them to use < 1316302335 310112 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :Everything else can be any symbols it doesn't matter. < 1316302337 962750 :monqy!~swell@pool-71-102-215-70.snloca.dsl-w.verizon.net PRIVMSG #esoteric :ais523: I was too lazy to parse haskell but I wanted to do some syntactic modifications where I could mark a haskell expression, pull it out, put it somewhere else, and leave a stump in its place < 1316302345 128768 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :so I've hooked the parser to recognise only Pervasives as a legitimate module name < 1316302351 451226 :CakeProphet!~adam@24.75.163.40 JOIN :#esoteric < 1316302351 470647 :CakeProphet!~adam@24.75.163.40 QUIT :Changing host < 1316302351 470804 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake JOIN :#esoteric < 1316302351 793924 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :zzo38: oh so that is required. < 1316302352 838812 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :is this going to be a crazily flawed solution? < 1316302360 700821 :monqy!~swell@pool-71-102-215-70.snloca.dsl-w.verizon.net PRIVMSG #esoteric :ais523: yes < 1316302378 204721 :monqy!~swell@pool-71-102-215-70.snloca.dsl-w.verizon.net PRIVMSG #esoteric :I used the syntactically invalid identifier to mark the expressions I wanted to pull out < 1316302380 377431 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :(that is, in any context where a module name is expected, if it isn't "Pervasives" error out) < 1316302382 522010 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :Now instead of f <- newName "x"; I can write f <- newVar; < 1316302386 367223 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :monqy: can you see any flaws with it? < 1316302391 534886 :monqy!~swell@pool-71-102-215-70.snloca.dsl-w.verizon.net PRIVMSG #esoteric :it was ugly < 1316302402 409950 :monqy!~swell@pool-71-102-215-70.snloca.dsl-w.verizon.net PRIVMSG #esoteric :oh you were not talking about what I was doing there < 1316302402 917821 :monqy!~swell@pool-71-102-215-70.snloca.dsl-w.verizon.net PRIVMSG #esoteric :oops < 1316302405 913088 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :oh, I see < 1316302411 485181 :monqy!~swell@pool-71-102-215-70.snloca.dsl-w.verizon.net PRIVMSG #esoteric :I was talking about my thing being falwed < 1316302415 689650 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :crossed conversations < 1316302467 469814 :monqy!~swell@pool-71-102-215-70.snloca.dsl-w.verizon.net PRIVMSG #esoteric :but it does have a sort of ugliness similar to what i was doing < 1316302482 497492 :kmc!~keegan@c-98-216-51-47.hsd1.ma.comcast.net QUIT :Ping timeout: 260 seconds < 1316302491 371476 :monqy!~swell@pool-71-102-215-70.snloca.dsl-w.verizon.net PRIVMSG #esoteric :hm < 1316302498 289728 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :never cross the conversations! < 1316302585 296612 :monqy!~swell@pool-71-102-215-70.snloca.dsl-w.verizon.net PRIVMSG #esoteric :dunno if this quite applies to ocaml at all, but perhaps make a wrapper module, always included, which exports only the stuff you want from Pervasives, and make all module imports syntactically invalid? < 1316302590 343809 :Vorpal!~AnMaster@unaffiliated/anmaster PRIVMSG #esoteric :oerjan, augh < 1316302604 509338 :monqy!~swell@pool-71-102-215-70.snloca.dsl-w.verizon.net PRIVMSG #esoteric :or would that be going against a goal or two < 1316302644 556765 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake QUIT :Ping timeout: 260 seconds < 1316302725 600907 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :yep, the idea is to verify that input programs use a particular subset of OCaml < 1316302740 785156 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :I haven't yet got around to the idea of conditionally banning if, mostly because it's so easy to work around < 1316302760 95080 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :there are any number of ways to express an if in OCaml, just as in most languages < 1316302789 540507 :monqy!~swell@pool-71-102-215-70.snloca.dsl-w.verizon.net PRIVMSG #esoteric :the ugliest part is rejecting the stuff in Pervasives you don't want them to use < 1316302790 452181 :Gregor!foobar@codu.org PRIVMSG #esoteric :Heh, one of the places where I buy cheap Chinese junk just sent me an email saying that they now have a US warehouse for their most popular wares, and so can offer 3nd day delivery. Whatever "3nd day delivery" is :P < 1316302812 470015 :monqy!~swell@pool-71-102-215-70.snloca.dsl-w.verizon.net PRIVMSG #esoteric :I can't think of any clean way to do it without making a new module :( < 1316302819 837251 :monqy!~swell@pool-71-102-215-70.snloca.dsl-w.verizon.net PRIVMSG #esoteric :and making a new module is also ugly :( < 1316302880 649574 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :I could reject module imports and qualifies altogether, because Pervasives is loaded by default < 1316302890 744404 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :but yes, I agree, the issue's rejecting things like file opens < 1316302920 292039 :ais523!~ais523@unaffiliated/ais523 PRIVMSG #esoteric :Gregor: I can pronounce it as a word somewhere between "third" and "second", and yet even though it's obvious how to pronounce it, I still don't know what it means < 1316302921 436073 :Patashu!~Patashu@c122-106-155-219.carlnfd1.nsw.optusnet.com.au JOIN :#esoteric < 1316303026 252333 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :One idea is, to have a macro system in Haskell with its own syntax and its own types. Such as, MetaExp, MetaPat, MetaName, MetaLcName, MetaUcName, MetaNewLcName, MetaNewUcName, MetaLocalLcName, MetaLocalUcName, MetaInt, MetaOrder, MetaLayout, etc. < 1316303040 379939 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :And each keyword is its own type. < 1316303043 972457 :CakeProphet!~adam@24.75.163.40 JOIN :#esoteric < 1316303043 990781 :CakeProphet!~adam@24.75.163.40 QUIT :Changing host < 1316303043 991015 :CakeProphet!~adam@wikipedia/The-Prophet-Wizard-of-the-Crayon-Cake JOIN :#esoteric < 1316303346 777264 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :zzo38: i somehow had the idea that was what template haskell is... < 1316303361 911410 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :approximately, anyhow < 1316303427 192227 :kmc!~keegan@c-98-216-51-47.hsd1.ma.comcast.net JOIN :#esoteric < 1316303510 449910 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :oerjan: No, it isn't. What I mean is something, you can define macro called "j" of type (MetaNewUcName -> Q [Dec]) to make a declaration "j K" permitted and it means K is a new name to this module instead of imported or something like that. And same with the other things; including make up new syntax and affecting what is already there, such as making up do-notation instead require it already have do-notation. < 1316303577 7516 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :Or possibly different monad not Q, it would be different to do the different thing, but in addition to the Q stuff of Template Haskell too. < 1316303693 678108 :oerjan!oerjan@tyrell.nvg.ntnu.no PRIVMSG #esoteric :i see. i think that would require intertwining TH with parsing? < 1316303725 78197 :zzo38!~zzo38@h24-207-49-17.dlt.dccnet.com PRIVMSG #esoteric :Yes, unless you did it different so that it is a separate step from TH. ```