<    April 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
00:11 eacameron joined
00:29 vaibhavsagar joined
00:30 eacameron joined
00:34 stef204 joined
00:36 eacameron joined
00:47 takle joined
00:56 Pupnik joined
01:05 baweaver joined
01:05 takle joined
01:05 ali_bush joined
01:05 ali_bush joined
01:06 jarshwah joined
01:10 Rodya_ joined
01:20 mac10688 joined
01:23 takle joined
01:26 dni- joined
01:30 uglyfigurine joined
01:31 takle joined
01:31 joneshf-laptop joined
01:40 takle joined
01:43 uglyfigurine joined
01:46 Youmu joined
01:47 permagreen joined
01:49 takle joined
02:04 eacameron joined
02:05 mac10688 joined
02:05 mizu_no_oto_work joined
02:07 takle joined
02:09 eacamero_ joined
02:09 shayan_ joined
02:15 takle joined
02:15 uglyfigurine joined
02:24 aarvar joined
02:25 takle joined
02:26 Sose_ joined
02:33 uglyfigurine joined
02:44 takle joined
02:47 uglyfigurine joined
02:56 meandi_2 joined
03:00 takle joined
03:02 exferenceBot joined
03:06 hexagoxel joined
03:12 takle joined
03:15 uglyfigurine joined
03:15 malaclyps joined
03:15 dni- joined
03:31 adamrbk joined
03:32 eacameron joined
03:38 takle joined
03:39 eacameron joined
03:42 uglyfigurine joined
03:47 Pupnik_ joined
03:50 systemfault joined
03:56 uglyfigurine joined
03:56 <Myrl-saki> mathu: Are you haunting this channel? omo
04:09 uglyfigurine joined
04:14 takle joined
04:23 uglyfigurine joined
04:28 takle joined
04:30 andyhoang joined
04:31 andyhoang joined
04:40 takle joined
04:56 takle joined
04:57 seagreen joined
05:00 uglyfigurine joined
05:03 systemfault joined
05:04 takle joined
05:04 dni- joined
05:12 <qmm> > let let replaceWithP = const 'p' in (fmap . fmap) replaceWithP lms
05:12 <lambdabot> <hint>:1:67: error:
05:12 <lambdabot> parse error (possibly incorrect indentation or mismatched brackets)
05:12 <qmm> > let replaceWithP = const 'p' in (fmap . fmap) replaceWithP lms
05:12 <lambdabot> error: Variable not in scope: lms :: f1 (f b0)
05:12 <qmm> > let replaceWithP = const 'p' ; lms = [Just "Ave", Nothing, Just "woohoo"] in (fmap . fmap) replaceWithP lms
05:12 <lambdabot> [Just 'p',Nothing,Just 'p']
05:13 <qmm> :t const
05:13 <lambdabot> a -> b -> a
05:13 uglyfigurine joined
05:14 <qmm> > [1,2,3] == [1,2,3]
05:14 <lambdabot> True
05:14 <qmm> > [Nothing, Nothing] == [Nothing, Nothing]
05:14 <lambdabot> True
05:15 <qmm> > let replaceWithP = const 'p' ; lms = [Just "Ave", Nothing, Just "woohoo"] in ((fmap . fmap) replaceWithP lms) == fmap replaceWithP lms
05:15 <lambdabot> error:
05:15 <lambdabot> • Couldn't match type ‘Char’ with ‘Maybe Char’
05:15 <lambdabot> Expected type: [Maybe Char]
05:15 <qmm> oh (fmap . fmap) is needed for the Maybe type
05:16 <qmm> i would have thought it would be written like the following
05:16 <qmm> > let replaceWithP = const 'p' ; lms = [Just "Ave", Nothing, Just "woohoo"] in fmap (fmap replaceWithP) lms
05:16 <lambdabot> [Just 'p',Nothing,Just 'p']
05:17 <qmm> i don't understand how (fmap . fmap) replaceWithP lms is the same as fmap (fmap replaceWithP) lms
05:22 takle joined
05:27 andrewhn51 joined
05:32 andyhoang joined
05:36 uglyfigurine joined
05:38 <qmm> glguy: i won't be offended if you help me
05:38 <glguy> I'm not sure how to take that o.O
05:39 <qmm> i should feel bad for highlighting you probably
05:39 <qmm> i just saw you talking in #haskell and thought i'd get your attention
05:39 <glguy> Your question is: why is (f . g) h x the same as f (g h) x ?
05:40 <qmm> yeah i guess it is
05:40 <glguy> OK: 1. (f . g) h x
05:41 <glguy> unfold definition of (.): (\y -> f (g y)) h x
05:41 <glguy> beta reduction: f (g h) x
05:42 <glguy> so the question is, which of those steps is surprising so we can focus on it
05:44 <glguy> don't forget that application associates to the left, so: a b c ==is== (a b) c
05:47 <qmm> i'm not sure i follow. maybe i will ask tomorrow when i have sleep :|
05:49 <glguy> OK. I'll keep my eye out for a question about that for a bit in case one comes to mind before you fall asleep :)
05:50 uglyfigurine joined
05:59 azahi joined
06:06 andyhoang joined
06:09 meandi_2 joined
06:13 andyhoang joined
06:19 glguy joined
06:22 shayan_ joined
06:28 howdoi joined
06:31 uglyfigurine joined
06:40 <adarqui_> when not programming for work, do most programmers - code/learn alone? or do they have friends to help? lmao
06:41 <adarqui_> for example when learning haskell, do most people learn it 'alone', or with alot of help from freenode, or at school, or what
06:41 <adarqui_> where to find such information regarding how normal humans learn things
06:44 eacameron joined
06:49 eacameron joined
06:50 slomo joined
06:50 slomo joined
06:52 Pupnik joined
06:53 dni- joined
06:54 eacameron joined
06:54 uglyfigurine joined
06:54 malaclyps joined
06:57 takle joined
06:59 eacameron joined
07:03 eacameron joined
07:09 eacameron joined
07:10 takle joined
07:13 eacamero_ joined
07:17 uglyfigurine joined
07:17 takle joined
07:23 eacameron joined
07:23 aarvar joined
07:29 eacameron joined
07:30 uglyfigurine joined
07:33 eacamero_ joined
07:34 takle joined
07:38 eacameron joined
07:44 uglyfigurine joined
07:47 thc202 joined
07:48 eacameron joined
07:49 dni- joined
07:50 madjestic joined
07:53 uglyfigurine joined
07:58 takle joined
08:01 nullcone joined
08:07 uglyfigurine joined
08:08 Axman6 joined
08:12 yellowj joined
08:13 Denthir joined
08:13 eacameron joined
08:14 colt44 joined
08:24 takle joined
08:30 uglyfigurine joined
08:37 takle joined
08:38 Denthir joined
08:43 Orion3k joined
08:48 uglyfigurine joined
08:53 takle joined
08:55 govg joined
08:56 pbrant joined
08:57 eacameron joined
09:05 zero_byte joined
09:05 GreySunshine joined
09:09 takle joined
09:09 eacameron joined
09:10 nirvinm joined
09:12 nirvinm left
09:12 nirvinm1 joined
09:15 eacameron joined
09:16 takle joined
09:19 azahi joined
09:20 uglyfigurine joined
09:22 kritzcreek_ joined
09:24 eacameron joined
09:24 takle joined
09:25 nirvinm1 joined
09:29 uglyfigurine joined
09:30 eacameron joined
09:33 takle joined
09:41 andyhoang joined
09:41 MrRicecake joined
09:43 uglyfigurine joined
09:50 shayan_ joined
09:50 eacameron joined
09:51 netheranthem joined
09:57 Zialus joined
10:08 GreySunshine joined
10:10 albertus1 joined
10:15 delexi joined
10:19 uglyfigurine joined
10:21 eacameron joined
10:23 Iceland_jack joined
10:25 binaryplease joined
10:29 <Akii> anyone knows the correct type of a servant server handler for DELETE?
10:31 MrRicecake joined
10:39 <Akii> hm just set it to () in the API
10:42 MrRicecake joined
10:43 yellowj joined
10:50 wildlander joined
10:51 wildlander joined
10:53 Denthir joined
10:56 vaibhavsagar joined
11:01 mengu joined
11:02 chlong joined
11:04 Iceland_jack joined
11:06 andyhoang joined
11:09 wei2912 joined
11:13 suds13_ joined
11:26 adamrbk joined
11:35 shayan_ joined
11:40 delexi joined
11:45 eacameron joined
11:46 wei2912 joined
11:49 acarrico joined
11:49 colt44 joined
11:53 eacamero_ joined
12:03 eacameron joined
12:14 nirvinm1 left
12:15 haskelleksah joined
12:17 eacameron joined
12:22 eacameron joined
12:22 wei2912 joined
12:23 stef204 joined
12:23 GreySunshine joined
12:23 Denthir joined
12:28 eacameron joined
12:33 eacameron joined
12:38 eacameron joined
12:45 MrRicecake joined
12:50 MrRicecake joined
12:58 MrRicecake joined
12:59 eacameron joined
13:07 azahi joined
13:08 eacameron joined
13:12 nyuszika7h joined
13:13 eacameron joined
13:19 eacameron joined
13:27 eacameron joined
13:28 dni- joined
13:33 eacameron joined
13:34 delexi joined
13:40 eacameron joined
13:43 harfangk joined
13:46 eacameron joined
13:50 nicoman joined
13:53 eacameron joined
13:57 govg joined
14:04 uglyfigurine joined
14:05 zero_byte joined
14:10 mizu_no_oto_work joined
14:19 Gurkenglas__ joined
14:22 delexi1 joined
14:33 Rodya_ joined
14:42 takle joined
14:45 takle_ joined
14:48 Denthir joined
14:58 anotherdude joined
14:59 Denthir joined
15:03 jship joined
15:08 mojjo joined
15:11 Denthir joined
15:12 takle joined
15:22 <geppettodivacin> adarqui_: I suspect most people have some kind of help. I used this channel for help when I got stuck learning things, and still do.
15:23 <geppettodivacin> adarqui_: bitemyapp has a website with a lot of good resources for learning Haskell, too: https://github.com/bitemyapp/learnhaskell
15:24 <geppettodivacin> ^he's also got a great book for learning Haskell. :)
15:29 takle joined
15:35 delexi1 joined
15:38 w4and0er96 joined
15:42 Rodya_ joined
15:51 nacon joined
15:51 nacon joined
15:58 <qmm> glguy: i fell asleep immediately :) i think i'm confused on how (f . g) h x is (\y -> f (g y)) h x
16:00 <glguy> qmm: That's just the definition of (.)
16:00 <glguy> http://hackage.haskell.org/package/base-4.9.1.0/docs/src/GHC.Base.html#.
16:10 haskelleksah joined
16:11 <qmm> glguy: oh
16:12 <qmm> :t (.) -- i understand the type signature. i hadn't looked at the source for function composition before
16:12 <lambdabot> (b -> c) -> (a -> b) -> a -> c
16:16 <qmm> if f is fmap and g is fmap, h is replaceWithP and x is lms, what is y?
16:16 <glguy> It's the fresh variable introduced by \y ->
16:17 <glguy> It comes from the definition of (.)
16:17 RoyalNightGuard joined
16:20 emmanuel_erc joined
16:21 vaibhavsagar joined
16:26 Rodya_ joined
16:44 <qmm> would it represent an element in a list?
16:45 <glguy> no
16:45 <glguy> It's going to become 'h'
16:45 <glguy> or in your example, 'replaceWithP'
16:49 systemfault joined
17:03 albertus1 joined
17:07 chbatey joined
17:12 Denthir joined
17:13 malaclyps joined
17:24 takle joined
17:25 earldouglas joined
17:27 takle_ joined
17:28 takle joined
17:32 malaclyps joined
17:38 <qmm> i think i can see how this work snow
17:39 <qmm> it is exactly equivalent to fmap (fmap replaceWithP) lms, but it's very different from the way i think
17:39 <qmm> i need to play around in ghci to solidify this knowledge i suppose
17:49 ebsen joined
17:53 eacameron joined
17:56 takle joined
17:57 haskelleksah joined
18:03 takle joined
18:07 zero_byte joined
18:09 binaryplease joined
18:13 MrRicecake joined
18:26 malaclyps joined
18:36 chbatey joined
18:53 saylu joined
18:53 t0by joined
19:10 Denthir joined
19:15 mizu_no_oto_work joined
19:19 takle joined
19:35 <chbatey> On chapter 16 exercises and stuck trying to write a functor for newtype Mu f = InF { outF :: f (Mu f) } which has kind (* -> *) -> *. Any tips?
19:37 Denthir joined
19:39 <Cale> Functor instances have to be for types of kind * -> *
19:40 <Cale> Did you mean something a little different? Usually Mu is applied to types which are functors.
19:40 <Cale> I don't know what the exercise says
19:41 <chbatey> It just says try and implement a Functor instance for it with the possibility that it is impossible. With my limited knowledge I don't think you can
19:43 <Akii> f (Mu f) is already strange
19:43 <monochrom> Consider the impossible possibility. Use kind to argue your case.
19:44 <Akii> if f is * -> * how can Mu f exist
19:46 malaclyps joined
19:47 <chbatey> To make the kind work I feel like I need to partially apply the (* -> *) but i don't know if that makes sense
19:47 Rodya_ joined
19:47 <geekosaur> so it sounds to me like it wants you to work through the types and figure out first whether it is possible or not
19:47 <geekosaur> ...and why/why not
19:49 <Akii> and I'm just sitting here searching for a practical use
19:51 <geekosaur> it's one way to encode the Y combinator (type level recursion)
19:53 <chbatey> i am not sure how to construct it given its I need to pass in an in a Mu to InF
19:53 colt44 joined
19:59 Denthir joined
20:08 <monochrom> Akii: f :: * -> *, Mu f :: *, therefore f (Mu f) :: *, all is well again.
20:09 <benzrf> Akii: the practical use is that you can express recursive types as applications of Mu to non-recursive types
20:09 <benzrf> Akii: then you can write code which is generic over recursive types
20:09 <benzrf> have you seen, for example, generalized folds by encoding your types as fixpoints of polynomial functors?
20:09 <Akii> nope
20:10 <benzrf> oh, it's quite neat!
20:10 <benzrf> do you know what a polynomial functor is?
20:10 <Akii> nope
20:10 <benzrf> ah
20:10 <Akii> I'm glad I know what fmap does
20:10 <benzrf> have you seen the terminology of "products" and "sums" to refer to types?
20:11 aarvar joined
20:11 <Akii> I watched Bartosz' videos
20:12 <Akii> vaguely remember what that is
20:12 <benzrf> ok!
20:13 <benzrf> so, the idea of the name "polynomial functor" is that, just like polynomials are functions built out of constants, sums, products, and the argument, polynomial FUNCTORS are functors built out of constants, sums, products, and the argument
20:13 <benzrf> e.g.
20:13 <benzrf> F t = t * t + Int
20:14 permagreen joined
20:14 <benzrf> or if you prefer,
20:14 <benzrf> newtype F t = F (Either (t, t) Int)
20:15 <benzrf> you can take the sum or product of two polynomial functors and get a new polynomial functor, just like adding or multiplying polynomials
20:15 <benzrf> writing "1" for the unit type (), we can make identifications like
20:15 <benzrf> Maybe = x + 1
20:16 <benzrf> Maybe is isomorphic to newtype F x = F (Either x ())
20:16 <benzrf> Akii: sorry, does this make sense?
20:16 Rodya_ joined
20:16 <Akii> I've been taking a brief detour to wikipedia to look up polynomials
20:16 peterbecich joined
20:17 <benzrf> oh, haha
20:17 <benzrf> i can relate to that
20:17 <Akii> like I get the types
20:17 <benzrf> alright!
20:17 <Akii> but no idea what it has to do with those curves
20:18 yellowj joined
20:18 <Akii> and with mappings from one category to another
20:18 <benzrf> oh, the analogy (at the surface level anyway) is primarily about the form of the polynomial expressions
20:18 <benzrf> not the shapes of their graphs
20:18 <benzrf> here's our analogy:
20:18 yellowj joined
20:18 <benzrf> @let fAdd f g = \x -> f x + g x
20:18 <lambdabot> Defined.
20:18 <benzrf> @let fMul f g = \x -> f x * g x
20:18 <lambdabot> Defined.
20:19 <benzrf> now our polynomials are all the functions we can write like this:
20:19 <benzrf> @let somePoly = (id `fMul` id) `fAdd` const 3
20:19 <lambdabot> Defined.
20:19 <benzrf> > somePoly 3
20:19 <lambdabot> 12
20:19 <benzrf> that is to say, using fMul, fAdd, id, and const
20:20 <benzrf> so that's normal "polynomial" functions
20:20 <Akii> :t fAdd
20:20 <lambdabot> Num a => (t -> a) -> (t -> a) -> t -> a
20:20 <Akii> :t const
20:21 <lambdabot> a -> b -> a
20:21 <Akii> wat
20:21 chlong joined
20:21 <benzrf> oh have u not seen const
20:21 <benzrf> it's defined "const x y = x"
20:21 <Akii> I have
20:21 <benzrf> oh
20:21 <benzrf> that's "const 3" up there
20:21 <Akii> I'm just.. processing what this means
20:21 <benzrf> application binds tighter than infix
20:22 <Akii> > 3 * 3
20:22 <lambdabot> 9
20:22 <Akii> aha
20:22 <benzrf> well, when you normally do addition and multiplication of polynomials in math, you do things like "(x + 3) * (x + 2)"
20:22 <Akii> gotcha
20:22 <benzrf> but if you want to formally express this, what you're really manipulating have to be either expressions or functions
20:22 <benzrf> i dont want to implement this as some kind of expression tree, so i'm using functions
20:23 <Akii> I feel terribly slow but I do understand how you ended up with 12 now
20:23 <benzrf> and in that case i have to use lifted multiplication. not just regular multiplication of numbres
20:23 <benzrf> ok cool :)
20:23 Gurkenglas__ joined
20:23 Denthir joined
20:23 <benzrf> so with these functions, a polynomial like "3x^2 - 2" would be
20:24 <benzrf> (const 3 `fMul` id `fMul` id) `fAdd` const (-2)
20:24 <Akii> just to give some background: I had that in school but I never understood what it meant
20:24 <benzrf> ah, ok!
20:24 delexi joined
20:24 <Akii> I've been applying rules to tests and succeeded
20:24 <benzrf> heh
20:25 <Akii> somehow
20:25 <benzrf> for the record, there's a one-to-one correspondence between "polynomial expressions over the real numbers" and "polynomial functions over the real numbers"
20:26 <benzrf> that is to say, if i have a given piece of syntax of the form "3x^2 - 5" or something, that uniquely corresponds to the actual function f where f(x) = 3x^2 - 5
20:26 <benzrf> so you typically equivocate between them
20:27 <benzrf> from the "functions" viewpoint, the polynomials are precisely the functions that can be build out of lifted addition & multiplication, constant functions, and the identity
20:27 <benzrf> just like from the "expressions" viewpoint, they're the expressions that can be built out of addition & multiplication, constant terms, and a variable
20:27 tusj joined
20:27 <benzrf> anyway!
20:28 <Akii> woot
20:28 <Akii> :D
20:28 <benzrf> if we swap out our number constants, additoin, and multiplication for type constants, type "addition", and type "multiplication", we get a useful concept
20:28 jjBliss joined
20:28 <benzrf> and so by analogy we call the functors you can get this way, "polynomial" functors
20:29 <benzrf> @let data Times f g x = Times (f x) (g x)
20:29 <lambdabot> Defined.
20:29 <benzrf> @let data Plus f g x = PlusF (f x) | PlusG (g x)
20:29 <lambdabot> Defined.
20:29 <benzrf> and we have Identity and Const already from the standard library
20:29 <benzrf> (for reference, that's "newtype Identity x = Identity x" and "newtype Const r a = Const r")
20:30 <benzrf> now our polynomial functors are the ones built out of these four blockjs
20:30 <benzrf> *blocks
20:30 <* Akii> creates new lib Block.js
20:30 <benzrf> hah
20:30 <Akii> it's too late now
20:30 <benzrf> for example, take:
20:30 <benzrf> Identity `Plus` Const ()
20:30 <benzrf> @let type M = Identity `Plus` Const ()
20:30 <lambdabot> Defined.
20:30 <benzrf> what terms have type "M a"?
20:31 <benzrf> (for a given a, not polymorphic ones)
20:31 <benzrf> (so like, what would be the "M Int"s)
20:33 <Akii> what's `Plus`
20:33 <benzrf> 04:29:20 benzrf │ @let data Plus f g x = PlusF (f x) | PlusG (g x)
20:33 <Akii> you defined the data type
20:33 <benzrf> that's just infix application of it
20:33 <benzrf> same as: Plus Identity (Const ())
20:33 <Akii> but how can you use that like that
20:33 <benzrf> just like functions
20:33 <Akii> oh
20:34 <Akii> wow I had no idea that was possible
20:35 <benzrf> heh
20:36 <benzrf> Akii: so can you write a term of, for example, type "M Int"?
20:36 aarvar joined
20:37 <Akii> I'm just guessing at this point
20:37 <Akii> Const () can't be adding Ints
20:38 <Akii> so () might be the phantom thingy and then identity int "plus" const another int
20:38 <benzrf> well, hold on
20:38 <Akii> I might not be ready for this yet ^^
20:38 <benzrf> let's unfold the type
20:38 <benzrf> we have:
20:39 <benzrf> Plus Identity (Const ()) Int
20:39 <benzrf> and: data Plus f g x = PlusF (f x) | PlusG (g x)
20:39 <benzrf> so our terms can either be a PlusF with an Identity Int argument, or PlusG with a Const () Int argument
20:40 <benzrf> @src Identity
20:40 <lambdabot> newtype Identity a = Identity { runIdentity :: a }
20:40 <benzrf> @src Const
20:40 <lambdabot> Source not found.
20:40 <benzrf> hm
20:40 <benzrf> newtype Const r a = Const {getConst :: r}
20:40 <Akii> newtype Const r a = Const r
20:40 <Akii> is what you wrote
20:40 <Akii> with a being phantom
20:42 <benzrf> yeah
20:42 <benzrf> that's equivalent
20:43 <benzrf> i just didnt make an accessor
20:43 <Akii> I get that, just now what that means
20:43 <benzrf> ah
20:43 <Akii> Const ()
20:43 <benzrf> :)
20:43 <benzrf> ok, so - do you think you can write a term now?
20:43 <Akii> what is a term?
20:44 <Akii> ^^
20:44 <benzrf> an expression
20:46 <Akii> I feel you're rubbing the solution into my face but I don't see it
20:47 <benzrf> ah, sorry
20:47 <benzrf> well, each term will be either:
20:47 <benzrf> PlusG (Const ())
20:47 <benzrf> or,
20:47 <benzrf> PlusF (Identity n)
20:47 <benzrf> where n is some int
20:48 <Akii> could also be PlusF (Const ()) and PlusG (Identity n)
20:48 <Sornaensis> can type theory do my taxes for me?
20:49 <Akii> I long forgotten where this might lead but I've been having a valid case for this in the past
20:49 <monochrom> No, but someone can use type theory to write a program that does taxes for you.
20:49 <monochrom> Also, isn't it past the USA deadline?
20:50 <Sornaensis> I am preparing for next year
20:50 <monochrom> Ah
20:50 <benzrf> Akii: no, that wouldn't be well-typed
20:50 <Akii> http://lpaste.net/354591
20:50 <benzrf> Akii: for the same reason that "Left 3" can't have type "Either String Int", but "Right 3" can
20:50 <Akii> oh
20:51 <benzrf> :t PlusF
20:51 <lambdabot> forall k (g :: k -> *) (x :: k) (f :: k -> *). f x -> Plus f g x
20:51 <benzrf> :t PlusG
20:51 <lambdabot> forall k (f :: k -> *) (x :: k) (g :: k -> *). g x -> Plus f g x
20:51 <benzrf> ignore all the fancy type stuff, just focus on the part after the dot
20:51 <benzrf> this is just Either lifted over type constructors
20:52 <benzrf> Plus f g x is equivalent to Either (f x) (g x)
20:52 <benzrf> analogous to how "(f `fAdd` g) x" is equivalent to "f x + g x"
20:54 <Akii> data Plus f g x = PlusF (f x) | PlusG (g x)
20:54 <Akii> what prevents me from putting Const () into PlusG or PlusF
20:54 <Akii> Identity and Const () are both * -> *
20:55 <benzrf> Akii: you can do PlusF (Const ())
20:55 <benzrf> but then you'll have something of type "Plus (Const ()) Whatever Int", not "Plus Whatever (Const ()) Int"
20:56 <benzrf> again, like how you can do Left 3, but then you'll have "Either Int String", not "Either String Int"
20:56 <benzrf> given that we've fixed "type M = Identity `Plus` Const ()", it has to be PluSG
20:56 <benzrf> PlusG*
20:57 <adarqui_> geppettodivacin: ya thanks. im actually going to buy that book soon.
20:57 <adarqui_> looks great.. also looks like a serious amount of effort went into it.
21:00 xificurC joined
21:00 circ-user-YJwe5 joined
21:03 <Akii> https://twitter.com/lucasdicioccio/status/852974061546352642
21:03 <Akii> just throwing in some real world
21:04 <Akii> benzrf: I'll re-read this tomorrow
21:04 <Akii> no way I get this today
21:04 <Akii> @karma+ benzrf
21:04 <lambdabot> benzrf's karma raised to 26.
21:04 <benzrf> :)
21:04 <Akii> :D
21:04 <benzrf> ok then!
21:04 <benzrf> maybe i'll be able to explain the original thing regarding Mu after that
21:12 kadoban joined
21:12 <benzrf> Akii: when you do look at this again, try doing these exercises! https://gist.github.com/17695d39c73d6112c87103612dc18b6e
21:12 seagreen joined
21:12 <benzrf> (if you don't know about writing instances that depend on other instances yet, you don't have to bother)
21:13 <benzrf> anyway, be back later
21:14 pilne joined
21:20 kobigurk joined
21:21 kobigurk joined
21:26 aarvar joined
21:32 haskelleksah joined
21:37 ksimon joined
21:39 earldouglas joined
21:49 haskelleksah joined
21:49 dpren joined
21:51 dpren left
21:54 systemfault joined
21:54 stef204 joined
22:03 hiratara joined
22:15 RoyalNightGuard left
22:31 hiratara joined
22:32 pixelfog joined
22:35 Uniaika joined
22:42 jship joined
23:03 iAmerikan joined
23:09 madjestic joined
23:17 texasmynsted joined
23:24 geekosaur joined
23:26 takle joined
23:38 Gurkenglas joined
23:44 takle joined
23:56 pinkythepig joined
23:58 MrRicecake joined
23:58 takle joined