<    March 2017    >
Su Mo Tu We Th Fr Sa  
          1  2  3  4  
 5  6  7  8  9 10 11  
12 13 14 15 16 17 18  
19 20 21 22 23 24 25  
26 27 28 29 30 31
00:07 shadowPriest joined
00:12 Pupnik joined
00:18 Rodya_ joined
00:24 splanch joined
00:25 eacameron joined
00:27 Rodya__ joined
00:41 louispan joined
00:50 <lpaste_> saylu revised “arrows”: “arrows” at http://lpaste.net/353922
00:50 <saylu> nil_: Revised further! Thank you for your help, this has become clear now.
01:07 <lpaste_> saylu revised “arrows”: “arrows” at http://lpaste.net/353922
01:09 Pupnik_ joined
01:10 <lpaste_> saylu revised “arrows”: “arrows” at http://lpaste.net/353922
01:10 <saylu> Sorry for the mini-spam there -- revised to be actually readable (this is what I'm putting in my notes). Thanks!
01:19 hexagoxel joined
01:28 drewr joined
01:33 hphuoc25 joined
01:45 peterbec` joined
01:47 Rodya_ joined
01:51 exferenceBot joined
01:51 hexagoxel joined
01:51 baroncharlus joined
01:52 Rizy joined
01:53 ali_bush joined
01:53 ali_bush joined
02:00 eacamero_ joined
02:07 drewr joined
02:09 shayan_ joined
02:19 justicefries left
02:26 exferenceBot joined
02:30 hexagoxel joined
02:52 TCZ joined
03:01 Pupnik joined
03:01 conal joined
03:02 peterbec` joined
03:22 sypwex joined
03:22 sypwex left
03:32 eacameron joined
03:34 hphuoc25 joined
03:38 takle joined
03:39 sypwex joined
03:39 sypwex left
03:46 robit joined
03:47 <robit> is there any function like flip, but it acts as a cyclic permutation? For example (flip1 f) (x y z) == (f z x y)
03:59 takle joined
04:03 splanch joined
04:10 <glguy> Not as you've written there
04:11 <glguy> What type do you think this function might have?
04:11 nomotif joined
04:11 malaclyps joined
04:17 takle joined
04:22 systemfault joined
04:23 systemfault joined
04:27 takle joined
04:36 rizary joined
04:43 eacameron joined
04:44 myrkraverk joined
04:51 Rizy joined
04:55 splanch joined
04:55 takle joined
05:29 meandi_2 joined
05:30 takle joined
05:32 kattak joined
05:40 malaclyps joined
05:40 malaclyps joined
05:48 <benzrf> :t \f x y z -> f z x y
05:48 <lambdabot> (t3 -> t2 -> t1 -> t) -> t2 -> t1 -> t3 -> t
05:48 Deide joined
06:04 splanch joined
06:04 takle joined
06:10 <parsnip> hmm, using parsec, then intercalate, then arson, perhaps is turning out convoluted. thinking I should just use parsec the once and then start manipulating the haskell data.
06:14 moei joined
06:23 takle joined
06:28 splanch joined
06:30 <parsnip> s/arson/aeson/
06:38 takle joined
06:42 hphuoc25 joined
06:44 hphuoc25 joined
06:47 eacameron joined
06:54 ali_bush joined
06:54 ali_bush joined
06:55 takle joined
07:02 splanch joined
07:09 eacameron joined
07:11 smichel17 joined
07:21 Malakai joined
07:24 eacameron joined
07:24 mounty joined
07:27 takle joined
07:30 xmonader left
07:31 xmonader joined
07:38 takle joined
07:42 slomo joined
07:45 takle joined
07:49 hphuoc25 joined
07:57 Pupnik_ joined
07:59 ali_bush joined
07:59 ali_bush joined
08:03 takle joined
08:04 nil_ joined
08:28 takle joined
08:34 simendsjo joined
08:42 takle joined
08:51 azahi joined
09:01 prophile joined
09:02 jarshwah_ joined
09:04 takle joined
09:06 takle joined
09:11 <parsnip> i have tuples [("a", "xa"), ("b", "xb"), ...], and i want to convert to a record rec {a :: A, b :: B, ...}
09:12 <parsnip> i've thought about having auxiliary records recRaw {a = "xa", b = "xb", ...}, and
09:12 <parsnip> recFuncs {a :: String -> A, b :: String -> b, ...}
09:13 <nil_> parsnip: "convert", as in, write a function that :: [(String, String)] -> MyRecord, or as in, refactor the list of tuples code into record code?
09:13 <parsnip> but not sure what i was thinking to do, you can't zip records
09:13 <parsnip> ah, yeah, i need to just have a conditional that checks the string value in "key"
09:14 thc202 joined
09:14 bungoman joined
09:14 <jle`> parsnip: a list of tuples is a bit of a weird structure for that
09:15 <jle`> you can use Map String String maybe
09:15 <jle`> and then just do Rec <$> M.lookup "a" m <*> M.lookup "b" m <*> M.lookup "c" m
09:16 <jle`> er, forgot about the parsing
09:16 <jle`> but Rec <$> parseA <*> parseB <*> parseC
09:16 <parsnip> yes, i agree i should most likely make it Map rather than list of tuples once i get the main idea worked out
09:16 andyhoang joined
09:17 <jle`> and most parsers have a MonadPlus instance
09:17 <jle`> so you can make a bad lookup count as a failed parse
09:17 <jle`> :t maybe mzero return
09:17 <lambdabot> MonadPlus m => Maybe a -> m a
09:18 <zaquest> idk, it doesn't seem weird to me, it's a perfectly fine data structure called association list, if you don't care about performance much, which i guess you don't unless your record has really many field. prelude even has `lookup` function to work with it.
09:19 rfvizarra joined
09:20 <jle`> list of tuples is kind of a permissive type for an association list
09:21 <jle`> if performance isn't an issue, it's still nice to use a type that enforces invariants and exposes a proper abstract api
09:21 <jle`> this is haskell after all ... we're not in C where ints are used to reprsent chars, pointers, and way too many things, heh
09:21 andyhoang joined
09:22 <parsnip> damnit, i can't write a map from the key string to what will act on the value string. the value string will map to a different type depending.
09:23 <jle`> yeah, vanilla haskell isn't very good at doing things generically like that
09:23 <parsnip> is it time to learn TH?
09:23 <jle`> probably not
09:24 <jle`> how many fields does the record have?
09:24 <parsnip> about a dozen
09:24 <jle`> probably isn't too bad to just write out the parsing action for each field
09:25 <jle`> Rec <$> parseInt "a" <*> parseBool "b" <*> parseInt "c" <*> ...
09:25 <parsnip> aaahhhh, it's clicking, thanks
09:25 <jle`> or you can write a hof
09:25 <jle`> parseKey :: String -> Parser a -> Parser a
09:26 <jle`> parseKeyWith :: String -> Parser a -> Parser a, maybe a better name
09:26 <jle`> parseKeyWith k = do
09:26 <parsnip> so when i look up "a", i have to return a and fa :: String -> A
09:26 <jle`> Just v <- return $ M.lookup k
09:26 <jle`> p
09:26 <jle`> *parseKeyWIth k p
09:26 <jle`> oh, are we working within parsers here
09:27 <parsnip> parsers?
09:27 <jle`> if you already have a `String -> a` for every field then you can just use that
09:27 <jle`> in that case you can just use fmap
09:27 <jle`> parseInt <$> M.lookup "k" m
09:27 <jle`> if parseInt :: String -> a
09:28 <parsnip> parseA :: String -> A
09:28 <jle`> parsnip: parsers as in, a parser combinator library
09:28 Durz0 joined
09:28 <jle`> yeah, then you can do `parseA <$> M.lookup "k" a`
09:28 <jle`> parseKeyWith :: String -> (String -> a) -> a
09:28 <jle`> er, -> Maybe a
09:29 <parsnip> i'm nervous of your use of lowercase a
09:29 <jle`> it's a higher order function
09:29 <jle`> parseKeyWith :: String -> (String -> a) -> Maybe a
09:29 <jle`> parseKeyWith k f = f <$> M.lookup k myMap
09:29 <jle`> so you can do Rec <$> parseKeyWith "a" parseA <*> parseKeyWith "b" parseB <*> parseKeyWith "c" parseC
09:29 killtheliterate joined
09:30 <parsnip> for pair ("a", "xa"), i need to use a type A where i get { a = fa "xa" :: A, ...}
09:30 <jle`> yeah, Rec <$> parseKeyWith "a" fa <*> parseKeyWith "b" fb <*> ...
09:31 <jle`> parseKeyWtih looks up the key, and then applies the parsing function to the result
09:31 <jle`> it's a higher order function, so it takes the parsing function as an argument
09:31 <jle`> `parseKeyWith :: String -> (String -> a) -> Maybe a`
09:31 <jle`> so if you give it a (String -> A), the result will be Maybe A
09:32 <jle`> if you give it a (String -> B), the result will be Maybe B
09:32 <parsnip> ah, so i will have to write the triples out in the Rec thing, like `a fa "a"`
09:32 <parsnip> , `b fb "b"`, ...
09:32 <parsnip> and it's okay that fa and fb don't have the same type
09:32 <jle`> not where what 'a' and 'b' are there
09:32 <jle`> but you'd use the same higher order function each time
09:33 <jle`> just with different parsers
09:33 <jle`> that's why how map :: (a -> b) -> [a] -> [b] will give you lists of different types, depending on what mapping function you use
09:33 <parsnip> yep, all but four are Maybe
09:33 <jle`> map show will returna list of strings
09:33 <jle`> map (+1) will return a list of some num type
09:33 <jle`> etc.
09:34 <jle`> the point is to re-use the same higher order function
09:34 <jle`> it might be more sensible to have
09:34 <jle`> parseKeyWith :: String -> (String -> Maybe a) -> Maybe a
09:34 <jle`> cause parsing might fail
09:35 <jle`> and so you'd write Rec <$> parseKeyWith "a" fa <*> parseKeyWith "b" fb <*> parseKeyWith "c" fc
09:35 <jle`> and `fa :: String -> Maybe A`, `fb :: String -> Maybe B`, 'fc :: String -> Maybe C', etc.
09:37 <parsnip> thank you, that gets me way back on course
09:38 <jle`> no problem!
09:38 <jle`> the only way you can use record syntax here is if you assume everything will always succeed
09:38 <jle`> but because things might fail, you'd have to sequence the maybes in applicative style (or monadic style, but you'd have to give explicit names)
09:39 <jle`> but if you're comfortable writing `parseWithKey :: String -> (String -> a) -> a`, then you can just do rec {a = parseWithString "a" fa, b = parseWIthString "b" fb, ... }
09:40 <jle`> all of these could reasonably fail at the lookup stage and at the parsing stage, which is why i'd recommed `parseWithKey :: String -> (String -> Maybe a) -> Maybe a`, but then you can't use record syntax directly
09:43 simendsjo joined
09:43 hphuoc25 joined
09:49 geekosaur joined
09:55 albertus1 joined
10:06 eacameron joined
10:06 Vzox0102 joined
10:08 Pupnik joined
10:16 yellowj joined
10:16 nokomo joined
10:16 <parsnip> k, rewrote earlier function to work per line, and make each one a Map, time to sleep
10:22 splanch joined
10:39 geekosaur joined
10:58 eacameron joined
11:02 initiumdoeslinux joined
11:14 Gurkenglas_ joined
11:17 geekosaur joined
11:19 hoffmeyer joined
11:20 <nil_> How would you flatten an nxn matrix (type Matrix a = [[a]] for our purposes) *diagonally*?
11:23 <nil_> Such as diagFlatten [ [1,2,3], [4,5,6], [7,8,9] ] == [3,2,6,1,5,9,4,8,7]
11:28 splanch joined
11:30 kritzcreek_ joined
11:31 albertus1 joined
11:32 netheranthem joined
11:35 simendsjo joined
11:39 geekosaur joined
11:40 geekosaur joined
11:43 azahi joined
11:47 Gloomy joined
11:48 hoffmeyer joined
11:52 geekosaur joined
11:53 geekosaur joined
11:55 geekosaur joined
12:00 geekosaur joined
12:01 hoffmeyer joined
12:03 geekosaur joined
12:12 geekosaur joined
12:13 jarshwah_ joined
12:14 geekosaur joined
12:14 Vibor joined
12:16 <Vibor> Hi, I'm having problem with this code https://ptpb.pw/Txwi , it gives me Ambiguous type variable error
12:18 simendsjo joined
12:19 <Vibor> The error can be solved by adding fromIntegral before (fact oddTerm), I wonder why and why if I trim ^oddTerm off, the code would work even without fromIntegral
12:20 geekosaur joined
12:26 Levex joined
12:26 geekosaur joined
12:36 tangled_z joined
12:41 Malakai joined
12:42 wildlander joined
12:48 geekosaur joined
12:58 geekosaur joined
13:00 t0by joined
13:00 t0by joined
13:02 geekosaur joined
13:04 geekosaur joined
13:07 geekosaur joined
13:14 eacameron joined
13:16 Gloomy joined
13:17 killtheliterate joined
13:22 eacameron joined
13:22 sypwex joined
13:24 dni- joined
13:28 takle joined
13:29 geekosaur joined
13:33 geekosaur joined
13:34 eacameron joined
13:36 geekosaur joined
13:40 geekosaur joined
13:48 eacameron joined
13:50 splanch joined
13:53 hphuoc25 joined
13:56 yellowj joined
13:58 pilne joined
14:03 eacameron joined
14:06 geekosaur joined
14:14 geekosaur joined
14:25 jorris joined
14:35 splanch joined
14:37 rfvizarra joined
14:50 contiver joined
14:53 simendsjo joined
15:03 peterbecich joined
15:08 Levex joined
15:13 dni- joined
15:16 earldouglas joined
15:30 boxscape joined
15:31 splanch joined
15:33 simendsjo joined
15:35 mengu joined
15:44 davs joined
15:45 davs joined
15:45 takle joined
15:50 curious_corn joined
15:51 pie_ joined
15:57 davs joined
16:02 marvin2 joined
16:03 takle joined
16:04 davs joined
16:09 takle joined
16:18 conal joined
16:20 <CuriousErnestBro> chapter 1 is messing me up
16:20 <* CuriousErnestBro> doesnt get lambda calculus at all
16:23 <boxscape> anything in particular that you have a problem understanding?
16:23 <CuriousErnestBro> beta reduction
16:23 <CuriousErnestBro> and the [y:=z] notation
16:26 <boxscape> CuriousErnestBro: Would you know how to perform beta reduction for (λx.xy)z?
16:27 <CuriousErnestBro> λz.zy?
16:27 blissdev joined
16:28 <boxscape> Well, you've done it partially right. You're right that you have to replace the x on the right side with z - which the notation [x:=z] signifies - but you must remove the left side of the expression. So you end up with just zy
16:28 <boxscape> if you think about this like a math function: f(x) = xy -> f(z) = zy
16:29 <boxscape> and so (λx.xy) would be the function f, and (λx.xy)z means that you're applying z to this function, hence f(z)
16:29 <boxscape> I hope this makes it more rather than less understandable
16:29 <CuriousErnestBro> ah ok, now it makes sense
16:29 <boxscape> good
16:29 <CuriousErnestBro> especially with the function explanation, thanks boxscape!
16:29 <boxscape> you're welcome
16:42 conal joined
16:43 albertus1 joined
16:44 <CuriousErnestBro> since we're doing math: a "function" in Haskell is always surjective, but not necessarily one-to-one?
16:46 <nil_> CuriousErnestBro: functions don't even need to be surjective imo.
16:46 <boxscape> For example, if you have a function that maps every number onto the number 1.
16:56 eacameron joined
16:58 <CuriousErnestBro> are there plans for GSoC 2018 for Haskell?
16:58 <parsnip> nil_: i think i can imagine sorta how to it with a loop
17:01 <geekosaur> CuriousErnestBro, https://www.reddit.com/r/haskell/comments/5wpwkq/summer_of_haskell_2017/
17:01 <geekosaur> although the page for it isn't up yet (keep an eye on summer.haskell.org which is currently the 2016 page)
17:01 dni- joined
17:06 tangled_z joined
17:10 Zialus joined
17:12 mojjo joined
17:14 geekosaur joined
17:20 davs joined
17:33 systemfault joined
17:34 curious_corn joined
17:34 <nil_> parsnip: do what? I'm not sure what we're talking about.
17:35 <parsnip> nil_: looks like A_{3,1}, A_{2,1}, A_{3,2}, ...
17:35 <parsnip> nil_: looks like you external loop would be i-j=2,1,...
17:36 <parsnip> nil_: and then a few constraints for the inner loop
17:36 <nil_> parsnip: oh, the diagonal flattening! We're on the same page now. :)
17:36 tom7942 joined
17:37 <nil_> Yeah, perhaps you could generate the list of index-pairs with a list comprehension.
17:37 <parsnip> you can draw it on an xy-plane if dropping the integer aspect helps you see the constraints
17:37 <nil_> Right.
17:37 <parsnip> like, 1<=i,j<=3
17:38 <parsnip> sorry, that was personal shorthand, not useful in public
17:38 anmin joined
17:39 <parsnip> meant, i and j are both restricted to set {1, 2, 3}
17:41 eacameron joined
17:42 sigmundv_ joined
17:43 kadoban joined
17:45 takle joined
17:46 conal joined
17:51 malaclyps joined
17:54 poohflapz joined
18:00 pie_ joined
18:03 conal joined
18:05 \Mike joined
18:07 Rodya_ joined
18:11 dni- joined
18:13 mojjo` joined
18:21 eacameron joined
18:25 Rodya_ joined
18:28 tom7942 joined
18:33 takle joined
18:34 conal joined
18:35 eacameron joined
18:38 aarvar joined
18:40 Rodya_ joined
18:42 curious_corn joined
18:47 <CuriousErnestBro> "expressions, variables, and abstraction", abstraction == function, or abstraction ⊃ function?
18:49 takle joined
18:51 <boxscape> CuriousErnestBro: in the context of lambda calculus, I believe they are equivalent
19:02 azahi joined
19:14 conal joined
19:22 <Cale> CuriousErnestBro: "Abstractions" are the terms with lambdas at the outermost level. Functions are the things they denote.
19:22 Uniaika joined
19:22 tom7942 joined
19:30 shayan_ joined
19:32 boxscape joined
19:33 drewr joined
19:34 <CuriousErnestBro> Cale, that doesn't make sense. Maybe you could tell what the abstraction and function is in this: λx.x
19:37 <Cale> So that term itself is an abstraction term
19:37 Vzox0102 joined
19:37 curious_corn joined
19:37 <Cale> The function it denotes is the identity function on whichever domain it acts on
19:39 <CuriousErnestBro> doesn't make sense sorry
19:39 Vzox0102 joined
19:39 <Cale> Terms are syntactic things
19:39 <Cale> Functions are semantic things
19:39 <CuriousErnestBro> I don't know what those things mean
19:40 <CuriousErnestBro> syntactic and semantic
19:40 Vzox01 joined
19:41 <geekosaur> syntactic ~ how you write it; semantic ~ what it means
19:42 <CuriousErnestBro> abstractions are semantic, functions are syntactic?
19:42 <benzrf> yes!
19:42 <CuriousErnestBro> but really they're the same thing
19:42 <CuriousErnestBro> kind of
19:43 <geekosaur> is the map the same as the territory?
19:43 <benzrf> CuriousErnestBro: syntactic: dealing with the textual/grammatical structure of a language; semantic: dealing with the mapping of syntax to "meaningful" objects, and/or those objects themselves
19:43 <benzrf> syntax vs semantics is the distinction between numerals and numbers
19:44 <benzrf> also, what geekosaur just said
19:44 <CuriousErnestBro> ok so λ is just notation (syntactic) for the mapping /"abstraction" (semantic)
19:44 <benzrf> no, the "abstraction" is the syntactic λ thing
19:45 <CuriousErnestBro> that's what I'm saying
19:45 <CuriousErnestBro> right?
19:45 <benzrf> ah
19:45 <benzrf> well, you just said: "abstraction" (semantic)
19:45 splanch joined
19:46 <boxscape> I think you said it wrong a couple minutes ago, CuriousErnestBro; you said abstractions are semantic, functions are syntactic, but it's the opposite
19:46 <benzrf> note that something can be syntactic in one context and semantic in another context
19:47 <CuriousErnestBro> wowowow now I lost it :/
19:47 <boxscape> so in this case, the abstraction is the notation (syntax)
19:47 <benzrf> sorry that probably wasn't a helpful thing to say >.>
19:47 <boxscape> and the function is what it means (semantics)
19:47 <geekosaur> "abstraction" (more completely: "lambda abstraction") is just what we call the λx.x syntax
19:48 <CuriousErnestBro> λ == "abstraction" (syntax) and it denotes a "function" (semantics)?
19:48 <geekosaur> the syntax represents a function, here what Haskell calls "id"
19:48 <benzrf> CuriousErnestBro: yeah
19:48 <geekosaur> (similarly λxy.x represents what Haskell calls "const")
19:49 <benzrf> a program that maps from syntactic objects to semantic objects is an interpreter or a compiler
19:49 <benzrf> (usually)
19:49 <boxscape> doesn't a compiler just map from one syntax (programming language) to another syntax (machine language)?
19:49 <benzrf> aha, well -
19:49 <benzrf> that's what i meant by 15:46 <benzrf> note that something can be syntactic in one context and semantic in another context
19:49 <CuriousErnestBro> I thought a computer worked on 0's and 1's
19:49 <benzrf> :)
19:49 <boxscape> yeah, ok
19:50 <boxscape> CuriousErnestBro: that's just the syntax ;)
19:50 <geekosaur> boxscape, the simple case says yes, but optimization usually requires some semantic understanding unless you're only doing trivial optimizations
19:50 <benzrf> also, for what it's worth, i was speaking a bit more abstractly
19:50 <boxscape> geekosaur: that makes sense
19:50 <benzrf> actually no, now that i think about it -
19:50 <CuriousErnestBro> boxscape, lol, then "no electricity" or "electricity"
19:50 <benzrf> i'd say that compilers transform from syntax to syntax, whereas interpreters transform from syntax to semantics
19:50 <benzrf> kiiinda
19:50 <benzrf> don't quote me on that.
19:51 <geekosaur> the line between compiler and interpreter has been getting steadily fuzzier since the 1960s or so
19:51 <benzrf> the key feature that you want from a compiler is that the output has the same semantics as the input
19:51 <CuriousErnestBro> applying abstraction → function?
19:52 <benzrf> CuriousErnestBro: huh?
19:52 <benzrf> sorry, can you be a bit more verbose?
19:52 <CuriousErnestBro> if you "apply" the abstraction, you get a function
19:52 <benzrf> well, depends on what you mean by "apply"
19:52 <boxscape> are you talking about beta reduction?
19:52 <CuriousErnestBro> boxscape, yes
19:52 <benzrf> ok, there's a correct concept i can think of, which you might mean -
19:53 <boxscape> beta reduction consists of simple syntactic rules, I would say. You don't need to know what the semantics are, to perform it
19:53 <benzrf> if you give me a lambda abstraction, i can give you a function that maps lambda terms to other lambda terms
19:53 <benzrf> for example, if you give me "\x.x", i can give you id on the LambdaTerm type
19:53 <benzrf> is that what you mean?
19:54 <CuriousErnestBro> idk, I don't know what id and LambdaTerm and type is
19:54 <benzrf> o
19:54 <* CuriousErnestBro> is only at chapter 1 o.o
19:55 Rodya_ joined
19:55 MotherFlojo joined
19:55 <CuriousErnestBro> that's what you get for reading books written by experts, so much unexplained lingo
19:55 <boxscape> well, one of the authors didn't know anything about programming when they started writing the book
19:56 <boxscape> the unexplained lingo seems to be mostly from IRC in this case, not from the book
19:57 <benzrf> heh... sorry
19:58 <benzrf> CuriousErnestBro: if you're just reading an introduction to the lambda calculus, don't worry about any of this
19:58 <benzrf> just don't think about "functions" at all - take what it's explaining at 100% face value
19:58 MitchellSalad joined
19:59 <boxscape> @where book
19:59 <lambdabot> http://haskellbook.com/
19:59 <boxscape> benzrf: he's reading this
20:00 <CuriousErnestBro> yeah, people were telling me (on here) that learn you a haskell was outdated so I picked up this book
20:00 <benzrf> it is!
20:00 <boxscape> LYAH also doesn't have exercises, whereas this does
20:01 <benzrf> LYAH is kind of bad at teaching you to think and build using the language features - it introduces the rules to you, but it doesn't show you what it's like to play the game
20:01 <Akii> it's pretty funny though
20:01 <CuriousErnestBro> "left associativity" of applications in lambda calculus means you go from left to right?
20:02 <benzrf> CuriousErnestBro: an infix operator is "left associative" if "a * b * c * d" means "(((a * b) * c) * d)"
20:02 <benzrf> CuriousErnestBro: an infix operator is "right associative" if "a * b * c * d" means "(a * (b * (c * d)))"
20:02 <CuriousErnestBro> ah ok, just like math
20:02 <benzrf> yup!
20:02 jmg8766 joined
20:02 <boxscape> it means that (λx.x)(λy.y)(λz.z) is interpreted as ((λx.x)(λy.y))(λz.z)
20:02 <CuriousErnestBro> =z
20:02 <boxscape> wait, does
20:02 <boxscape> it
20:03 <CuriousErnestBro> :p
20:03 <benzrf> here the infix operator is just the empty string between the thing being appled and the thing it's applied to
20:03 <benzrf> boxscape: it does
20:03 <boxscape> I'm a bit confused by my own notation here, because it looks like I'm passing two arguments
20:03 <benzrf> boxscape: passing two arguments is the same as what you did
20:03 <boxscape> ah,righmt
20:03 <boxscape> I feel a bit silly now
20:04 <CuriousErnestBro> these terms sound new: "alpha equivalence" "beta reduction"
20:04 eacameron joined
20:05 <boxscape> What do you mean by "new"? They are explained in the book, right?
20:05 <benzrf> bbl
20:05 <CuriousErnestBro> new to me, and yes they are :)
20:05 <boxscape> ok
20:07 <Akii> btw, when do I need this lambda calculus to do Haskell?
20:07 <CuriousErnestBro> ^ I have the same question
20:07 splanch joined
20:07 eacameron joined
20:08 takle joined
20:09 <Akii> maybe an isomorphic question would be "when do I need categories to do Haskell"
20:09 <Akii> but to this say I've not really needed that lambda calculus knowledge from the book
20:10 <boxscape> it can be quite helpful for understanding currying and a few other things down the line, but I don't think you strictly need lambda calculus to learn haskell. I didn't know anything about lambda calculus when I learned haskell.
20:11 <boxscape> I do think lambda calculus is more helpful than category theory
20:12 <Akii> I'd guess edward and gabriel et al would disagree
20:12 <Akii> CuriousErnestBro: fwiw I read the first chapter but just went on reading, not fully getting it
20:13 <Akii> you can always come back later, don't let that be a blocker ^.^
20:13 <CuriousErnestBro> who are "edward and gabriel et al"
20:13 <Akii> well edward is "the" edward
20:13 <Akii> and gabriel is gabriel gonzalez
20:14 <Akii> made pipes and stuff
20:14 <Cale> Probably Edward Kmett (or Yang?) and Gabriel Gonzalez
20:14 <geekosaur> arguably you don't *need* either. they are helpful in understanding what's actually going on, though
20:14 <CuriousErnestBro> "S&P Capital IQ" oo
20:14 <Akii> what's a monoid morphism btw https://twitter.com/GabrielG439/status/837313024272707584
20:15 <Cale> If M and N are monoids, then a monoid homomorphism M -> N is a function f :: M -> N for which f mempty = mempty and f (x <> y) = f x <> f y
20:15 <geekosaur> in particular, haskell is in many ways modeled after lambda calculus
20:15 <CuriousErnestBro> gonna follow you Akii :D
20:15 <CuriousErnestBro> cute anime pics lol
20:16 <Akii> CuriousErnestBro: for more follow @SmallCatgirl lol
20:17 <Akii> but hey, tuturu~~!
20:17 <Akii> Cale: wat :S
20:17 curious_corn joined
20:18 <Cale> Akii: can I clarify something about that?
20:19 <boxscape> maybe helpful to index the functions: f mempty_M = mempty_N and f (x <>_M y) = f x <>_N f y or maybe not.
20:19 <boxscape> I hope I got the indices right though
20:19 <Cale> you did
20:19 <boxscape> good
20:20 <Akii> now I'm even more confused
20:20 <boxscape> :/
20:20 <Akii> okay, what is a homomorphism
20:21 splanch joined
20:21 <geekosaur> "same shape" (here, with respect to monoids), which is what Cale described formally
20:21 <Cale> Akii: In general? It's defined differently for different kinds of mathematical objects
20:22 <Akii> this went from "Oh look, Gabriel does something useful with monoids" to "dafuq is x"
20:22 <Cale> I defined what a homomorphism of monoids is. Homomorphisms of other sorts of things will be defined differently.
20:22 <Akii> that has nothing to do with a Hom set though, right?
20:22 <Cale> The idea is just that it's a function which preserves the identity of the monoid, and preserves the multiplication of the monoid
20:22 <geekosaur> but there's stil a concept of "somehow has the same shape". that shape could be fairly abstract though
20:23 <Cale> Akii: Well, the hom sets in the category of monoids are sets of monoid homomorphisms
20:24 curious_corn joined
20:24 <Cale> i.e. Hom(M,N) will be the set of all monoid homomorphisms M -> N
20:25 <Akii> and those are functors? >_>
20:25 <Akii> no, arrows?
20:25 <Akii> I'm confused
20:26 <Cale> Well, yeah, the arrows in the category of monoids are monoid homomorphisms (by definition)
20:26 <Cale> I'm not sure that helps at all
20:26 takle joined
20:27 <Cale> Bringing category theory into it doesn't really clarify anything here
20:27 <Akii> like I'm almost pretty sure that what Gabriel meant is to use a function from x to y
20:27 MotherFlojo joined
20:27 <Cale> Well, yeah, but not just any function
20:27 <Cale> a function which happens to be a monoid homomorphism
20:27 <Akii> I need something practicalc
20:28 <Akii> -c
20:28 <Akii> let me see if I can find the example code for his talk
20:29 ExpHP joined
20:30 <Cale> If VisiCalc had been written for another computer, where would you be today? Write your answer in the comments below.
20:30 <Akii> https://github.com/Gabriel439/slides/blob/master/lambdaconf/category/category.md#event-streams-are-monoids
20:30 <Cale> What Gabriel is offering there is a very vague suggestion.
20:31 <CuriousErnestBro> why is λxy.x called a const?
20:31 <Cale> Because it makes constant functions
20:31 <Akii> ye I think the next best abstraction would've been "use functions"
20:31 <Cale> It's not called "a const" it's just called const
20:31 <Cale> :t const
20:31 <lambdabot> a -> b -> a
20:31 <Cale> e.g. const 5 will be the function which no matter what you give it, produces the result 5
20:31 <boxscape> ((λxy.x)z) will always evaluate to z, regardless of the second argument you pass
20:31 <Akii> https://github.com/Gabriel439/slides/blob/master/lambdaconf/category/category.md#configurable-event-streams-are-monoids
20:31 <Akii> that one actually
20:32 <CuriousErnestBro> ah I see
20:32 <CuriousErnestBro> ty
20:32 <Akii> :t const "lel"
20:32 <lambdabot> b -> [Char]
20:32 <CuriousErnestBro> better write this down in latex quickly before I forget haha
20:33 <Akii> actually a function I use every now and then
20:33 <Akii> has more uses though
20:33 <Akii> Cale: anyway, somehow there this monoid morphism has to be
20:33 <Akii> or could be
20:33 <Akii> Config -> Whatever
20:34 <Akii> should be SubConfig -> Whatever where SubConfig is member of Config
20:34 <Akii> or at least that's how I understood it
20:34 <Cale> Another way to put it (sort of) would be "use lenses", since a lens has about the same shape as what he's suggesting :)
20:35 tom7942 joined
20:36 <ExpHP> First time using quickcheck, "stack test" tells me "Use --quickcheck-replay 'nonsense elided for irc' to reproduce."
20:36 <Cale> So, X here is meant to be the subcomponent of the Config that you're interested in. I'm not entirely sure what M is.
20:36 <Akii> Cale: probably Config
20:36 <Akii> err wat
20:36 <ExpHP> meanwhile 'stack test --test-arguments="--quickcheck-replay 'nonsense elided for irc'"' gives me: 'option --quickcheck-replay: Could not parse quickcheck-replay'
20:36 <Cale> Well, Config is presumably Config
20:37 <Akii> I'll just write him "2 months in and I still have no idea what you meant"
20:37 <CuriousErnestBro> is λx.x called an "expression"?
20:37 <Cale> CuriousErnestBro: sure.
20:37 <Cale> "term" and "expression" are synonyms, if it helps
20:37 <Cale> Akii: heh
20:37 <Cale> Akii: Well, tell me more about your situation
20:38 <Akii> like wth, use functors
20:38 <Akii> :D
20:38 <Akii> Cale: I've something similar to his "plugins" and thought I might be able to just make them a monoid
20:38 <Cale> I don't know what his plugins are
20:38 <Akii> just trying out things
20:39 <Akii> this Transaction Event stuff of his
20:39 <Cale> Okay, I haven't read any of that
20:39 <Akii> https://github.com/Gabriel439/slides/blob/master/lambdaconf/category/category.md#named-and-configurable-event-streams-are-monoids
20:40 <geekosaur> ExpHP, I think you want to ask that in #tasty
20:40 <ExpHP> geekosaur thanks, will try
20:40 <geekosaur> I presume it has something to do with configuring the test harness, but don't know details
20:40 <Akii> probably not even going to do it like here but "for science" still interested in how it would look like if `chars` and `ticks` would have different config types
20:42 <Cale> Akii: Well, in that case, you'd have to convert them so that they had the same config type, right?
20:42 <Akii> Cale: somehow Gabriel made it sound like there would be magic and no
20:42 <Cale> Akii: At least, if you wanted to combine them with <>
20:43 <Cale> <> only combines things which have the same type
20:43 <Akii> idk, he just said that it would be possible
20:43 <Cale> So, what Gabriel was suggesting (it's clearer to me that M means Managed (Transaction Event) now)
20:43 <Akii> (of course!)
20:43 <Cale> is that if you define some things of type X -> Managed (Transaction Event), with some other configuration type X
20:44 <Cale> Then you just need a function (which ought to be a monoid homomorphism), that will transform the X -> Managed (Transaction Event) values to Config -> Managed (Transaction Event) ones.
20:44 <Akii> wat
20:44 <Akii> magic
20:45 <Akii> how
20:45 <Akii> :D
20:45 <Cale> How is that anything other than entirely mundane?
20:45 <CuriousErnestBro> is this a correct explanation? https://i.imgur.com/1BZGUa0.png
20:45 <Akii> Cale: give me a second to process
20:46 <Cale> CuriousErnestBro: the lambda in the middle of that sequence of equations shouldn't be there
20:46 <Cale> You want something like [x := 2] x
20:47 <CuriousErnestBro> Cale, the book does the same: https://i.imgur.com/AnF9FNT.png
20:47 <Akii> tadaa~~ http://lpaste.net/353954
20:47 <Akii> like this? ^^
20:48 <Cale> wtf
20:48 MotherFlojo joined
20:48 <Cale> CuriousErnestBro: I have no idea. Nobody else uses notation like that so far as I'm aware.
20:48 <Cale> But okay.
20:49 <CuriousErnestBro> Cale, yes they said so, they introduced this notation to make it easier
20:49 <CuriousErnestBro> to show the "substitution"
20:49 <Cale> Akii: right, so (. subConfig) would do it.
20:49 <Akii> eureka
20:50 <Cale> Akii: It doesn't always have to be that simple of course
20:51 <Akii> sure, but I think I got the idea
20:51 <Akii> will surely take me a while to think this through
20:51 <Cale> Akii: you could do almost anything to make that translation between config types, but whatever it is that you do, you probably want it to be the case that combining computations beforehand, and then applying the translation is the same as applying the translation to each of the things, and then combining.
20:52 <Cale> (which is the "monoid homomorphism" part
20:52 <Cale> )
20:53 enolan_ joined
20:53 <Cale> CuriousErnestBro: Right, that's fine. It's just different from the notation that everyone else uses to do the same.
20:53 <Akii> sounds like some monoid law
20:53 <Cale> That's the f (x <> y) = f x <> f y bit
20:54 malaclyps joined
20:54 <Akii> don't understand your sentense though
20:55 takle joined
20:56 <Akii> in order to combine stuff it has to be the same type, Config -> Foo
20:56 <Akii> and then the function is a monoid
20:56 <Akii> if you have SubConfig -> Foo you first need to come up with Config -> Foo
20:56 monty joined
20:57 marvin2 joined
20:57 <Akii> assuming Foo is "the computation"
20:57 <Cale> No, you can presumably combine things of type SubConfig -> Foo as well
20:57 <Cale> But if you combine them at that type
20:58 <Cale> and then transform the result into a Config -> Foo
20:58 <Cale> then you want that to be the same as transforming each one to a Config -> Foo first
20:58 <Cale> and then combining the results
20:58 <Akii> well that is the law
20:59 <Akii> and this is where it can become more complicated and you could violate the law
20:59 <Akii> running into problems
20:59 <Akii> gotcha
21:00 <reptar_> how would this look in haskell? ((λx.(x y))(λz.z))
21:00 <reptar_> i don't understand what (x y) means, basically
21:01 <Akii> guessing the result is just `y`? :D
21:01 <reptar_> Akii: yes, but i don't understand why
21:01 <Cale> reptar_: That's function application
21:01 <Akii> ha!
21:01 <Cale> x y means apply the function x to the argument y
21:02 <Akii> @karma+ Cale
21:02 <lambdabot> Cale's karma raised to 82.
21:02 <parsnip> dang it, i have records { uuid :: UUID, ...} and { uuid :: String -> UUID }, i thought i could use {-# LANGUAGE DisambiguateRecordFields #} and {-# LANGUAGE DuplicateRecordFields #-}
21:03 <Akii> parsnip: :o
21:03 <parsnip> i guess i have to rename this like { fUuid :: String -> UUID }
21:03 <ExpHP> I wonder: how does one generally determine whether some e.g. monad instance they've created is actually law abiding?
21:03 <ExpHP> without going insane, I mean
21:03 <Cale> ExpHP: Usually the proofs are fairly straightforward.
21:03 <Akii> parsnip: I bet you can parameterize this on some categorical context :P
21:04 <ExpHP> I tried proving the laws for one of my own and got fed up at the third applicative law :V
21:04 <reptar_> Cale: oh, i thought x was a variable
21:04 <Cale> ExpHP: Don't bother with the laws for Applicative
21:04 <Cale> ExpHP: If it's a Monad, it'll be an Applicative for free.
21:05 <ExpHP> Yeah but proving it's a monad also entails proving the laws on (<*>) right?
21:05 <Cale> no
21:05 <Cale> Well, you don't have to give a shit about (<*>) at all
21:05 <ExpHP> so merely proving the laws on fmap and >>= is really enough?
21:05 <Cale> You can just pretend that Applicative doesn't even exist.
21:05 <Cale> yeah
21:05 <ExpHP> O_o
21:05 <Cale> In fact, just the laws on >>= and return are enough
21:06 <Cale> (but usually checking that it's a functor is sufficiently easy that you might as well do that first)
21:06 yellowj joined
21:06 <Cale> ExpHP: It might be worth noting that Applicative is a relatively new addition to the librarie
21:06 <Cale> s
21:06 <Cale> Compared to Monad and Functor
21:07 <ExpHP> I think I remember reading that the functor instance for a given type is unique, so it's hard to get that wrong
21:07 <ExpHP> unless one writes fmap f xs = [] or something
21:07 <Cale> Also, category theorists didn't really have that concept in the way that we do (they had something equivalent, but you have to go looking).
21:07 <Akii> ExpHP: or that: https://github.com/Akii/acme-fucks/blob/master/src/Acme/Fucks.hs#L32
21:07 <Akii> :>
21:08 <* ExpHP> approves
21:09 <Cale> So yeah, all that you need to check is that return v >>= f = f v, and x >>= return = x, and that (x >>= f) >>= g = x >>= (\v -> f x >>= g)
21:09 <Cale> Alternately, you can first prove that fmap id = id (from which you'll get fmap (f . g) = fmap f . fmap g by parametricity)
21:09 <reptar_> Cale: but where does the function x come from? and how do we know it doesn't change y?
21:10 <Cale> reptar_: Well, where does x come into scope there?
21:10 <reptar_> ooooh
21:11 <Cale> reptar_: It's the parameter to the function
21:11 <Cale> and you're supplying (λz.z) as the argument
21:11 <reptar_> (λz.z) replaces x
21:11 <Cale> So it reduces to (λz.z)y
21:11 <Cale> and then y
21:11 <reptar_> ah, i see
21:11 <reptar_> thanks :)
21:12 <reptar_> would (λz.zy) mean the same?
21:12 <reptar_> (as (λz.(z y)))
21:13 <boxscape> yes
21:13 <reptar_> nice :D
21:13 <reptar_> @karma+ Cale
21:13 <lambdabot> Cale's karma raised to 83.
21:14 takle joined
21:15 <Cale> reptar_: Yeah, the general convention is that lambdas extend as far to the right as possible
21:15 smichel17 joined
21:19 malaclyps joined
21:26 eacameron joined
21:36 tom7942 joined
21:39 takle joined
21:44 sigmundv_ joined
21:53 hiratara joined
21:56 <reptar_> putStrLn "\\" gives \, but x == 'λ' = "\\" ++ next gives something\\next
21:56 <reptar_> what is going on here?
21:56 <ExpHP> @pl m >>= (\x -> f x >>= g)
21:56 <lambdabot> g =<< f =<< m
21:56 splanch joined
21:56 <ExpHP> O_o backwards binds
21:57 <ExpHP> @pl (m >>= f) >>= g
21:57 <lambdabot> m >>= f >>= g
21:57 MotherFlojo joined
21:59 <ExpHP> reptar_ are you putStrLning the something\\next string?
21:59 <ExpHP> Otherwise the repl 'show's it which will show raw escapes
21:59 <* reptar_> facepalms
21:59 <reptar_> no
21:59 <reptar_> thanks
22:00 takle joined
22:03 <ExpHP> @pl (=<< (f =<< m))
22:03 <lambdabot> ((f =<< m) >>=)
22:03 <ExpHP> Yuck
22:03 <ExpHP> proving monad associativity doesn't look fun
22:03 <ExpHP> probably the one single actual hurdle in proving a monad
22:05 <ExpHP> @pl \g f m -> g =<< f =<< m
22:05 <lambdabot> (. (=<<)) . (.) . (=<<)
22:05 <ExpHP> okay, pointful it is then
22:06 <boxscape> what exactly is the monad associativity law? It's clearly not (f >>= g) >>= h == f >>= (g >>= h), right? (given that the second one wouldn't compile)
22:06 takle joined
22:07 <ExpHP> Boxscape it would look approximately like that if written with the >=> operator
22:07 <boxscape> ah, I see
22:07 <ExpHP> without it it is ... I'm trying to paste it :V
22:07 <ExpHP> (m >>= f) >>= g = m >>= (\x -> f x >>= g) there
22:08 <boxscape> okay, that makes sense
22:08 <ExpHP> dang wiki has this unicode triple equals :P
22:11 Gurkenglas_ joined
22:19 pie_ joined
22:24 malaclyps joined
22:26 eacameron joined
22:30 eacamero_ joined
22:31 hiratara joined
22:34 <ExpHP> okay now I just need to prove that Mk $ run v >>= K (run . \x -> Mk $ f' x >>= K g') == Mk $ run (Mk $ run v >>= K f') >>= K g'
22:34 <ExpHP> easy peasy
22:36 tom7942 joined
22:39 eacameron joined
22:51 conal joined
22:51 <CuriousErnestBro> λz.a what was a called again?
22:52 <ExpHP> undefined?
22:52 conal joined
22:52 <CuriousErnestBro> wait I mean if you try to apply this lambda term to say 1
22:52 <CuriousErnestBro> (λz.a)1
22:52 <CuriousErnestBro> =a
22:53 <CuriousErnestBro> it's a free variable? or something else?
22:53 <CuriousErnestBro> not const right?
22:53 <ExpHP> In haskell it would be (const a)
22:54 <ExpHP> dunno if there's lambda calculus lingo for what 'a' is
22:55 <boxscape> free variable sounds right to me
22:56 <ExpHP> in other languages one might say "a is closed over"
22:57 <ExpHP> the implication being it's part of some outer expression
22:57 <boxscape> it doesn't have to be part of some outer expression, in lambda calculus
22:57 <ExpHP> funky
22:58 <srhb> Yes, free variable is exactly correct.
22:59 splanch joined
22:59 eacameron joined
23:00 conal joined
23:02 malaclyps joined
23:04 sypwex joined
23:05 suls joined
23:05 tom7942 joined
23:10 suls joined
23:11 <CuriousErnestBro> what am I doing wrong here? Currying
23:11 <CuriousErnestBro> https://i.imgur.com/kmZDPvt.png
23:11 louispan joined
23:11 \Mike joined
23:15 <boxscape> second to third line, you replaced x instead of y, CuriousErnestBro
23:15 <boxscape> oh wait
23:15 <boxscape> nevermind
23:15 sandonfuge joined
23:17 <boxscape> is that an exercise from the book?
23:20 <boxscape> CuriousErnestBro: Everything looks actually correct to me; why do you think that something is wrong?
23:21 malaclyps joined
23:21 <CuriousErnestBro> because I can't reduce it further to something beautiful
23:21 <boxscape> where did you get this term from? Not everything necessarily becomes beautiful and simple in the end
23:22 <* ExpHP> </3
23:23 <CuriousErnestBro> boxscape, they gave it as example in the book (but didn't reduce it)
23:24 <CuriousErnestBro> they said due to alpha equivalence you may see expressions like (λxy.xxy)(λx.xy)(λx.xz)
23:25 <reptar_> (λy.(x y)) where does the x come from in this example?
23:26 <reptar_> full expression is ((λx.((λy.(x y))x))(λz.w)), if that matters
23:26 <boxscape> CuriousErnestBro: Yeah, probably just an example term where they didn't care much what it would evaluate to, then. On which page is it? I scrolled through and couldn't find it.
23:26 <boxscape> reptar_: the x is bound in the first lambda
23:27 <CuriousErnestBro> boxscape, page 39
23:28 <boxscape> ok, I still can't find it for some reason, but I suppose it doesn't change anything
23:28 eacameron joined
23:29 <CuriousErnestBro> boxscape, https://i.imgur.com/wTWjsJQ.png
23:29 <CuriousErnestBro> at the bottom of this image
23:29 <boxscape> weird, that's page 12 for me :P
23:30 <CuriousErnestBro> I must have an old version or something
23:31 <boxscape> yeah, I just downloaded it to make sure I have the newest version, but in the older version I have, it's actually page 44
23:32 <reptar_> boxscape: so what should i put for w to make this work? ((\x -> ((\y -> (x y))x)) (\z -> w))
23:32 <boxscape> reptar_: you're trying to translate the lambda calculus term into haskell?
23:32 <reptar_> yes
23:33 <boxscape> w is a free variable in the lambda calculus term; it's not defined to be anything
23:33 <reptar_> i know
23:33 <reptar_> so what do i define it as, is my question
23:33 <geekosaur> I would just prefix with \w ->
23:34 splanch joined
23:36 <boxscape> reptar_: you're still gonna have problems doing that in haskell because the haskell type system isn't happy with you applying a function to itself
23:36 <reptar_> ah, that's the problem then
23:37 <geekosaur> heh, the y is armed? :p
23:37 <boxscape> even (\x -> x x) doesn't work in haskell
23:38 <boxscape> though "let x = x in x x" typechecks... I'm not quite sure why
23:39 <geekosaur> :t let x - x in x x
23:39 <lambdabot> error: parse error on input ‘in’
23:39 <geekosaur> er
23:39 <geekosaur> :t let x = x in x x
23:39 <lambdabot> t
23:39 <geekosaur> :t undefined
23:39 <lambdabot> a
23:39 splanch joined
23:39 <geekosaur> (then just alpha rename)
23:39 TCZ joined
23:40 <geekosaur> the compiler recognizes that x is only inhabited by bottom and can match any type
23:40 <boxscape> ah
23:40 <boxscape> ok, I think that makes sense
23:41 <ExpHP> this associativity proof is going very not well
23:41 <ExpHP> unless all arbitrary functions g are equal to "pure", in which case it is going great
23:42 <ExpHP> s/going/not going/
23:43 <boxscape> Sounds like a const Monad or something
23:44 <ExpHP> It's a wrapper around Turtle's Shell type that streams stdout and stderr synchronously
23:45 <ExpHP> Like "Shell (Either (Either Line Line) a)", and I use Shell's monad instance on 'a' and let the Lefts pass through
23:46 <ExpHP> My definition for >>= is barely a line long yet the proof still explodes into an uncontrollable monstrosity
23:47 <ExpHP> which is to say I very likely messed up somewhere >_>
23:48 <boxscape> have you at least tested empirically wether it is associative?
23:48 <ExpHP> oops, s/not going/going/, I had it right the first time
23:49 <ExpHP> As a thought experiment it seems it should be associative
23:49 <ExpHP> The stdouts/stderrs are ultimately concatenated like a monoid
23:50 <boxscape> yeah, that would make it likely to be associative, I suppose
23:50 <ExpHP> hmmm, I guess that gives me a clue to where I might have gone wrong then, since it means in one of my equations stdout "disappeared"
23:51 malaclyps joined
23:52 <ExpHP> also I've been using it for a while and noticed nothing out of the ordinary in how it behaves
23:53 Rodya_ joined
23:53 <boxscape> that's good
23:53 <ExpHP> maybe I should turn on optimizations and see if that changes...
23:55 sypwex joined
23:59 <reptar_> can you really apply a function to itself?