00:01 <Zemyla> Or maybe it's the other way around. f a -> f (f (f a)).

00:02 <Zemyla> Because I know contrareturn would be a -> f (f a).

00:04 <Ptival> is there a known trick to deal with a state monad where certain parts of the code should only have read-only access to certain parts of the state?

00:04 <Ptival> seems lens-y

00:05 <jle`> Ptival: there's a common readOnly pattern

00:05 <michalrus> jle`: so that’s what glguy suggested, also. (: I’ll look into that, looks much more interesting than IoRef. Thank you, to both of you!

00:05 <jle`> readOnly :: Reader s a -> State s a

00:05 <jle`> and you can use 'zoom' on the result

00:06 <jle`> zoom :: Lens s t -> State t a -> State s a

00:06 <Ptival> ah yeah that could help

00:06 <jle`> i'm not sure if there's a pre-written way that combines them, though

00:07 <jle`> i've only seen readOnly as an idiom but I haven't seen it defined anywhere

00:07 <Ptival> the idea is my state has a global component, and a local component, and some functions should have read-only access to the global part and read-write to local, while the toplevel code is allowed to modify the global

00:07 <jle`> so `zoom _1 . readOnly $ do ....`, the do block would be a Reader with access to the first item in a tuple state

00:07 <Ptival> I could also make the local parts just run in a different state monad I guess

00:08 <Ptival> maybe it would be simpler

00:08 <jle`> yeah, the typical way is to write the local parts in a State monad that has only small portion of the global state as its state

00:08 <Ptival> to put (Reader GlobalState, State LocalState) or something

00:08 <Ptival> makes sense :)

00:08 <jle`> and then use 'zoom' to use it as a part of a bigger fatty state type

00:08 <Ptival> thanks for the brainstorming

00:08 <jle`> no problem :)

00:09 <Zemyla> Yeah, because contrabind would be f a -> (b -> f (f a)) -> f b.

00:09 <jle`> \me . o ( zoom _1 . readOnly :: Reader r a -> State (r, s) a )

00:09 <robkennedy> Is DPH still active? I can't find a repo that compiles with ghc 8, but it seems perfect for my usecase

00:10 <robkennedy> In particular, is there an implementation for the syntax SPJ mentions: `[: 1,2,3 :]`

00:15 <robkennedy> @pl \a -> \f g -> (,) <$> f a <*> g a

00:15 <lambdabot> ((((,) <$>) .) .) . ap (flip . (((.) . (<*>)) .) . flip id) (flip id)

00:15 <Ptival> oh, but if I have (MonadReader T m, MonadState T m), how do I make sure from the caller point of view that it's not the State monad filling in the Reader task?

00:17 <glguy> Ptival: By using those constraints you're saying you don't care

00:17 <robkennedy> @pl \a -> let f x = if null x then Nothing else Just (length x) in (,) <$> listToMaybe a <*> f a

00:17 <lambdabot> flip (((,) <$>) .) (ap (flip if' Nothing . null) (Just . length)) . ap ((.) . (<*>) . listToMaybe) (flip id)

00:17 <dunx> nnpppp/buffer 45

00:17 <robkennedy> Damn lambdabot too clever

00:17 <Ptival> glguy: so I'd need a newtype to be able to discriminate?

00:18 <glguy> Ptival: Just pick an 'm' that has the behavior you want

00:20 <robkennedy> @djinn (x -> Maybe a) -> (x -> Maybe b) -> x -> Maybe (a,b)

00:20 <lambdabot> f a b c =

00:20 <lambdabot> case b c of

00:20 <lambdabot> Nothing -> Nothing

00:20 <lambdabot> Just d -> case a c of

00:20 <lambdabot> Nothing -> Nothing

00:20 <lambdabot> Just e -> Just (e, d)

00:20 <glguy> robkennedy: You can play with lambdabot in /msg

00:21 <robkennedy> Sorry. Apart from the distraction: do you know the status of DPH?

00:30 <`Guest03> @pl \name loc -> attributeLocation prog name $= loc

00:30 <lambdabot> ($=) . attributeLocation prog

00:30 <`Guest03> dang

00:32 <nilof> What alternative preludes are the most used?

00:32 <Welkin> I think most people don't bother with any prelude

00:33 <Welkin> I've used classy-prelude in the past, but it is overly complex

00:33 <Welkin> all the prelude does it re-export other modules

00:33 <Welkin> is*

00:34 <Jenaf> Hi there! I'm beeing stupid right now

00:34 <Jenaf> whats the equivalent to "map" for Data.Sequence

00:34 <Welkin> is that a bee joke?

00:34 <Welkin> Jenaf: fmap

00:34 <Welkin> fmap is the generic map

00:34 <Welkin> :t fmap

00:34 <lambdabot> Functor f => (a -> b) -> f a -> f b

00:35 <Jenaf> okay, do i need to import it from traversable or so?

00:36 <Koterpillar> it is in Prelude

00:36 <`Guest03> omg

00:37 <`Guest03> why don't modules export specialized functions with standard names?

00:37 <`Guest03> like map in this case

00:37 <Welkin> ?

00:37 <Welkin> fmap is the standard...

00:37 <`Guest03> map is too

00:38 <Welkin> map is the weird one that is specialized to List

00:38 <`Guest03> Data.Sequence.map would be specialized to Seq

00:38 <inferno-cop> Welkin: Does map only exist for historical reasons?

00:38 <Welkin> yes

00:38 <Welkin> fmap is what you want

00:38 <`Guest03> maybe i like to use specialized functions

00:38 <`Guest03> for extra type robustness

00:38 <`Guest03> or whatever

00:39 <`Guest03> is it so hard?

00:39 <Welkin> I assume that the 'f' stands for "Functor", as in, "functor map"

00:39 <pacak> `Guest03: Specialized functions are actually worse

00:39 <pacak> For example

00:39 <pacak> :t id

00:39 <lambdabot> a -> a

00:39 <pacak> There's only one implementation (ignoring bottoms)

00:40 <pacak> But for

00:40 <pacak> :t id (Int -> Int)

00:40 <Welkin> I have felt the pain of using specialized functions for everything when using Elm

00:40 <lambdabot> error:

00:40 <lambdabot> Pattern syntax in expression context: Int -> Int

00:40 <lambdabot> Did you mean to enable TypeApplications?

00:40 <Welkin> it sucks

00:40 <pacak> there are a whole bunch of versions

00:40 <Welkin> you have to explictly import and qualify *everything*

00:40 <`Guest03> oh well

00:40 <pacak> :t map

00:40 <pacak> :t fmap

00:40 <lambdabot> (a -> b) -> [a] -> [b]

00:40 <lambdabot> Functor f => (a -> b) -> f a -> f b

00:40 <Koterpillar> `Guest03: Elm does that, and it's a pain

00:41 <`Guest03> anyway map not only carries that, but also promise that it won't reorder and duplicate elements

00:41 <pacak> function with map's type signature can change the shape, fmap - does not.

00:41 <pacak> Not in the type signature

00:41 <Welkin> @src map

00:41 <lambdabot> map _ [] = []

00:41 <lambdabot> map f (x:xs) = f x : map f xs

00:41 <Welkin> wrong one

00:41 <inferno-cop> I think it's bad enough that there aren't general versions of collection functions like (!), insert etc

00:41 <Welkin> map is actually defined using fmap

00:41 <Welkin> so, it gives you no benefits whatsoever

00:42 <Welkin> ! is only used for Vector, !! for List

00:42 <Welkin> !! is almost never used for any reason

00:42 <`Guest03> Welkin: what should i use: singleton or return?

00:42 <Welkin> because List indexing is slow

00:42 <Koterpillar> `Guest03: there's another choice, pure

00:43 <Welkin> use pure o.o

00:43 <`Guest03> or pure

00:43 <`Guest03> are you sure?

00:43 <Welkin> unless you want to be explicit and use Map.singleton

00:43 <`Guest03> what if we are deep down in layers of Applicative?

00:43 <inferno-cop> But I mean, you have Data.Map.! and Data.Array.! for example

00:43 <Welkin> that's fine

00:43 <inferno-cop> And you have to qualify them if you've got both in scope (I think?)

00:43 <Welkin> you have to qualify Vector, Array, etc almost every time anyway

00:44 <Welkin> because they share similar apis with List

00:44 <Welkin> at least Vector does

00:44 <`Guest03> Welkin: that would be V., A., ...

00:44 <Welkin> yes

00:44 <Welkin> I am not sure what your point is

00:44 <inferno-cop> Yeah, why can't we just have a Indexable typeclass or something, so we don't have to qualify

00:44 <`Guest03> i want to be explicit when i want

00:45 <Welkin> fmap comes from the Functor typeclass

00:45 <`Guest03> specialized = explicit

00:45 <`Guest03> abot the type

00:45 <Welkin> ! does not have a typeclass

00:45 <`Guest03> by the way

00:45 <`Guest03> why the names ! and !! were chosen?

00:45 <inferno-cop> It doesn't, but I am saying the world may be a better place if it had a typeclass

00:46 <Welkin> inferno-cop: that has been taken to its logical extreme with classy-prelude

00:46 <Welkin> and it's a monster

00:46 <Welkin> too many typeclasses makes the code impossible to understand

00:46 <glguy> gaudy-prelude?

00:46 <inferno-cop> Oh, I hadn't heard about that, but I can definitely imagine it...

00:46 <Welkin> I think the name 'classy' refers to typeclasses :P

00:47 <`Guest03> inferno-cop: in that case, either that typeclass had to provide algorithm complexity restrictions or hadn't

00:47 <`Guest03> in first case, there are less !'s which could make it into the typeclass

00:47 <`Guest03> in the second case, you can write less code or be less sure about its complexity

00:48 <`Guest03> have to *

00:48 <Welkin> `Guest03: not having generic functions like `fmap` means you can never write generic functions yourself

00:48 <inferno-cop> Fair point.

00:48 <Welkin> that is horrible

00:48 <Welkin> you have a function you want to operate on Lists, and on Array, and on Map, and on etc.

00:48 <Welkin> have to copy/paste it several times

00:48 <Welkin> it's just stupid

00:48 <`Guest03> Welkin: i never said that we don't need generic functions

00:48 <Welkin> that is why Elm sucks

00:48 <Welkin> at least one reaosn

00:48 <`Guest03> i said that i need names for specialized versions too

00:49 <`Guest03> defined in modules.

00:50 <Welkin> `fmap :: (a -> b) -> [a] -> [b]` -- `Guest03 , done

00:50 <inferno-cop> But at the same time, lists, arrays, maps, sets etc are all different in important ways, so writing generic implementations of algorithms for them would seldom be a good idea (if you care about performance)

00:50 <Welkin> there is your specialized fmap for List

00:50 <`Guest03> Welkin: too verbose

00:50 <`Guest03> could just use L.map

00:50 <Jenaf> I still have the feeling that I'm producing ugly code:

00:50 <Jenaf> ieldReducer rows (a:(b:list))= (fmap (bfRowSetZeroPastN b) (Seq.take (b-a) rows))><(fieldReducer (Seq.drop (b-a) rows) (b:list))

00:50 <Welkin> Jenaf: this ain't lisp

00:50 <Welkin> !

00:51 <pacak> Jenaf: You are.

00:51 <Welkin> Jenaf: paste it on lpaste and we can show you how to clean it up

00:51 <Jenaf> I know but $ keeps throwing compilation errors

00:51 <Welkin> @lpaste

00:51 <lambdabot> Haskell pastebin: http://lpaste.net/

00:51 <Welkin> also, don't try to construct one big expression

00:51 <inferno-cop> At least their should be a space on both sides of the equals sign :P

00:51 <Welkin> break it up into smaller functions and use let/where clauses where they can help

00:52 <Jenaf> in this case i think breaking it up into where would make it less readable

00:52 <Jenaf> I've already broken down the main thingy into many subfunctions ^.^

00:53 <`Guest03> blah @lpaste

00:53 <`Guest03> hm

00:53 <Jenaf> http://lpaste.net/353365

00:54 <`Guest03> could parse that, then user could mention lpaste and invoke command simultaneously

00:54 <Jenaf> I'm quite sure I don't have the perfect representation of the Problem I want to tackle.

00:54 <MarcelineVQ> `Guest03: it's bad form for a bot to guess what you intend, it tends to produce noise

00:54 <`Guest03> that's bad if noise is very bad

00:55 <MarcelineVQ> noise is very bad

00:55 <`Guest03> it's not very bad for me...

00:55 <Welkin> Jenaf: something more like this http://lpaste.net/353366

00:55 <Welkin> but add type signatures to your functions

00:55 <`Guest03> okay

00:56 <Jenaf> I think i always have signatures

00:56 <Jenaf> thats what i start with when writin a function

00:56 <Welkin> Jenaf: I see you are using list comprehensions in your code as well

00:56 <Welkin> try to avoid those, especially for your use case

00:56 <Welkin> just use a simple `filter` instead

00:57 <Jenaf> can you tell me an example line?

00:57 <Jenaf> (jsut line number)

00:57 <Jenaf> also: I don't get <$>

00:57 <Welkin> http://lpaste.net/353365#line121

00:57 <Welkin> `<$>` is infix `fmap`

00:57 <Welkin> you could also write it as `fmap` (literally with backticks)

00:57 <Welkin> wrapping any function in backticks makes it infix

00:58 <Welkin> <$> is specifically already defined as infix though

00:58 <Jenaf> okay, so it's syntactical sugar

01:00 <Jenaf> btw: those lists/sequences are only 9 elements long

01:00 <ReinH> `` is syntax, <$> is a normal operator.

01:01 <Jenaf> see line 70 for evil magic number code

01:01 <inferno-cop> @src (<$>)

01:01 <lambdabot> f <$> a = fmap f a

01:01 <Welkin> Jenaf: I see a lot of unnecessary parentheses, but you'll get used to precedence rules with time

01:01 <Jenaf> yeah

01:02 <Jenaf> I tend to try and be better safe then sorry.

01:02 <Jenaf> and soemtimes $ messes up at compliation/ loading in ghci

01:02 <Welkin> the great thing about haskell is that you can afford to take risks

01:02 <Welkin> if you mess up, the compiler will tell you

01:02 <Jenaf> so I feel unsure about using $, but I know what parans do

01:02 <Welkin> unlike other languages that fail at runtime

01:03 <Welkin> $ is function application, but it has the lowest precendence

01:03 <inferno-cop> I actually think $ often looks uglier than parentheses

01:03 <Jenaf> like when you use gcc to compile C code with null pointers

01:03 <Welkin> so it's like wrapping everything to the right-hand side of the $ in parens

01:04 <Jenaf> what I don't really like is stuff like

01:04 <Jenaf> if isNothing squares

01:04 <Jenaf> then Nothing

01:04 <Jenaf> else Just $ foo (fromMaybe (error "unreachable") squares)

01:04 <Koterpillar> Jenaf: this is fmap foo

01:05 <inferno-cop> that can be rewritten!

01:05 <Welkin> try to avoid using if-then-else

01:05 <Welkin> it is not idiomatic and there are almost always better ways to write it

01:05 <Koterpillar> > let foo = (* 2) in fmap foo (Just 3)

01:05 <lambdabot> Just 6

01:05 <Koterpillar> > let foo = (* 2) in fmap foo Nothing

01:05 <lambdabot> Nothing

01:05 <Welkin> use pattern matching as much as possible

01:05 <Welkin> and higher-order functions

01:05 <Jenaf> yeah

01:05 <drostie> What I like about $ is that a $ b $ c $ d is equal to a . b . c $ d.

01:06 <Welkin> and yes, the Myabe Monad instance

01:06 <Koterpillar> functor

01:06 <Welkin> Maybe*

01:06 <inferno-cop> yup, your entire example can be rewritten: fmap foo squares

01:06 <Welkin> er, Functor yes

01:06 <Welkin> the Monad instance is very useful too though :P

01:06 <Jenaf> lul

01:06 <Koterpillar> Jenaf: but if you want to go step by step, it's this:

01:07 <Koterpillar> case squares of Nothing -> Nothing; Just value -> Just $ foo value

01:07 <Jenaf> that should be äquivalent to the compiler?

01:07 <Jenaf> (interpreted is a different story ofc)

01:08 <Koterpillar> all three are equivalent

01:08 <Jenaf> but that part with "fromMaybe (error "unreachable") foo" is really ugly

01:09 <inferno-cop> Yeah, since you know that error "unreachable" is impossible to reach

01:09 <Jenaf> so let mayList::Maybe[a]

01:09 <inferno-cop> That's where you should use pattern matching

01:09 <Jenaf> then I can fmap (foo:: a->b) mayList

01:09 <Jenaf> ?

01:10 <Koterpillar> :t fmap

01:10 <lambdabot> Functor f => (a -> b) -> f a -> f b

01:10 <Koterpillar> replace f with Maybe

01:10 <mbw> Ok the other day I asked for some advice about refactoring some data structures. It boiled down to introducing some more "helper types" in order to reduce overlap in constructor arguments. One of those subtypes was something like Helper a = None | A a | B b. I thought "None could be represented by Maybe" and made another type like Helper' a = A' a | B' b, and used it like Maybe (Helper' a). However, in

01:10 <mbw> another function of type a -> Maybe a I introduced a very subtle bug because of this, when going from do notation to "clever Applicative style". So, and this is probably pretty opinionated, is there a lesson to learn from this? Should I try not to be overly clever with types, or stick to do notation? I often find myself "going back to a temporary do representation" when doing changes in functions using

01:10 <mbw> applicative style, after all. Or is Maybe inside data structures generally a little dangerous because of cases like this?

01:11 <inferno-cop> Jenaf: No, if you have mayList :: Maybe a, then you can do fmap (f :: a -> b) mayList :: Maybe b

01:11 <Jenaf> okay i think i got that

01:12 <inferno-cop> Jenaf: and that's the same as: case mayList of { Nothing -> Nothing; Just x -> Just (f x) }.

01:13 <Jenaf> Memo to self: you always learn things and meet helpfull people at #haskell

01:13 <Jenaf> thanks a lot ^.^

01:14 <inferno-cop> So I heard! This is actually my first time ever using IRC :)

01:18 <stevenxl> Hi folks. I'm reading Real World Haskell and I have to run ghc -c to compile a source file to object code.

01:18 <stevenxl> Those directions seem to be out of date

01:18 <stevenxl> What should I replace them with?

01:18 <ezyang> what's the full snippet? ghc -c still works

01:19 <dunx> stevenxl: man ghc

01:19 <dunx> iirc -c works tho

01:19 <dunx> did for me last time i was writing progs in haskell

01:19 <mbw> stevenxl: Generally, the comments you can find on the online version of the books are very helpful.

01:19 <mbw> *book

01:20 <inferno-cop> ghc -c works for me, just tested it

01:20 <mbw> Most of the issues which arise from RWH being dated are adressed there.

01:20 <stevenxl> mbw: online version you say?

01:20 <Jenaf> I'm going to bed

01:20 <Jenaf> see you later space cowboys

01:20 <stevenxl> inferno-cop: weird. I am using stack so running `stack ghc -c Source.hs`

01:20 <mbw> http://book.realworldhaskell.org/read/

01:21 <inferno-cop> stevenxl: Ah, stack. I didn't try that

01:21 <stevenxl> mbw: thank you!

01:21 <stevenxl> inferno-cop: do I have the wrong program installed?

01:22 <stevenxl> I see the -c option in `man ghc`. Stop after generating object file.

01:22 <mbw> What are you using the object files for? I don't remember this from reading the book.

01:23 <stevenxl> http://book.realworldhaskell.org/read/writing-a-library-working-with-json-data.html

01:23 <stevenxl> mbw: the module is not set up to correctly generate an executable. missing the main function, etc.

01:23 <stevenxl> i think i'm just going to brew install ghc and take it from there

01:24 <stevenxl> mbw: See section Compiling Haskell Source if you're interested in the area I'm on.

01:24 <mbw> Yeah I saw it.

01:25 <inferno-cop> stack is good though, but I guess 'stack build' is meant to take care of build details...

01:27 <Welkin> using homebrew to install ghc?

01:27 <Welkin> sounds like a terrible idea

01:27 <Welkin> just use stack or install from the bindist

01:27 <Welkin> or use nix

01:28 <mbw> stevenxl: Did you try stack exec -- ghc -c Source.hs? From my tab completion I don't see any -c command which could be passed to stack ghc.

01:29 <stevenxl> mbw: I just tried that, and it work. Thank you!

01:32 <kit_> Hey everyone, I'm running into a haskell problem that I can't figure out how to solve. Effectivley I'm trying to spawn a ghci process using createProcess, and then read and write to it but it keeps freezing or closing after about a minute

01:32 <sshine> when I can do [ x | x <- [1..], x < 5 ], is that predicate strictly a list comprehension thing? I can't seem to write 'do { x <- [1..]; x < 5; return x }'

01:32 <kit_> I think maybe the input and output handles are being closed but I have no idea how to avoid that, does anyone have any suggestions?

01:33 <teto> what would be the best way to look for a string into a string plz ?

01:34 <mbw> sshine: I think you need guard from Control.Monad.

01:35 <sshine> teto, did you find http://stackoverflow.com/questions/8748660/is-there-a-better-way-to-write-a-string-contains-x-method ?

01:35 <sshine> mbw, cool, thanks.

01:36 <teto> sshine: I had found others but this one looks better thanks !

01:37 <Welkin> sshine: use filter instead of list comprehensions

01:37 <Welkin> > filter (< 5) [1..10]

01:37 <lambdabot> [1,2,3,4]

01:38 <mbw> teto: I don't think the question is really clear. Do you want to check if it exists? Or find it's position? Or... ?

01:38 <teto> mbw existence is enough so I am good ty

01:40 <Welkin> 5 `isElem` [1..10]

01:40 <Welkin> > 5 `isElem` [1..10]

01:40 <Welkin> o.o

01:40 <lambdabot> error:

01:40 <lambdabot> Variable not in scope: isElem :: Integer -> [Integer] -> t

01:40 <sshine> just `elem`, no?

01:40 <Welkin> > 5 `elem` [1..10]

01:40 <Welkin> yeah

01:41 <lambdabot> True

01:41 <sshine> True dat.

01:41 <* Welkin> shakes fist at Elm

01:41 <Welkin> still recovering

01:42 <sshine> hehe.

01:43 <mbw> I have some expression like fun (Contructor a b c) = do { b' <- m b; return (Constructor a b' c) }. Is it possible to write this in Applicative style?

01:44 <Welkin> ?

01:44 <Welkin> that code doesn't make sense

01:45 <Welkin> @undo { b <- mb; return b }

01:45 <lambdabot> <unknown>.hs: 1: 1:Parse error: {

01:45 <Welkin> @undo do b <- mb; return b

01:45 <lambdabot> mb >>= \ b -> return b

01:46 <Welkin> well, that is literally just fmap

01:46 <mbw> hmm

01:46 <Welkin> you could define fmap for your constructor

01:46 <Welkin> er

01:46 <Welkin> for your mb

01:47 <Welkin> whatever that is

01:47 <mbw> I think I better paste an example.

01:49 <lyxia> looks like a lens

01:50 <Koterpillar> mbw: Constructor a <$> m b <*> pure c

01:53 <Zemyla> What does it say about an Applicative type when a <* b = a and a *> b = b?

01:56 <ReinH> that it's ()?

01:58 <mbw> Koterpillar: That's the correct solution, thank you! Still, I pasted a minimal example of what my problem was about: http://lpaste.net/353369

02:02 <Koterpillar> checkType (T s n m) = T s <$> check n <*> fmap check m

02:02 <mbw> Koterpillar: Doesn't this correspond to checkTypeWrong?

02:02 <mbw> This actually does not do the same thing.

02:03 <Koterpillar> checkTypeWrong - no

02:03 <Koterpillar> checkTypeWrong always has m as a Just something

02:03 <Koterpillar> it is possible to have m = Nothing in my version

02:05 <mbw> I do want it to treat the third argument like in the version using do notation, i.e. with pattern matching. From the program logic, if a Nothing is encountered, the other two values should still be able to "make it through".

02:05 <mbw> If I try your version with Type "" 6 Nothing, it fails, but it shouldn't.

02:06 <mbw> This kind of thing lead to a pretty subtle bug for me.

02:07 <Koterpillar> > let check (x :: Int) = if even x then Just (x `div` 2) else Nothing in let checkType (x, y, z) = (,,) x <$> check y <*> pure (fmap check z) in checkType (1, 2, Nothing)

02:07 <lambdabot> Just (1,1,Nothing)

02:07 <Koterpillar> Back in your terms, checkType (T s n m) = T s <$> check n <*> pure (fmap check m)

02:09 <`Guest03> what does "Segmentation fault/access violation in generated code" mean?

02:09 <mbw> This doesn't typecheck for me, the last term expands to Maybe (Maybe (Maybe Int)).

02:10 <augur> lambdabot: ?faq can haskell make memes?

02:10 <lambdabot> https://wiki.haskell.org/FAQ

02:10 <augur> lambdabot: ?ask can haskell make memes?

02:10 <lambdabot> Consider it noted.

02:10 <augur> :|

02:13 <Koterpillar> mbw: suggest changing check to Either, then the type errors will be obvious

02:13 <Koterpillar> or anything other than Maybe, really

02:14 <`Guest03> oh welllll....

02:14 <`Guest03> shaderSource (from the OpenGL binding) segfaults my program if the source text is empty...

02:16 <mbw> Koterpillar: I'm using Maybe in the context of symbolic manipulations on algebraic expressions, which can become zero under certain circumstances, so it was an alright fit in this case.

02:17 <mbw> I think I will just stick with the version using do notation, for readability.

02:20 <mbw> Anyhow, thanks for your help!

02:24 <echosystm> what sorts of applications is haskell most suited to, given its performance, libraries, etc?

02:24 <markasoftware> echosystm: it's a g8eneral purpose language

02:24 <echosystm> i understand that

02:24 <echosystm> but in the real world, what is it most useful for compared to other languages?

02:25 <markasoftware> depends if you like it or not

02:25 <markasoftware> i'd say it's easier to define what it's not so great at: guis

02:26 <echosystm> ok let me put it another way

02:26 <echosystm> what is haskell most used for?

02:26 <markasoftware> what is python most used for?

02:26 <echosystm> cultivating neckbeards

02:27 <markasoftware> it's not "most used" for any one thing

02:27 <markasoftware> or any group of things

02:27 <echosystm> swift - ios, ruby - web apps, java - enterprise stuff, etc.

02:27 <echosystm> every language has some main purpose that has come about over time

02:27 <markasoftware> that's definitely not correct right there

02:27 <c_wraith> Haskell is easily most used for writing software

02:27 <markasoftware> apart from swift - ios

02:28 <c_wraith> it has some other minor uses.

02:28 <markasoftware> ruby existing long before ruby on rails

02:28 <c_wraith> but it's definitely for building software

02:28 <echosystm> yeah but almost all ruby devs use rails lol

02:28 <ertes> echosystm: haskell is not suitable for targetting small/embedded systems directly

02:28 <pikajude> haskell is good for frightening people

02:28 <markasoftware> well that's what it's turned into after a while

02:28 <markasoftware> but haskell wasn't designed for any one purpose like Javascript was

02:28 <echosystm> neither was ruby, but ruby == rails now

02:28 <markasoftware> or php

02:29 <c_wraith> if you want to get really narrow, Haskell's best niche is software that's maintained.

02:29 <ertes> echosystm: other than that i can't think of anything i wouldn't pick haskell for

02:29 <echosystm> so, as an fp newbie, i just want to know what box i can put haskell into

02:29 <ertes> echosystm: if you ask 10 people, you will get 10 different answers… you should just try it

02:30 <c_wraith> @quote used.for

02:30 <lambdabot> fasta says: Haskell is like an efficient version of Python and is used for the same things.

02:30 <c_wraith> hmm, that's not the one I was looking for

02:30 <ertes> @quote HashMap

02:30 <lambdabot> ertes says: python can be summarised as HashMap String Dynamic

02:30 <markasoftware> echosystm: you can't put C, python, java, or totns of other languages into a "box"

02:30 <markasoftware> haskell either

02:30 <markasoftware> they're very general purpose lanugages

02:30 <markasoftware> php was designed with a purpose -- servers

02:30 <markasoftware> js was for front end web scripting

02:31 <markasoftware> sql for querying databases

02:31 <markasoftware> haskell -- no

02:31 <ertes> echosystm: one thing haskell is particularly strong at is concurrency, especially for networked stuff like servers and clients… it's also strong at processing lots of data (but you need to learn how to do it properly)

02:32 <ertes> it's strong at embedded domain-specific languages, if that means anything to you

02:32 <c_wraith> Haskell is quite successfully used for live-coding music performances

02:34 <c_wraith> Haskell is also excellent for studying the application of mathematical structures to programming.

02:34 <echosystm> i disagree markasoftware

02:34 <c_wraith> but mostly, it's used for writing software.

02:34 <echosystm> i think C, python and java do have fairly clear uses

02:34 <echosystm> but anyway

02:34 <ertes> or live-coding in general… i've used a small lens-based library for live-coding at a crypto workshop several times (often quite literally with a few jaw-drops)

02:34 <markasoftware> what exactly is C's single use case?

02:35 <echosystm> it sounds like systems programming would be a pretty common use for haskell

02:35 <echosystm> probably comparable to the sorts of projects i'm using go for currently

02:35 <markasoftware> or java or python for that matter

02:35 <markasoftware> all three of those have been used for all sorts of major projects that are very different

02:36 <markasoftware> java has been used for mobile apps, desktop games, giant databases (cassandra), servers, etc etc

02:36 <ertes> echosystm: i've observed a lot of haskell programmers trying to bring everything into haskell-land, often rewriting haskell versions of libraries from scratch to do it (myself included)

02:37 <ertes> so it's really difficult to decide what you will be using haskell for, until you have actually learned it to some extent

02:38 <c_wraith> ertes, lens makes a lot of live-coding jaw-dropping. like, lens-aeson makes live json manipulation astounding. and I had a demo of using lenses to examine a full game tree for tic-tac-toe in a live setting.

02:39 <ertes> c_wraith: my use case was stuff like: textFiltered isAlpha . blocks 3 . ix 0 . letter +~ 13

02:39 <ertes> i.e. rotate every third *letter* by 13 places

02:40 <ertes> the jaw-drop effect kicks in as soon as you use traversals =)

02:40 <peddie> c_wraith: is there a screencast of any of these available?

02:40 <ertes> or non-field lenses like textFiltered (lens into a filtered portion of the text)

02:40 <c_wraith> peddie, no. best I can do is find the code that created the game tree and lenses for working with it.

02:41 <peddie> no worries

02:41 <MarcelineVQ> what do you two mean by live coding?

02:41 <Gurkenglas_> Try to do screen recordings the next time, or stream it on a website like livecoding.tv

02:41 <ertes> MarcelineVQ: in my case: sitting in front of an audience with a beamer and hacking stuff into emacs/GHCi

02:42 <c_wraith> MarcelineVQ, setting up some tools and then use them interactively to try things based on the result of previous exploration.

02:42 <c_wraith> MarcelineVQ, usually in a REPL

02:43 <hololeap> when you use record syntax with one argument of a constructor, do you have to use it for all arguments of the constructor?

02:44 <ertes> hololeap: only when using the constructor rather than an existing value in scope

02:44 <MarcelineVQ> ertes, c_wraith: thank you

02:45 <ertes> @let data Person = Person { _numFingers :: Integer, _numTeeth :: Rational } deriving (Eq, Ord, Show)

02:45 <lambdabot> Defined.

02:46 <hololeap> for instance `data Iterator a = a {nextLevel :: Iterator a}` gives me "Record syntax is illegal here", but `data Iterator a = {iterItem :: a, nextLevel :: Iterator a}` is ok

02:46 <Axman6> that doesn't look ok

02:46 <geekosaur> hololeap, yes it's all or nothing and it must have a constructor

02:46 <ertes> @let dentist x = x { _numTeeth = 32 }

02:46 <geekosaur> a is not a constructor

02:46 <lambdabot> Defined.

02:46 <ertes> > dentist (Person 10 17.4)

02:46 <lambdabot> Person {_numFingers = 10, _numTeeth = 32 % 1}

02:47 <hololeap> sorry, i mistyped that: `data Iterator a = Iterator {iterItem :: a, nextLevel :: Iterator a}`

02:47 <geekosaur> and even wth the constructor, you must use either the positional or the record syntax, you can't switch in the middle

02:48 <hololeap> hmm, ok

02:48 <geekosaur> although you can do something like data Foo a = Foo1 a | Foo2 {aa :: a; ab :: Int}

02:48 <geekosaur> (but don't do that, partial record destructors will throw exceptions if used against the wrong constructor)

02:49 <izacht13> Hi, can someone point me in the right direction. I'm looking for a monad lesson that goes over the concept, not the syntax. I'm trying to learn Ur/Web, which also has monads.

02:49 <geekosaur> tht is, if you apply aa or ab to a Foo1 then it will throw

02:49 <geekosaur> @go you could have invented monads

02:49 <lambdabot> Maybe you meant: google googleit do

02:49 <geekosaur> @google you could have invented monads

02:49 <lambdabot> http://blog.sigfpe.com/2006/08/you-could-have-invented-monads-and.html

02:49 <lambdabot> Title: A Neighborhood of Infinity: You Could Have Invented Monads! (And Maybe You Al...

02:49 <ertes> izacht13: if there is no ur/web-related version, you will most likely see haskell syntax anyway

02:50 <izacht13> Mhm, well thanks.

02:50 <izacht13> Ill take a look at it.

02:50 <geekosaur> it'll still have syntax, but it's mostly bout the concept

02:50 <ertes> or at least the haskell-based ones are probably the most trustworthy

02:50 <geekosaur> several examples of evolving the monad "pattern" from various use cases

02:51 <leshow> man lambdabot is pretty sweet, i had no idea you could search google with it

03:02 <ertes> lambdabot has far more impressive feats than that

03:03 <ertes> @djinn ((a -> r) -> r) -> (a -> (b -> r) -> r) -> (b -> r) -> r

03:03 <lambdabot> f a b c = a (\ d -> b d c)

03:06 <faberbrain> can anyone give me some ideas about how to accomplish something along these lines: http://lpaste.net/5129458430632787968

03:07 <faberbrain> specifically, for a given j, queueName should basically be a constant

03:07 <ertes> faberbrain: you need to mention 'j' in the type… a common method is to use a proxy argument

03:08 <ertes> queueName :: proxy j -> ByteString

03:08 <faberbrain> ok yea, i started going down that path

03:08 <faberbrain> but wasn't sure if there was some simpler kind of way to do that

03:08 <pikajude> not much simpler than that

03:09 <ertes> faberbrain: import Data.Proxy, queueName (Proxy :: Proxy MyJobType)

03:09 <faberbrain> guess that is pretty simple

03:09 <ertes> faberbrain: also take a look at the aeson library, which already covers the first two functions

03:10 <ertes> class (FromJSON j, ToJSON j) => Resque j where queueName :: proxy j -> ByteString

03:10 <faberbrain> yea, i'm using aeson and may just add a FromJSON/ToJSON constraint

03:10 <faberbrain> but the particular JSON required by Resque (the ruby queueing library) is so weird that i may want it to e an alternative json represnetation

03:11 <ertes> faberbrain: you can make the JSON look like anything you want

03:12 <faberbrain> yea, i was more thinking along the lines of what if i don't want the Resque-json to be _the_ json representation for the data type.. but thinking on it more thats kinda dumb maybe

03:12 <faberbrain> since thats the only point of that data tyep in the first place

03:12 <ertes> faberbrain: same kind of question: is Integer the (+) or the (*) monoid? answer: use a newtype wrapper to select different semantics

03:13 <ertes> > Sum 5 <> Sum 7

03:13 <lambdabot> Sum {getSum = 12}

03:13 <ertes> > Product 5 <> Product 7

03:13 <lambdabot> Product {getProduct = 35}

03:13 <faberbrain> ok yea, makes sense

03:13 <pikajude> > mempty @(Product Int)

03:13 <lambdabot> error:

03:13 <lambdabot> Pattern syntax in expression context: mempty@(Product Int)

03:13 <lambdabot> Did you mean to enable TypeApplications?

03:13 <pikajude> doh

03:13 <faberbrain> so its more conventional to newtype wrap something then come up w/ some arbitrary new alternative thing (like an alternative to/from json)

03:14 <ertes> faberbrain: yes, because you're not looking for a different abstraction, just different semantics with an existing abstraction

03:15 <ertes> (+) and (*) *are* both monoids

03:15 <ertes> so it would be crazy to make (+) the default and invent a new monoid class to handle (*)

03:16 <ertes> along with all the functions that abstract over Monoid, like foldMap

03:16 <faberbrain> yea, i see.. thats a good way to think about it

03:16 <faberbrain> (probably _the_ way to think about it, i just hadn't reached that myself yet!)

03:17 <faberbrain> thanks!

03:18 <ertes> faberbrain: of course nothing wrong with making a particular semantics the default and selecting different ones via newtype

03:19 <ertes> like: clean JSON as default, insane JSON via newtype

03:19 <faberbrain> yea and in this case there honestly is really only one meaning, there isn't ever a need for a clean JSON rep (yet i guess)

03:20 <faberbrain> so probably makes sense to do the insane json as the default, since its the common use case

03:20 <ertes> insane JSON is quite common… perhaps aeson should provide a wrapper by default

03:20 <athan> is @ just... ::?

03:21 <athan> I don't really see how they differ semantically :s

03:21 <pikajude> kind of, not really

03:21 <pikajude> if you have foo :: a -> b -> c you can use @T to fill in the variables

03:21 <Koterpillar> :t fmap@Maybe

03:21 <pikajude> Proxy :: Proxy Int --> Proxy @Int

03:21 <lambdabot> error:

03:21 <lambdabot> Pattern syntax in expression context: fmap@Maybe

03:21 <lambdabot> Did you mean to enable TypeApplications?

03:21 <pikajude> bit shorter

03:21 <pikajude> lambdabot doesn't have them enabled

03:22 <ertes> athan: if you look at the fully quantified type signature @ will apply type variables as introduced by 'forall'

03:22 <ertes> id :: forall a. a -> a

03:22 <pikajude> it's helpful to turn on ExplicitForall in GHC btw

03:22 <pikajude> or rather GHCi

03:22 <ertes> (id @ Bool) :: Bool -> Bool

03:22 <pikajude> or wait, sorry, i'm completely wrong

03:22 <pikajude> it's -fprint-explicit-foralls

03:22 <ertes> athan: so @ is literally application and therefore not the same as "::", which is more like a judgement

03:23 <ertes> athan: think about it this way: if haskell were dependently typed, "@" would literally be function application

03:26 <AndChat61364> !/

03:33 <athan> ertes, pikajude: Ahh wow okay that makes sense, so @ treats `forall` as a proper lambda?

03:34 <athan> man that makes a lot of sense, thank you

03:34 <athan> :: as a judgement, and how Curry works, that would also make a lot of sense too (ziiiing)

03:45 <whatinthefoo> Hi, I'm reading the happy parser docs and I came across this code: http://lpaste.net/353374

03:45 <whatinthefoo> lexer is defined as accepting one argument... but the pattern matches 2 arguments ??

03:46 <whatinthefoo> When I try similar code in haskell locally I get an error... is this an issue with the happy docs or am I missing something?

03:47 <Koterpillar> whatinthefoo: what's P?

03:47 <whatinthefoo> Koterpillar: P is 'type P a = String -> ParseResult a'

03:47 <geekosaur> that's your answer

03:48 <geekosaur> P a represents a function

03:48 <whatinthefoo> huh?

03:48 <whatinthefoo> okay

03:48 <whatinthefoo> I know that part

03:48 <geekosaur> so cont is a function that produces a function

03:48 <geekosaur> the "result type" P a is also a function

03:48 <whatinthefoo> 'lexer :: (Token -> P a) -> P a; lexer cont s = '

03:48 <geekosaur> so you can apply it, and the "s" parameter is applied to it

03:49 <whatinthefoo> how can you do 'lexer cont s =' though?

03:49 <geekosaur> let's try this: expand the P a in the type of lexer

03:49 <geekosaur> then remember that you can remove parens grouping rightward

03:49 <geekosaur> (Token -> P a) -> (String -> ParseResult a)

03:50 <geekosaur> we can remove the last parentheses

03:50 <geekosaur> (Token -> P a) -> String -> ParseResult a

03:50 <geekosaur> there's your cont and your s

03:50 <whatinthefoo> ohhh

03:50 <geekosaur> it's one of the trickier things to get used to in Haskell

03:51 <whatinthefoo> wow

03:52 <whatinthefoo> that makes sense

03:52 <whatinthefoo> i kept thinking that the P a in (Token -> P a) was being pattern matched somehow

03:54 <geekosaur> :t map

03:54 <lambdabot> (a -> b) -> [a] -> [b]

03:54 <geekosaur> we do the same thing in reverse here, fairly often

03:54 <geekosaur> (a -> b) -> ([a] -> [b])

03:54 <geekosaur> turning a function on a into a function on lists of a

03:55 <xmonader> is there a special meaning to colon in the beginning of line comments in haskell "--:" ?

03:55 <whatinthefoo> thanks geekosaur

03:56 <xmonader> because i get "parse error on input ‘--:’"

03:56 <geekosaur> xmonader, it's not a comment

03:56 <geekosaur> --: is a valid operator name

03:56 <geekosaur> -- is only a comment leader when followed by something that is not a symbol character

03:57 <geekosaur> so --<space> or --a would be a comment but --: is an operator

03:57 <xmonader> uha I see. Thanks a lot geekosaur

03:57 <geekosaur> likewise you'll see --> as an operator in some libraries

03:59 <cc> may i get a haskell cloak ?

04:09 <suica> anyone have a nice way of doing something like, given a string like `"(()())()"`, breaking it into `["(()())", "()"]` by counting matching parens (or any similar operation where you unfold into a list by keeping a running count and breaking off a piece right after the count reaches zero)?

04:09 <suica> could do it with zip, map, fst, snd, etc. but was wondering if anyone had a more concise way

04:17 <ludat> suica, what should happen with corner cases not matching parens?

04:21 <suica> i was going to ignore them

04:22 <suica> i just had a feeling there are some combinators or something I could use instead of doing a bunch of stuff like `break (f . snd) (zip (map nestLevels xs) xs)`

04:23 <suica> i'll try lambdabot

04:27 <lyxia> > let s = "(()())()" in (fmap . fmap) snd $ groupBy (const ((/= 0) . fst)) $ zip (scanl (+) 0 (f s)) s

04:27 <lambdabot> error:

04:27 <lambdabot> • Ambiguous type variable ‘a0’ arising from an operator section

04:27 <lambdabot> prevents the constraint ‘(Eq a0)’ from being solved.

04:28 <lyxia> come on

04:28 <lyxia> Oh I forgot to paste in f.

04:30 <lyxia> > let s = "(()())()" in (fmap . fmap) snd $ groupBy (const ((/= (0 :: Int)) . fst)) $ zip (scanl (+) (0 :: Int) (fmap (\x -> case x of '(' -> 1 ; _ -> -1) s)) s

04:30 <lambdabot> ["(()())","()"]

04:30 <lyxia> that's not simpler than just recursing

04:30 <suica> yeah, fair enough

04:32 <suica> i've just been reading a lot of the "recursion is the goto of functional programming" stuff recently and wanted to try out some fancy things

05:11 <skeuomorf> Is the overloadedstrings language pragma documented anywhere?

05:14 <jle`> skeuomorf: https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#overloaded-string-literals

05:14 <jle`> in the ghc manual

05:14 <markasoftware> skeuomorf: there's some stuff about it in the introduction chapter of the yesod book

05:14 <markasoftware> which was enough for me to (mostly) understand it

05:15 <skeuomorf> jle`: Thanks

05:22 <lolisa> Hi, I am having some problem with my haskell code, I suspect it might be a bug: is it possible that splitting a file in two cause a term to inference different typeclass constraint?

05:23 <ertes> lolisa: one way this can happen is if you forget to turn on the same extensions in both files

05:23 <ertes> another way: different imports, different things in scope

05:24 <ertes> for example, if you import Control.Monad.Trans.State in one and Control.Monad.State in the other

05:26 <lolisa> Hmm, I indeed have different lang extension.

05:27 <lolisa> OMG now it work

05:27 <lolisa> ertes, Thx, bugging me for three hour... Where can I read more on such stuff?

05:28 <ertes> lolisa: the GHC manual explains what each extension does

05:28 <ertes> https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/index.html

05:28 <ertes> they are a bit scattered around, so ctrl+f is your friend

05:29 <ertes> (or / or C-s or …)

05:29 <lolisa> :) happy!

05:31 <Suren> Hello

05:32 <lolisa> hello

05:32 <Suren> What's up lolisa, are you a Haskell developer just having a chat or are you new to the language?

05:37 <lolisa> Suren, I dont know, but shouldnt we like, talk more about haskell stuff instead of individual?

05:38 <peddie> lolisa: there is also a guide to some common GHC extensions at https://ocharles.org.uk/blog/pages/2014-12-01-24-days-of-ghc-extensions.html

05:40 <KiChjang> Suren, i happen to be new at the language

05:40 <KiChjang> i know zilch

05:40 <Suren> I was just asking you that question to see if you are the right person to ask my real question to, which is; as a web developer why would I choose haskell for a project over let's say C# .NET MVC

05:41 <KiChjang> Suren, i think the answer here is you would not

05:41 <Suren> @lolisa

05:41 <lambdabot> Unknown command, try @list

05:41 <KiChjang> haskell isn't the right tool for that job i believe

05:41 <Suren> Why do you say that?

05:41 <lolisa> I'm here. Dont know about web, sorry.

05:41 <KiChjang> if you're using C# .NET MVC, then you're most likely making a web application

05:42 <Suren> yep

05:42 <Suren> lol

05:42 <Koterpillar> My .Net knowledge is rusty, but I would choose Haskell anyway

05:42 <Suren> What applications is haskell good for?

05:42 <KiChjang> literally "rusty" or "rust-y"?

05:42 <Suren> if not web

05:42 <ertes> hackage has more web frameworks than TYPO3 has global variables

05:42 <Koterpillar> because why would I give away referential transparency?

05:42 <ertes> so it's a weird thing to say

05:42 <KiChjang> Suren, i would consider it more of an academic language

05:42 <Koterpillar> Suren: applications where you want correctness

05:43 <pacak> Suren: parsing, ast manipulation

05:43 <KiChjang> there was a blog post before that talks extensively about how a company used haskell in production

05:43 <pacak> We are using it for automated trading.

05:43 <KiChjang> lemme try and fish that up

05:44 <Suren> Pacak: Automated trading has always interested me, how did you get into the field? What was your background before that job?

05:45 <pacak> Suren: Submitted my application. Had relatively basic haskell experience, no finance background.

05:46 <Suren> Pacak: How many years into your software engineering career were you? Did you have a CS or Stem degree? Was it from a top university?

05:46 <KiChjang> Suren, btw, this happened a while ago in #haskell but may also be relevant https://gist.github.com/quchen/5280339

05:47 <Suren> KiChjang: thanks

05:47 <KiChjang> (probably not but eh, good for laughs)

05:47 <pacak> Suren: I've been developing various stuff for quite a while back then. No CS, no fancy university either.

05:49 <Suren> Pacak: Nice man, really glad to hear! I'm a self-taught developer without a degree, about a year into my career now. I always hoped for a career in finance software engineering but didn't think it was possible without a CS degree.

05:52 <buttons840> I am seeing "Type as Type" in an error -- what exention is this?

05:52 <buttons840> extension*

05:53 <jle`> can you give the context?

05:53 <jle`> is Type as Type the error message?

05:54 <buttons840> "Couldn't match expected type Text with actual type HVec as Text" -- something like this

05:55 <jle`> i think 'as' is a type variable there

05:55 <jle`> you are giving a value of type 'HVec bs Text', but the function expects a Text

05:55 <buttons840> jle`: you are right, it's actually "as0"

05:56 <buttons840> so, in spocks renderRoute (https://hackage.haskell.org/package/Spock-0.12.0.0/docs/Web-Spock.html#v:renderRoute) the "as" is a type variable?

05:56 <jle`> yup

05:57 <buttons840> it's not colored like a type variable, guess it's just a css issue?

05:57 <jle`> it's colored as a type variable on my browser

05:58 <jle`> it's just plain black text

05:58 <jle`> looking at the HTML, type variables don't have any specific styles

05:59 <buttons840> ah, your right, it's rendered the same as all other type varibles -- i guess it's just that it was sitting between two links that threw me off

06:16 <lolisa> Hi, so I do cabal install hscolour, but I still cant run the command (or use it from cabal). I am using windows, what should I do?

06:17 <Axman6> you probably need to add the install location to your path, but I have no idea how to do that on windows

06:19 <Axman6> lolisa: this looks like it nas what you need: http://stackoverflow.com/questions/15461085/how-to-configure-cabal-in-windows-7

06:29 <lolisa> Axman6, thx

06:36 <halogenandtoast> If I'm considering making a static website is Hakyll a good way to go?

06:36 <Axman6> it's not a bad way to go, I use it for my website

06:37 <halogenandtoast> https://axman6.com/blog/ ?

06:37 <Axman6> that's the one

06:37 <halogenandtoast> That page isn't selling me :p

06:37 <Axman6> uh, actually without /blog IIRC

06:37 <halogenandtoast> Ah much better

06:37 <Axman6> not even sure how that page is being served...

06:37 <Axman6> it shouldn't even be there :|

06:38 <halogenandtoast> Your github links there

06:38 <halogenandtoast> Which is why I ended up there

06:38 <Axman6> I'll fix that

06:39 <Axman6> all done

06:39 <halogenandtoast> Ha nice, are there any particular tools you suggest?

06:40 <Axman6> for what?

06:40 <Axman6> btw I believe that the code for my site is also on github

06:40 <Axman6> https://github.com/axman6/axman6.com

06:40 <halogenandtoast> Ah sorry I meant things you found useful to use with Hakyll

06:40 <Axman6> the important bits are in site.hs

06:41 <halogenandtoast> Cool thanks, I'll check it out.

06:41 <pikajude> blog posts need a bit more contrast

06:41 <pikajude> i can barely read it

06:41 <Axman6> submit a PR =)

06:42 <lolisa> Hi... the problem is still there, so basically if you move Poly into DBI, it will compile, but right now it wont. Can anyone look at it? I am working on a minimal example.

06:42 <lolisa> https://github.com/ThoughtWorksInc/DeepDarkFantasy/tree/master/src

06:43 <pikajude> oh, no, i don't want to contribute to your blog

06:43 <pikajude> this is just my opinion as a reader

06:44 <halogenandtoast> pikajude: My life rule has always been to never complain about something I won't try to fix myself :p

06:44 <halogenandtoast> Not judging you, just saying

06:44 <pikajude> my life rule has been not to try to interfere with other people's possessions

06:45 <halogenandtoast> Must make it hard to get a house or car loan.

06:45 <pikajude> i have neither

06:45 <halogenandtoast> Story checks out.

07:00 <lolisa> I got the minimal example out. So as you can see, https://github.com/ThoughtWorksInc/DeepDarkFantasy/blob/master/src/PolyT.hs contain a definition that is included in https://github.com/ThoughtWorksInc/DeepDarkFantasy/blob/master/src/DBIT.hs (but under different name), but wont type check

07:00 <lolisa> No library is used, and they have same language extension

07:08 <qmm> 12:30 < c_wraith> Experiments with per-process GC for GHC have shown it to not be especially compatible with laziness.

07:08 <qmm> c_wraith: do you have links, paper titles, email subjects, or any keywords to share whatsoever about this?

07:09 <qmm> i am still interested in this subject

07:09 <c_wraith> there was a paper by at least one of the simons about adding per-HEC heaps

07:09 <c_wraith> I don't recall the name of it

07:14 <qmm> c_wraith: ah okay. i'm aware

07:15 <qmm> it added something like 15% performance increase and according to #ghc it wasn't easy to implement so it was never merged

07:15 <qmm> i read per-HEC has per core heaps

07:15 <qmm> what is HEC? :)

07:16 <qmm> haskell execution context, i see

07:16 <qmm> s/has/as

07:17 <qmm> c_wraith: thank you

07:17 <c_wraith> oh hey. the paper was by both simons. :)

07:18 <qmm> :)

07:18 <qmm> http://community.haskell.org/~simonmar/local-gc.pdf

07:18 <qmm> haskell doesn't sound like it's desirable for distributed programming type projects

07:19 <qmm> <-- noob in distributed computing

07:22 <c_wraith> I don't think it's inherently unsuitable, just that there's a lot of engineering work that hasn't been done

07:23 <qmm> the lightweight scheduler work would be a nice first step

07:26 <Rotaerk> isn't that what cloud haskell is for?

07:27 <qmm> cloud haskell mimics erlang's style concurrency without changing the haskell runtime

07:27 <qmm> erlang style concurrency

07:27 <qmm> it's a library, in other words

07:29 <ongy> Axman6: I've read your blog article about linear typing, do you know how much that would change if ghc got some support for it?

07:31 <qmm> ongy: thanks for mentioning that Axman6 has a blog (and a post about linear types!)

08:03 <ongy> Axman6: I hope you don't mind if I rip off your website a bit, when I decide to blog something at any point. I like the design

10:16 <Athas> Has anyone studied the performance impact of using deepseq?

10:20 <srhb> Athas: What do you mean? Deepseqing what and when?

10:21 <Athas> srhb: deepseq'ing involves traversing an entire object graph, right? I see it frequently used in (task-)parallel Haskell code, to ensure that the computation is actually done in worker threads before the result is passed back to a main thread.

10:22 <Athas> I'm curious whether the traversal in deepseq can have a significant negative performance impact.

10:22 <Athas> Looks to me like it can easily evict the entire cache.

10:29 <merijn> Athas: It can also do a bunch of unnecessary work, so the obvious answer is "yes" ;)

10:30 <Athas> merijn: okay, but has anyone studied it? Things like monad-par seem to be quite happy about implicitly deepseq'ing anything you put in a future, which may have an impact in some cases.

10:31 <Athas> There's been a lot of work on Haskell parallelism and performance, after all.

10:31 <merijn> Honestly, if evicting caching is something you worry about, I don't think Haskell is an ideal language to begin with

10:31 <merijn> laziness is pretty crappy for your caches

10:33 <Athas> Well, you could use laziness for control flow.

10:34 <Athas> I'm mostly asking because I don't know the answer, but lots of smart people have been working on it for years.

10:34 <merijn> Athas: I don't think anyone knows, tbh

10:35 <Athas> "High-performance", "functional", or "programming", pick two?

10:35 <merijn> Athas: There's a guy at Twente working on designing a CPU for lazy languages, so I know he's thought about caches and stuff (mostly, he said he decided not to use caches in the traditional sense), but I'm not sure if he has a write up on that

10:35 <Athas> That sounds cool! Lazy and pure, or impure?

10:35 <merijn> Athas: Purity is rather irrelevant at the chip level

10:36 <Athas> Right, but you could call the total absence of cache coherence "purity".

10:36 <merijn> At the CPU level you're thinking about thunk updating, indirection, etc.

10:39 <Boomerang> merijn: is that CPU for lazy languages being written in CLaSH?

10:40 <merijn> Boomerang: He's in the same group as the CLaSH people

10:40 <Boomerang> Alright! Is it possible to read about this CPU somewhere online?

10:41 <merijn> Boomerang: But since the project I was collaborating on ended a while back I only see them incidentally, so I'm a bit out of date

10:41 <Boomerang> It sounds very interesting, I would love to find out more about it

10:41 <merijn> Boomerang: It doesn't exist yet, even in design, afaik :p Now would only be like the 2nd year of his phd?

10:42 <Boomerang> Fair enough :)

10:48 <merijn> Boomerang: I expect I'll run into them later this month, so I'll ask them about it

11:02 <_sras_> Is there a type class in haskell that can be used to describe conversions between related types?

11:02 <Athas> _sras_: not a standard one, no.

11:06 <Boomerang> _sras_: You could look at how opaleye does it to convert between Haskell type and SQL specific types, the type class used it called Default. I don't understand it fully but it seems to be what you want.

11:06 <_sras_> Boomerang: 'Default Constant' instances describes conversion in one direction...

11:07 <Athas> And be prepared for ambiguity errors...

11:10 <Boomerang> _sras_: Ah yes, I am not aware of a standard way to do this, you could just create your own type class then

11:14 <Boomerang> _sras_: Again I don't really know this package but would the Bijection type class from invertible be useful? It's a bidirectional arrow. It seems appropriate to convert a type from and to another one

11:14 <_sras_> Boomerang: Will look into it. I am not familiar with it either.

11:19 <otulp> Yikes. Just saw the (=<<->>=) operator in Data.Invertible.Monad. Its description: "Crazy operator form of bind." :)

11:30 <cocreature> that definitely qualifies as crazy

11:32 <Boomerang> At least it reuses well known infix symbols, but yeah that's a crazy operator

11:38 <Athas> I wonder what's the largest operator name on Hackage.

11:39 <otulp> Surely there is something hideous somewhere in the Acme hierarchy.

11:45 <monadicDuck> dw

11:47 <Jenaf> good morning!

11:47 <Taneb> Athas, https://gist.github.com/ndmitchell/aa1e0944379a7429cedb#file-gistfile1-txt

11:47 <Jenaf> Yesterday I was told to better replace if then else constructs with case matchings

11:47 <Jenaf> also i have some unreachable code in a fromMaybe wich is guaranteed not to be nothing

11:48 <Jenaf> http://lpaste.net/353382

11:48 <Jenaf> any tipps how to write that more cleanly?

11:49 <Athas> Taneb: thanks; some good ones there!

11:49 <otulp> I see functor-infix is doing quite well, lengthwise.

11:50 <Jenaf> I would love to get rid of this : fromMaybe (error "unreachable")

11:50 <Taneb> Jenaf, is fromJust an option?

11:51 <Taneb> > fromJust (Just "hello")

11:51 <lambdabot> "hello"

11:51 <Jenaf> > fromJust (Nothing)

11:51 <lambdabot> *Exception: Maybe.fromJust: Nothing

11:51 <ongy> Jenaf: if it's not reachable why is the argument of type (Maybe Int) ?

11:51 <ongy> ohh, I see

11:51 <Athas> Jenaf: 'sequence mayList' will give you a 'Maybe [Int]' back.

11:51 <Athas> You can pattern-match on that, instead of the branch.

11:52 <Taneb> > [x | Just x <- [Just 1, Nothing, Just 2, Just 3, Nothing]

11:52 <lambdabot> <hint>:1:58: error:

11:52 <lambdabot> parse error (possibly incorrect indentation or mismatched brackets)

11:52 <Taneb> > [x | Just x <- [Just 1, Nothing, Just 2, Just 3, Nothing]]

11:52 <ongy> that and I think you can use the Monad and MonadFail instances of Maybe here

11:52 <lambdabot> [1,2,3]

11:53 <Jenaf> ahh

11:53 <Athas> > sequence [Just 1, Just 2, Just 3]

11:53 <lambdabot> Just [1,2,3]

11:53 <Athas> > sequence [Just 1, Just 2, Just 3, Nothing]

11:53 <lambdabot> Nothing

11:53 <Jenaf> I stay with maybe because i get the values from a sequence findIndexL

11:54 <ongy> yea, I wasn't properly reading at first, I thought it's Maybe [Int] which was weird, but [Maybe Int] is a bit different

11:54 <Boomerang> > catMaybes [Just 1, Nothing, Just 2]

11:54 <lambdabot> [1,2]

11:54 <Jenaf> in the bigger context Nothing means that my propblem is unsolvable, while values indicated that the program can go on solving

11:55 <Jenaf> so I will propably have a case X of Nothing -> Nothing //of Just something -> foo(something) cascade

11:55 <Jenaf> (unsolvability is NOT an error, it is an expected case)

11:58 <lpaste_> ongy annotated “How to refactor” with “How to refactor (annotation)” at http://lpaste.net/353382#a353383

11:59 <ahri> i'm writing a bomberman clone and i'm thinking about how to best model the exploding of bombs and resulting possible flame, which can in turn destroy powerups and walls. i was going to fmap over my [Bomb] but then i need to remove some of [Wall] and [PowerUp] in some cases, so: Bomb -> [Wall] -> [PowerUp] -> (Bomb, [Wall], [PowerUp], [Flame]) ..... is this sensible? i'm learning Haskell and feel like that

11:59 <ongy> Jenaf: ^ Use the monad instance. It's nice

11:59 <ahri> looks clunky, but have no idea how i might otherwise model it

12:00 <ahri> hm, actually i have to return Maybe Bomb, as it may or may not explode

12:01 <Rodenbach> I have a function, which works nicely to create one random Bar, with the signature: foo :: (PrimMonad m) => Config -> Gen (PrimState m) -> m Bar

12:01 <Rodenbach> I create a rng via rng <- createSystemRandom

12:01 <Jenaf> thats what you get when you forget your luggage at the airport: Maybe Bomb

12:01 <Rodenbach> How can I now create a list [Bar] with 10 random Bars?

12:01 <SexHendrix> Jenaf: lol

12:02 <Jenaf> inb4 Just Nothing

12:02 <SexHendrix> Bomb disposal teams were in JFK this morning after a suspicious package was discovered. The initial fear was Maybe Bomb but it was later confirmed to be Nothing

12:03 <ahri> hehe, although in my case if it's Nothing, it just blew up so is no longer a Bomb ;)

12:05 <SexHendrix> unsafeMaybe

12:05 <SexHendrix> @ghc

12:05 <lambdabot> Try -fglasgow-exts for GHC's newtype-deriving extension

12:07 <ahri> so am i to assume that my suggested solution seems reasonably idiomatic for Haskellers? that's all i'm after really

12:10 <Athas> ahri: I find something to be strange about your representation. What does [Wall] and what does [PowerUp] code?

12:10 <Athas> Is a Wall a coordinate?

12:11 <ahri> yeah, they both have a coordinate. powerup might be various types of powerup (more flame, more bombs, ... maybe other stuff if i get that far)

12:11 <Boomerang> Rodenbach: Is that the random from sfmt? You could do something along the line of: traverse makeBar $ replicateM 10 createSystemRandom

12:12 <Athas> ahri: can there be a powerup and a wall in the same location simultaneously?

12:13 <ahri> Athas: no, when a wall is destroyed it has a random chance to leave a powerup in its place

12:14 <ahri> it concerns me that my current model allows both to exist since they just have coordinates attached

12:14 <Athas> ahri: in your representation, what happens if the [Wall] and [PowerUp] lists have conflicting entries?

12:14 <Athas> Yeah, exactly.

12:14 <Athas> That is a design smell.

12:15 <Athas> Instead, I'd recommend the game board as a 2D-array of Things, where a Thing is then a bomb, a powerup, or a wall.

12:15 <Athas> (Or some other encoding - the point is that it can only encode valid states.)

12:15 <Athas> The only tricky thing is the player, since there can only be one of those, right?

12:16 <Boomerang> Rodenbach: Actually you'll need to use bind with the code I gave you: traverse makeBar =<< replicateM 10 createSystemRandom

12:17 <ahri> Athas: there are a few wrinkles like that: multiple players can be in one place. a player cannot move onto a square with a bomb on it, however when a player drops a bomb it is on the same square as whatever players currently reside on there

12:17 <Boomerang> Where makeBar :: GenIO -> IO Bar

12:17 <Athas> ahri: right, so maybe players should not be part of the game world as such, but stored separately.

12:17 <Athas> But for everything else, the 2D array approach makes more sense.

12:18 <Athas> It's not always about a design that eliminates *all* errors, just as many as practical.

12:18 <ahri> Athas: ok, i guess flame should stay apart too, as it will cover a wall, and then when it's cleaned up i will decide whether or not to leave a powerup in its place

12:19 <Athas> You could have an WallWithFlame cell state.

12:19 <ahri> Athas: and a SpaceWithFlame?

12:20 <ahri> i'd end up needing a PowerupWithFlame, too, actually, as they can be destroyed

12:21 <Athas> ahri: maybe all cells should just have an onFire field.

12:22 <Athas> But generally, don't be afraid of having many constructors. It just means you are being explicit about your states.

12:22 <merijn> Athas: Well, too many might ruin your compile time :p

12:22 <Athas> merijn: using Haskell might ruin your compile time.

12:23 <merijn> Athas: Not as much as C++!

12:23 <Athas> That battle's already lost!

12:23 <Athas> Perhaps! Although 'make' seems to do a better job of parallelisation than GHC does.

12:24 <merijn> Athas: My magic bash alias for superfast compilation: alias make='make -j32' :p

12:33 <ongy> Athas: what? when I compile with ghc (well cabal) I have 100% usage on all cores

12:33 <ongy> I dont' think that much more parallelisation is possible

12:33 <merijn> ongy: How many cores do you have? :p

12:33 <ongy> on this? 4+TH

12:33 <ongy> but I have done it with 24 cores before

12:33 <merijn> ongy: Right, that's pretty easy to saturate

12:34 <ongy> HT not TH

12:34 <Athas> ongy: how much faster is it?

12:34 <ongy> Athas: then what? single core?

12:34 <Athas> Yeah.

12:34 <ongy> never tested, I'd asume roughly 6 to 7 times.

12:35 <ongy> merijn: aren't you working on a cluster? shouldn't that be something like -j8192? :)

12:35 <Athas> My experience is that it doesn't scale very well.

12:35 <merijn> ongy: Jobs don't magically run on more than one machine

12:36 <merijn> And I don't think make can handle multiple machines anyway

12:36 <ongy> if you have single *huge* files, it doesn't. But for many small-ish files it's fine

12:36 <ongy> well, that's what we can use distcc for. But I don't know hoe make -j# and distcc interact

12:37 <SexHendrix> can lambdabot do IO

12:37 <cocreature> SexHendrix: no

12:38 <ongy> > putStrLn "It has a show instance"

12:38 <lambdabot> <IO ()>

12:40 <Reisen> Is there a recommended way of emulating anonymous union / sum types in Haskell?

12:40 <ongy> hm Athas you are right. I was under the impression it parallelises better. But installing lens in a sandbox (with cabal) it's 1-3 cores most of the time. does 'cabal build' do something different?

12:41 <Athas> ongy: yes, building multiple *packages* works quite well.

12:42 <Athas> I think it just launches several GHC processes.

12:42 <Athas> It's compiling a single multi-module package that doesn't scale much.

12:42 <ongy> Athas: cabal build in the lens package multithreads properly

12:43 <ski> @help run

12:43 <lambdabot> run <expr>. You have Haskell, 3 seconds and no IO. Go nuts!

12:43 <ongy> though it doesn't saturate all cores all of time either

12:44 <Athas> I think GHC has some sequential bottlenecks.

12:44 <Athas> Or shared critical regions.

12:44 <Athas> Maybe the FastString stuff.

12:44 <ongy> which is probably more of a problem with the dependencie graph of the modules in it. For my own, which has very few inter-dependencies it's all cores all the time

12:46 <Athas> It doesn't matter how much you can utilise your cores. That's just heat. Only the wall-clock time matters.

12:46 <Athas> You can get great utilisation by spinning on a lock.

12:46 <ongy> it's an indicator, provided things don't spin on locks

12:47 <Athas> Or the cores trash each others caches.

12:53 <Jenaf> Yay my Code works as intended so far ^.^

12:58 <michalrus> Hey, is there traverseM in Haskell? Like in https://git.io/vywEQ i.e. traverse+join.

12:59 <michalrus> Or rather https://git.io/vywuJ

13:01 <teto> how to disambuguate instances: I have "The type variable ‘a0’ is ambiguous" ; full error here http://paste.ubuntu.com/24151500/

13:02 <reactormonk> !hoogle (Monad f, Applicative g) => f a -> (a -> g f b) -> g f b

13:03 <reactormonk> michalrus, http://hayoo.fh-wedel.de/?query=%28Monad+f%2C+Applicative+g%29+%3D%3E+f+a+-%3E+%28a+-%3E+g+f+b%29+-%3E+g+f+b

13:04 <michalrus> So it’s useful in Scala but not in Haskell? (:

13:04 <reactormonk> Implement it, can't be too hard.

13:06 <ongy> :t traverse

13:06 <lambdabot> (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b)

13:06 <lally> Hi, I've got a lens question

13:07 <ongy> :t join . traverse

13:07 <lambdabot> Traversable t => (a -> t a -> b) -> t a -> t b

13:09 <lally> I've got a list of a sum type, and want to get the last one that has a value for a given lens

13:09 <lally> Is there something smaller than last $ catMaybes $ map (preview myLens) list ?

13:09 <Gurkenglas_> lastOf (traverse . myLens)

13:10 <lally> Nice! Thanks

13:11 <Gurkenglas_> Though it's more of a traversal than a lens if it only matches sometimes

13:13 <Gurkenglas> Hmm maybe lambdabot should get a module that defines undefinedLens :: Lens s t a b, undefinedTraversal :: Traversal s t a b, undefinedLens' :: Lens' s a, and so on, just so :t demonstrations don't explode into high-end typeclassery

13:14 <ski> @let undefinedLens :: Lens s t a b; undefinedLens = undefined; undefinedTraversal :: Traversal s t a b, undefinedLens' :: Lens' s a

13:14 <lambdabot> Parse failed: Parse error: ,

13:15 <ski> @let undefinedLens :: Lens s t a b; undefinedLens = undefined; undefinedTraversal :: Traversal s t a b; undefinedTraversal = undefined; undefinedLens' :: Lens' s a; undefinedLens' = undefined

13:15 <lambdabot> .L.hs:167:1: error:

13:15 <lambdabot> Duplicate type signatures for ‘undefinedLens’

13:15 <lambdabot> at .L.hs:158:1-13

13:15 <ski> well

13:16 <Gurkenglas> Ya but that's gonna disappear after every @undefine. Though I guess I can query those to lambdabot when I need them...

13:16 <Cale> :t undefinedLens

13:16 <lambdabot> error: Variable not in scope: undefinedLens

13:16 <ongy> :t undefinedLens

13:16 <lambdabot> error: Variable not in scope: undefinedLens

13:16 <Cale> What would the purpose of those be?

13:16 <Gurkenglas> case in point, just did @undefine right after he said that in query to test whether they're actually in L.hs

13:18 <Gurkenglas> :t lastOf (traverse . undefinedTraversal) -- So you can say this instead of:

13:18 <lambdabot> Traversable t => t s -> Maybe b

13:18 <Gurkenglas> :t lastOf (traverse . ?f)

13:18 <lambdabot> (?f::(a -> Const (Rightmost a) a) -> a1 -> Const (Rightmost a) a1, Traversable t) => t a1 -> Maybe a

13:19 <Cale> Then again, I'm not sure "Traversable t => t s -> Maybe b" is much more comprehensible

13:19 <Cale> (though I suppose it's perhaps fine if you know the type variables used in undefinedTraversal)

13:20 <Gurkenglas> Yeah, not sure why I expected something to produce a reference to the connection between s and a there

13:22 <Gurkenglas> What's a good way to say this, for example something that produces (?f::Traversal s t a b, Traversable t1) => t1 s -> Maybe b

13:24 <drdo> I want to print data similarly to the derived Show instances but with full indentation (in a sexp-like fashion). Is there something for this?

13:25 <Cale> drdo: perhaps http://hackage.haskell.org/package/groom

13:26 <Cale> http://hackage.haskell.org/package/groom-0.1.2/docs/src/Text-Groom.html#groom -- as you can see here, it's a really simple application of haskell-src-exts

13:26 <Cale> So you could also just use haskell-src-exts directly

13:26 <lally> Is there a better way to learn lenses than th FPComplete tutorial + a lot of mucking around in ghci?

13:27 <drdo> Cale: I guess I could try it, but from the very first example on the page, it doesn't look like it's what I want

13:28 <Cale> lally: Perhaps start with some lens library which isn't 'lens'. The main lens library is great, but it's got a lot of stuff that is simply irrelevant when you're trying to learn the most important bits.

13:28 <drdo> Maybe there's a prettyPrint with this option

13:28 <drdo> I guess I'll check haskell-src-exts

13:29 <lally> n.m. just saw the FAQ off the lens package. I'll hunt through there first.

13:30 <bennofs> drdo: try pretty-show

13:30 <bennofs> @hackage pretty-show

13:30 <lambdabot> http://hackage.haskell.org/package/pretty-show

13:31 <Cale> hmm, I was thinking of lens-family, but it seems to have become oddly abstracted as well now too.

13:33 <Cale> lally: I guess the real answer is "be around back when lenses were being invented for the first time and everything was much simpler" ;)

13:34 <bennofs> Cale: lens-family-core?

13:34 <Cale> Well, even that has the weird FoldLike shenanigans in it

13:35 <Cale> Is there anything which *just* does van Laarhoven lenses, without abstracting over various sorts of getters and setters and traversals and whatnot?

13:37 <bennofs> Cale: microlens doesn't look too bad

13:38 <Cale> It still does the ASetter / Getting stuff, but yeah, it's closer to what I'd want in order to teach someone about lenses the first time.

13:39 <Cale> I'd also kill off the infix operator shenanigans, but that's just personal preference ;)

13:40 <drdo> Ah, screw it, I'll just roll my own printer

13:40 <drdo> These things want to do fancy choices and all I want is simple consistent indentation

13:48 <cris_> hi , i write a small module to supplement postgresql-simple , it is to let larger size tuple to use with postgresql-simple, https://github.com/szehk/Haskell-Carbonara-Library/blob/master/src/Database/Carbonara/PostgreSQL.hs

13:49 <cris_> i myself need to upload to postgres database with tuple size large than 40 , so i need to write it myself , do you think this will be useful to other haskeller as well?

13:50 <hexagoxel> drdo: so you want something like the last example in the readme of http://hackage.haskell.org/package/GenericPretty

13:50 <teto> anyone could help me disambiguate " The type variable ‘a0’ is ambiguous" in https://github.com/teto/vim-config/blob/master/test.hs (just runhaskell test.hs), it's my first haskell program and I don't think setting the returned value might disambugate thing (please ^^)

13:50 <merijn> teto: What's the full error?

13:51 <teto> merijn: full error here http://paste.ubuntu.com/24151500/

13:52 <teto> (btw I tried cabal update to get cassava 0.4.5, but it stays with 0.4.4)

13:52 <merijn> teto: You never use part of the result, so GHC can't infer what type you're wanting

13:53 <teto> merijn: I see thanks got it

14:04 <niko> .14

14:17 <matchwood> Hi all, I've tried asking this haskell-stack but nobody seems around so thought I'd give it a go here...

14:17 <matchwood> The question is basically about configuring stack for ghcjs

14:17 <matchwood> http://stackoverflow.com/questions/42720347/how-to-configure-stack-for-most-recent-ghcjs-lts-build

14:18 <matchwood> Any thoughts greatly appreciated!

14:22 <shiona> Does anyone know of a haskell-diagrams (or similar) web repl? I'm sure I've used something like that in the past, but now I cannot find such a thing.

14:30 <Jenaf> anything wrong with those two lines?

14:30 <Jenaf> http://lpaste.net/353390

14:30 <Jenaf> (except my fetish for parans)

14:39 <Cale> Jenaf: Well, I would add an import Data.Sequence (Seq) to the top of the file so as to avoid needing to write Seq.Seq

14:39 <Cale> also you *really* don't need parens around single tokens

14:39 <Jenaf> um, I did import Data.Sequence as Seq

14:39 <Cale> (Bool) is always going to be the same thing as writing Bool

14:39 <Jenaf> I was beeing scared of namespace collisions

14:39 <Cale> You should do:

14:39 <Cale> import qualified Data.Sequence as Seq

14:39 <Cale> import Data.Sequence (Seq)

14:39 <Cale> like that

14:40 <Jenaf> also I found another error

14:40 <Cale> The import qualified will make sure you need to use an explicit "Seq." qualifier to refer to things from that module, and then the second import removes that restriction for the type itself.

14:41 <Jenaf> yeah

14:41 <Cale> Another thing you can do is to remove the lambda and pull that argument over to the other side of the = sign

14:41 <Cale> filterHelper numList bools = toList ...

14:42 <Jenaf> yeah

14:43 <Jenaf> but I think I have my main reduction step for sudoku solving done. ^.^

14:43 <Jenaf> 140 lines of haskell feel a bit much thou

14:43 <Cale> I'm also not certain that it's actually better to be using Seq.zip rather than doing the toLists sooner

14:43 <Cale> but that's pretty minor

14:44 <Jenaf> yeah thats really quite minor ^.

14:53 <kuribas> You may get better fusion with lists.

14:53 <kuribas> Does that typecheck?

14:55 <kuribas> wouldn't it return [(Int, Bool)]?

15:01 <Denommus> hello

15:02 <kuribas> Jenaf: confirmed by ghci

15:02 <kuribas> hi

15:03 <Denommus> do you guys use any package for gherkin specifications?

15:04 <Denommus> it's essential to us to make specifications in a human-readable language

15:04 <Jenaf> kuribase: yeah that was the error i was talking about earlier

15:08 <unclechu> hey guys, i'm trying to get coverage info from Stack, i'm trying to build my app by command `stack build --coverage` but getting this error at the end: `No tix files found in /--myapppath--/.stack-work/install/x86_64-linux/lts-6.30/7.10.3/hpc/, so not generating a unified coverage report.`

15:08 <unclechu> what should i do?

15:32 <nitrix> unclechu: I think you're supposed to compile with -fhpc to get .tix files.

15:33 <unclechu> nitrix: how should i do it?

15:33 <nitrix> I think you compile your executable with -fhpc, then run the executable, the runtime should generate a .tix file, which you can then generate reports from.

15:35 <unclechu> nitrix: how i can compile my executable with `-fhpc` flag?

15:35 <unclechu> `stack build --help` doesn't show any available fhpc flag

15:36 <nitrix> The ghc-options section of your cabal file is possibly the easiest way.

15:37 <nitrix> stack build --ghc-options=-fhpc ?

15:38 <nitrix> Does stack lets you do that?

15:43 <unclechu> nitrix: thanks, now it's working, but coverage value is defenetely not right

15:43 <unclechu> or i misunderstand something

15:44 <unclechu> here it is: http://pastebin.com/H49Lyyg2 but my tests cover very small percent of the `library`

15:46 <unclechu> i'm looking at report right now and it shows only modules i imported in tests

15:47 <unclechu> maybe it's correct, but i prefer to show there everything from `exposed-modules`

15:52 <Jinixt> a design question: a Game has Players which have Cards; a Card can have wildly different effects, so right now it has a function with the type "State Game" to perform these effects. it feels like i'm giving too much 'power' to the cards since they can do anything they want with the Game. is there a better idiomatic way?

15:53 <Jinixt> i've toyed with the idea of a simple DSL for describing the effects, but i'm looking for other alternatives as well

15:54 <lyxia> I was about to suggest enumerating the effects in an ADT but that's basically what you just said.

15:55 <merijn> Jinixt: Difficult trade-off

15:57 <Jinixt> agreed

15:58 <Jinixt> it feels like it would be nice to be able to enumerate what sort of "permissions" a Card is asking for, if you will

15:58 <Jinixt> "why is this card asking for delete permissions?"

15:58 <teto> is it possible to embed an if/else (or case) in a lambda ?

15:59 <cocreature> teto: sure, just use it like anywhere else

16:00 <merijn> Jinixt: The "State Game" approach gives you maximum flexibility, but it's harder to restrict things

16:00 <Boomerang> teto: for example (\x -> case x of Just a -> True; Nothing -> False), you can even use the LambdaCase extension to make it shorter to write

16:00 <merijn> Jinixt: Enumerating it eliminates that, but becomes more verbose/hassle-like if you wanna add new behaviour

16:01 <Jinixt> i can imagine there's only a relatively limited set of things you'd want to do anyways

16:01 <teto> thanks

16:02 <Jinixt> the only thing missing is that if you have branching you can't see -all- possible effects easily, but perhaps that's a pipe dream

16:02 <Jinixt> or would require manually stating that first, which is also a hassle

16:06 <padre_angolano> I want to start learning Yesod. The homepage http://www.yesodweb.com/ makes reference to the first edition of the O'Reilly book (2012), whereas the 2-nd edition (2015) is already available. Is there a specific reason why the yesod site recommends the outdated edition?

16:07 <padre_angolano> Or maybe the yesod website itself was not updated since 2012?..

16:07 <Clint> padre_angolano: probably nobody noticed the discrepancy

16:08 <Reisen> So, if I had Either (Either A B) C, and I want to serialize the value contained with aeson (Just the value, not the Right/Left's of the Either), I can write a simple pattern match and do that easily

16:08 <padre_angolano> Clint: hmm...

16:08 <Reisen> But if I want to do the reverse, and I have an aeson serialized A, B, or C, and I want to write something that looks like: decode :: Text -> Either (A B) C

16:09 <Reisen> I feel like I'm stumped on how I'd know how many Left/Right's would be needed to construct the right result, or how to traverse the type

16:09 <Reisen> Can someone point me in the right direction on what I should read about, or if this is impossible?

16:10 <smaug_> Is Haskell impractical to learn?

16:10 <ongy> Reisen: unless you have some information in there about whether it's an A, B or C you can't (how would you decide what it is?)

16:11 <ongy> smaug_: it's different, so when you are coming from oop/imperative languages it may be a bit harder at first

16:11 <Taneb> smaug_, there's not as many resources to learn from as as a more popular language like Python, say

16:11 <Reisen> ongy, I don't mind tagging the resulting encoded value with the type that it is

16:11 <ongy> if you are coming from maths or using it as first language, it may even be easier

16:11 <Taneb> smaug_, but I think once you get the hang of it it ends up quite easy

16:12 <smaug_> Is Haskell best for AI?

16:12 <Boomerang> Reisen: In that case I believe Aeson already provides you with instances for FromJSON and ToJSON fro Either a b

16:12 <merijn> padre_angolano: I would suspect they forgot to update the site

16:12 <ongy> Reisen: then you know what it is by from the type. if it's A it's (Left (Left val)) and so forth

16:12 <Taneb> smaug_, I don't know of much people writing AI code in Haskell

16:12 <Boomerang> And it "tags" the data with "Left" and "Right"

16:12 <Reisen> Boomerang that's the thing though, I don't want to encode the Either part, I.E, I want to store something that looks like

16:12 <Reisen> Just "{"type": "C", "C { ... }"}

16:13 <Reisen> And then at runtime, figure out the right amount of Left's/Right's needed

16:13 <Reisen> When pulling it out

16:13 <Reisen> Without having to hand write the instances, if that makes sense

16:13 <Reisen> Essentially I'm trying to write a ghetto emulation of anonymous sum types

16:14 <smaug_> Why should I learn Haskell? Give me some good reasons.

16:14 <Boomerang> Reisen: You would probably be better of having a sum type: data MyData = MyA A | MyB B | MyC C, or do you need it to be Either?

16:14 <Reisen> Boomerang, I need it to be either because, there are some 15 types that I have stored, and I want to be able to do something that looks roughly akin to:

16:14 <Reisen> type (:|) a b = Either a b

16:14 <Reisen> And right functions that can work on any pairing, I.E

16:15 <Reisen> x :: (A :| B :| Z :| G) -> ()

16:15 <Taneb> smaug_, because it is a productive language that can change how you think about and program in other languages for the better

16:15 <Reisen> y :: (A |: R |: N) -> ()

16:15 <Jinixt> sounds like a list, Reisen

16:15 <ongy> smaug_: because you want to broaden your horizon. Also that question reaks of troll

16:15 <Reisen> It is like a list, except that I don't want a product I want a sum

16:15 <Reisen> I think, THINK this is the UnboxedSum extension that might get merged at some point

16:16 <dunx> smaug_: https://www.cs.utexas.edu/users/EWD/OtherDocs/To%20the%20Budget%20Council%20concerning%20Haskell.pdf

16:16 <Reisen> Where I'd be able to write, x :: (A | B | C) -> () and use case x of ( A ||); (| B |) and so on

16:16 <Reisen> but It's not implemented yet

16:16 <smaug_> ongy, I don't an answer from people like you. Go away.

16:16 <ski> Reisen : unboxed or anonymous/light-weight ?

16:16 <ongy> you accidently all the :)

16:17 <Reisen> ski, I'm not really looking for unboxed it just happens the (||X) syntax is part of the UnboxedSums extension from what I can tell

16:17 <Reisen> anonymous sum types is what I'm after

16:17 <* ski> nods

16:17 <Reisen> but they don't exist so I'm trying to get as close as possible

16:17 <ski> (OCaml has them, e.g.)

16:19 <ski> i'd perhaps call them "positional sum types", since the alternatives are determined by position (as for tuples), rather than by name (as for records, and for "ordinary" sum types with data constructors)

16:19 <Reisen> That is exactly what I'm after more or less

16:20 <Reisen> I'm thinking that maybe I could traverse an Either type with some sort of type level function in order to determine that position

16:20 <ski> (OCaml's "polymorphic variants" have alternatives determined by name. but you dont' have to declare the types beforehand, you can just use them, as with e.g. tuples)

16:21 <smaug_> Fucktional programming has ugly syntax

16:21 <dunx> go away then

16:21 <ski> it has different syntax

16:21 <dunx> i like the syntax

16:21 <dunx> mathematival

16:21 <ongy> Reisen: I think this may be a job for template-haskell.

16:21 <* ski> doesn't think there's any reason to be unfriendly

16:22 <Reisen> ongy, I think you may be right

16:22 <* dunx> concurs

16:22 <ski> (heh. that applies to both of you :)

16:22 <ongy> but then you need one instance for each version (arity?) of the sum you use. So probably not that practical either

16:22 <Taneb> smaug_, there are many different functional programming languages, and many different syntaxes!

16:23 <Reisen> I'm sure there's a way to write a type level traversal, something like monad-classes liftN

16:23 <Reisen> I'll give it some thought

16:23 <Tuplanolla> Syntices?

16:23 <dunx> ski: i didn't mean to be unfriendly :(

16:23 <ski> if you like brackets, you might try Scheme

16:23 <Taneb> Haskell looks very different to Lisp looks very different to Erlang looks very different to Scala

16:23 <Reisen> I was kind of hoping maybe the concept had been done before and I'd get a "you want X-package Reisen" style answer

16:23 <Reisen> but It's cool, it'll be fun to play with this idea

16:23 <ski> dunx : regardless, "go away" could easily be construed as such

16:23 <cocreature> is there any way to get the exact logbase2 of a Word64 using base < 4.8 (and no other packages)?

16:24 <MarcelineVQ> Reisen: if you were wanting to try unboxed sums you could build ghc head which has them

16:24 <Reisen> Yeah, I just don't want my project relying on GHC head

16:24 <Reisen> I want to stay on a stackage LTS release

16:24 <ongy> cocreature: exact logbase2? How would you store that?

16:25 <MarcelineVQ> You can use head with stack if that's your only sticking point :>

16:25 <cocreature> ongy: I don’t understand that question :)

16:26 <MarcelineVQ> anyway it was just to try it, if you're waiting for something more official 8.2 will have them

16:26 <Tuplanolla> Rounded up or down, cocreature?

16:26 <cocreature> ongy: 4.8 allows me to use countLeadingZeroes but that doesn’t exist

16:26 <cocreature> Tuplanolla: rounding down

16:26 <ongy> cocreature: is log_2 guaranteed to be representagle in finite memory?

16:26 <cocreature> ah sorry yeah exact was a bad term

16:26 <cocreature> I wanted to say integer and for some reason I said exact

16:27 <Taneb> Tuplanolla, syntaxes or syntaxies I think

16:27 <ski> smaug_ : most languages other than functional programming ones are weak on expressing sum types and pattern-matching. for that reason alone, i'd suggest learning a functional programming language (such as Haskell,Erlang,OCaml,SML,F#, e.g.)

16:27 <cocreature> by exact I was referring to the fact that I’d like to avoid floating point errors as caused by log x / log 2

16:28 <ski> smaug_ : note that one of the core concepts in object-orientation is "record/struct types", aka "product types". product types are "dual" (complementary) to sum types. in practice, you should know about both of them

16:28 <ongy> cocreature: how would countLeadingZeroes help you? do you know it's just a single bit?

16:29 <cocreature> ongy: logBase2 x = finiteBitSize x - 1 - countLeadingZeros x

16:29 <ongy> oh because we are rounding, right

16:29 <cocreature> yep

16:30 <ongy> copypaste the code of countLeadingZeroes?

16:30 <cocreature> it’s a primitive :)

16:30 <ski> smaug_ : another thing that functional programming is heavy on is treating functions as "just another kind of value", passing functions as arguments, computing them at run-time, returning them, storing them in data structures. passing functions as input and output yields higher-order functions, which are good to reduce more complicated patterns of boiler-plate code than ordinary (first-order) functions can reduce

16:30 <cocreature> but yeah I might just write a shitty implementation myself

16:31 <ongy> binary search for it :)

16:31 <cocreature> I was hoping something like that might already exist somewhere in base and I’m just unable to find it

16:31 <cocreature> ongy: I feel kind of bad for doing a binary search when my cpu can do this in a single instruction :)

16:31 <smaug_> ski, most languages are multiparadigm

16:32 <ski> smaug_ : most functional languages discourage "side-effects", if not completely disallowing them. you might have an easier time getting started with one which allows them, but then you might not as easily learn alternative modes of expression. it's a trade-off

16:32 <Taneb> smaug_, multiparadigm rarely means "good at all of them"

16:32 <ongy> cocreature: inline-c inline-assemble it? :P

16:32 <cocreature> ongy: heh :)

16:32 <ski> smaug_ : most languages have assignment and mutation all over the place (in standard libraries, e.g.) .. which is hardly conducive to doing functional programming

16:32 <ongy> also the single instruction may not be as good as it sounds. Way better than doing it yourself though

16:33 <smaug_> ski, what is the best language paradigm?

16:33 <Cale> smaug_: Another reason to learn Haskell is to find out what it's like to actually have a useful type system that helps you make large refactors to your codebase far more easily, and catches the vast majority of stupid bugs for you.

16:33 <Taneb> smaug_, that is not a question with an answer

16:34 <ski> smaug_ : i'd also like to mention "logic programming" (e.g. Prolog), which is based on expressing computation using *relations*, rather than functions. relatively often, it happens that one can run these relations both "forwards and backwards", getting "two (or more) for one", with a single implementation

16:34 <viuo> Hi everybody! Im trying to write a sort of expression evaluator. I have State Monad with an expression and an "environment" (the map + some other stuff). Unfortunately the algorithm I am implementing, treats the map as a global so if you set a var inside an expression it should be accessible from the outer ones too. The question is - do you know of any way I could propagate the state up the ladder so I can

16:34 <viuo> read a variable from the surrounding expression too ?

16:34 <ski> smaug_ : imho, it's best to learn about all the major paradigms, and try to learn which one is the best tool for any given job

16:34 <ski> (which is why i was mentioning logic programming as well)

16:36 <ski> smaug_ : the point is to broaden your horizons, which will improve your programming skills also in Java or Python or whatever ..

16:36 <shapr> I see a lot of illogic programming at my day job.

16:36 <ongy> haha thank you ski

16:36 <* ski> idly wonders which language(s) would be the best exponent(s) for the paradigm of illogical programming ..

16:36 <shapr> smaug_: want to see some cool code I wrote to get subway times for the nearby stops in Atlanta?

16:37 <Cale> On the other hand, once you know Haskell well enough, programming in Java or Python will be an absolutely terrible experience and you will hate it.

16:37 <djfo> viuo: you may want to try using the State monad

16:37 <smaug_> shapr, sure.

16:37 <djfo> viuo: do you have an example expression?

16:37 <ski> ongy ?

16:37 <Cale> (but you will be better at it than before)

16:37 <ongy> ski: for going full circle. I started with your last statement

16:37 <shapr> smaug_: right now the output in my tmux status bar: ["M:Arriving,4","N:3,10"] and the source is: https://github.com/shapr/tmuxmarta/blob/master/src/Lib.hs

16:38 <ski> ah :)

16:38 <shapr> smaug_: have you written Python before? Are you familiar with list comprehensions?

16:38 <ongy> shapr: you really love that piece of code

16:38 <smaug_> shapr, not much

16:38 <viuo> djfo: I am using a state monad but i cannot update the variable on the upper expression

16:39 <* ski> idly wonders whether someone should ask smaug_ about what language(s) they're comfortable with, so far

16:39 <shapr> ongy: it's a single file self contained example that does something useful, do you have others you'd suggest?

16:39 <Cale> shapr: wow, fancy list comprehension :)

16:39 <shapr> Cale: yeah! TransformListComp code by napping :-)

16:39 <viuo> djfo: let me think how to visualize it

16:39 <smaug_> ski, I am from low-level world ;)

16:39 <ongy> I didn't say that it's bad, or that I have something better

16:39 <shapr> smaug_: oh, you want embedded Haskell then?

16:40 <ongy> smaug_: so ada/assembly, or closer to C?

16:40 <shapr> ongy: I'd much prefer to have a long list of "working program in one file" examples.

16:41 <Denommus> so, it seems there isn't a usable gherkin parser in Haskell, right?

16:41 <smaug_> Cortex M

16:41 <smaug_> Assembly

16:41 <ski> shapr : `let station = event ^. station' ?

16:41 <Denommus> I wonder how difficult it would be to create one with megaparsec

16:41 <shapr> Denommus: https://github.com/sakari/haskell-gherkin ?

16:41 <ski> smaug_ : that's nice :)

16:41 <shapr> smaug_: oh yeah, fun stuff. I got the risc-v arduino recently, it's really cool

16:42 <Cale> smaug_: Back around 2004 or so, I had the experience of writing a pipeline scheduler for PPC/Altivec in Haskell for a research project. We used it to optimise some vectorised code for computing sine/cosine pairs so that it operated at about 2.6 clocks/float (by extremely unfair comparison, GNU libm's cosine takes a couple hundred clock cycles)

16:42 <viuo> djfo: http://pastebin.com/DmcJPgMe here's my code

16:42 <Cale> Haskell can make a really good metalanguage for low-level work

16:42 <shapr> ski: yeah, that lens grabs the station field from this event

16:43 <ski> i meant, why not use `let' there ?

16:43 <viuo> djfo: it's a little messy, I just started with haskell, excuse if it hurts the eyes ;) could use a review

16:43 <Cale> Basically, my thing did a simulation of the units on a particular PPC/Altivec CPU and rearranged the instructions such that as many different functional units in the processor could be operating simultaneously.

16:43 <Taneb> ski, well, you couldn't use the name "station"

16:44 <Cale> (Modern processors are really non-obvious to optimise assembly code for by hand)

16:44 <viuo> djfo: in general, when evaluating MuExpr, the i want to be able to set a variable and then re-use it in the next iteration of fixpoint

16:44 <shapr> smaug_: if you decide you want to learn Haskell, I'm a big fan of haskellbook.com

16:45 <shapr> smaug_: although if you want free learning materials, byorgey's course is really nice

16:45 <ski> viuo : instead of `e <- get' and then later `symbols e', you could use `old <- gets symbols' and then later `old' ..

16:45 <shapr> @where cis194

16:45 <lambdabot> http://www.seas.upenn.edu/~cis194/spring13/

16:46 <ski> viuo : oh, yeah, `getSymbols = gets symbols'

16:47 <viuo> ski: yeah it's a bit messy

16:47 <ski> viuo : i'd suggest looking into `modify', possibly defining `modifySymbols' and `modifyBinding', using it

16:48 <smaug_> shapr, yes the book sounds good.

16:48 <ski> viuo : in `assign', the last `return ()' is redundant, since the type of `setSymbols new' is already `Evaluator ()'. the return value of that will just be propagated

16:48 <viuo> ski: oh right, will fix

16:49 <cocreature> ongy: ah the class providing countLeadingZeros has a default implementation so I can be lazy after all and just copy it :)

16:50 <ongy> cocreature: are you doing this for compat reasons, or because you need 4.8?

16:50 <cocreature> ongy: I’m doing this because hackerrank doesn’t have base 4.8 :)

16:50 <viuo> ski: I am not sure I understand what modify does

16:50 <ongy> oh hakerrank

16:51 <ongy> that probably doesn't do FFI

16:51 <cocreature> yeah

16:51 <ski> viuo : `modify' takes a function, call it `f', gets the state, applies the function to it, and puts the result back

16:52 <Profpatsch> Does anyone know how I pattern match on structures using Data.Fix?

16:52 <Profpatsch> e.g. I have an NExpr from https://hackage.haskell.org/package/hnix-0.3.4/docs/Nix-Expr.html#t:NExpr

16:53 <Profpatsch> It’s parsed in from a string.

16:53 <Profpatsch> Now I want to transform it in a certain way.

16:53 <ski> viuo : `modifySymbols f = modify (\(Environment ks old b el) -> Environment ks (f sym) b el)', e.g., could be used in `assign'

16:53 <Taneb> Profpatsch, you can match on Fix (NConstant c) for example

16:53 <viuo> ski: oh right I get it now

16:53 <dunx> users

16:54 <Profpatsch> Taneb: Interestingly, this is the Show instance of Fix: https://hackage.haskell.org/package/data-fix-0.0.3/docs/src/Data-Fix.html#line-68

16:54 <Profpatsch> So the printed value skips all the Fixes

16:54 <Profpatsch> I wonder if there is no nice pattern matching for that?

16:54 <ski> Profpatsch : bad instance ..

16:55 <ski> (doesn't even define `showsPrec')

16:55 <Taneb> Profpatsch, the Show instance doesn't affect the pattern matching one iota

16:55 <viuo> ski: I am concerned mostly about the evaluate. So for instance if I have a AndExpr where I have expressions A and B , I want all the assigns from A and B get propagated so in AndExpr I can read those assigns

16:55 <ertes> in what way is GHC's Any type different from, say, Void?

16:56 <Profpatsch> Taneb: Yes, of course.

16:56 <ski> viuo : should work with a state monad, iiuc

16:56 <viuo> ski: damn can't express myself properly... basically I want the SymTab in the State to be shared between all the expression

16:56 <ski> what does "shared between all the expression" mean ?

16:57 <viuo> so far what I get is I can read assigns going downwards but I want it to work both ways

16:57 <Profpatsch> Taneb: I should be able to use one of cata ana hylo for that, but I’m not entirely sure, how.

16:57 <nitrix> viuo: You'll have access to the state as long as your computations happen within the stateful monadic context.

16:57 <viuo> ski: in the original algorithm - SymTab is a global variable

16:57 <Taneb> Profpatsch, it can be hard to get an intuition for those, I've found

16:57 <Taneb> I'd just use explicit recursion

16:58 <ertes> ah, nevermind

16:58 <ski> viuo : yes, go on ..

16:58 <viuo> ski: that is when you evaluate an expression where a child expression sets a variable to 1. This variable should return 1 in the parent expression too

16:58 <Profpatsch> Taneb: Probably.

16:58 <Profpatsch> I’m sure there is a nice way to do structure conversion.

16:58 <ski> viuo : yes, that should happen automatically, if you set up the evaluator right, using a state monad

16:59 <Profpatsch> Having all these Fixes everywhere is kind of suboptimal.

16:59 <ski> (which, at a quick glance, it looks like you're doing. perhaps i'm missing some detail ?)

16:59 <Profpatsch> Maybe with ViewPatterns

17:00 <ski> Profpatsch : `foo (Fix x) = case x of NConstant atom -> ...; ...' ?

17:00 <ski> (or with a helper function, if you prefer)

17:00 <ski> (`cata' or whatever could also be useful, yes)

17:01 <eacameron> What's the best way to provide lenses for my datatypes to downstream users (it's a library) without bringing in all of lens dependency?

17:01 <viuo> ski: unfortunately what I get is the state only get passed down

17:01 <Profpatsch> If I want to match deeper into the structure, it will be (Fix (Constr (Fix Constr2 (Fix …

17:02 <Gurkenglas> eacameron, https://github.com/ekmett/lens/wiki/How-can-I-write-lenses-without-depending-on-lens%3F

17:02 <viuo> what I would like to do is something in a sense of. I do new <- eval and later on i set the current state to what was calculated in "new"

17:03 <eacameron> Gurkenglas: Hah, wow. Just for me? ;)

17:04 <viuo> ski: I googled a module called Tardis which looks like something that would be relevant here

17:04 <Profpatsch> convertToNewstyle (Fix (NWith _ (Fix (NWith _ a)))) = a

17:04 <ski> Profpatsch, yes

17:04 <Profpatsch> Has to be nice somehow. :(

17:04 <ski> pattern synonyms could be helpful

17:05 <Profpatsch> Complaining on a very high level. :P

17:09 <ski> viuo : `MuExpr' and `NuExpr' always has `FixedPointExpr fp' in first component ?

17:09 <viuo> ski: yes, correct

17:09 <viuo> ski: FixedPoint is a variable that I set in SymTab

17:11 <ski> why not just have `MuExpr fp f' instead of `MuExpr (FixedPointExpr fp) f', and similarly for `NuExpr' ?

17:11 <Profpatsch> johnw: You wrote hnix, have you find

17:11 <* ski> figures this is some kind of modal logic thing ..

17:11 <Profpatsch> *found a nice way to match on Fix Structures?

17:11 <Profpatsch> convertToNewstyle (Fix (NWith _ (Fix (NWith _ a)))) = a

17:11 <Profpatsch> That’s a bit verbose.

17:12 <viuo> ski: yeah Im trying to implement EmersonLei Model Checking

17:12 <Profpatsch> As in many Fix Constructors.

17:12 <* ski> 's never heard of "Emerson-Lei" befoer

17:12 <viuo> FixedExpr comes from the parser

17:12 <viuo> you can have a freestanding FixedExpr too

17:12 <ski> can you fix the AST ?

17:12 <ski> yes, but that seems to me to be a different thing

17:13 <ski> aiui, `MuExpr' and `NuExpr' represents binders in the object language

17:13 <ski> as such, it would make sense to not (typewise) allow any expression in the first component, but only an identifier

17:14 <viuo> that's correct

17:14 <viuo> should never come to this though