IRCBrowse

2023/11/20

2023-11-20 00:02:49 +0100ham(~ham@user/ham)
2023-11-20 00:04:15 +0100hamhamster
2023-11-20 00:06:02 +0100jumper149(~jumper149@base.felixspringer.xyz) (Quit: WeeChat 4.1.1)
2023-11-20 00:06:19 +0100jumper149(~jumper149@base.felixspringer.xyz)
2023-11-20 00:07:57 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:a57c:6e2:236b:24e3)
2023-11-20 00:09:13 +0100axeman(~quassel@ip5b40ac1e.dynamic.kabel-deutschland.de) (Ping timeout: 256 seconds)
2023-11-20 00:21:20 +0100neptun(neptun@2607:5300:60:5910:dcad:beff:feef:5bc) (bye)
2023-11-20 00:27:44 +0100haskellbridge(~haskellbr@069-135-003-034.biz.spectrum.com) (Ping timeout: 268 seconds)
2023-11-20 00:33:15 +0100SmirnoffBG(~Guest86@2a01:5a8:302:def2:8c8e:534:2c31:3b30)
2023-11-20 00:34:41 +0100m257(~maaz@184.147.203.180)
2023-11-20 00:34:58 +0100 <m257> Why div?
2023-11-20 00:35:12 +0100 <ski> `div' is for integral division, division with a remainder
2023-11-20 00:35:23 +0100chomwitt(~chomwitt@ppp-94-67-189-25.home.otenet.gr) (Ping timeout: 252 seconds)
2023-11-20 00:35:24 +0100 <m257> does it return the remainder?
2023-11-20 00:35:33 +0100 <ski> `/' is for (more or less) exact division, so floating-point (not quite exact), and rationals (exact)
2023-11-20 00:35:40 +0100 <ski> `mod' does
2023-11-20 00:35:46 +0100 <ski> > 17 `divMod` 7
2023-11-20 00:35:47 +0100 <lambdabot> (2,3)
2023-11-20 00:35:49 +0100 <m257> I thought it would return the result of the division.
2023-11-20 00:35:49 +0100 <ski> > 17 `div` 7
2023-11-20 00:35:51 +0100 <lambdabot> 2
2023-11-20 00:35:52 +0100 <ski> > 17 `mod` 7
2023-11-20 00:35:54 +0100 <lambdabot> 3
2023-11-20 00:35:55 +0100 <m257> 4 mod 2
2023-11-20 00:36:01 +0100 <ski> use "> "
2023-11-20 00:36:04 +0100 <m257> mod 4 2
2023-11-20 00:36:13 +0100 <m257> > mod 4 2
2023-11-20 00:36:14 +0100 <lambdabot> 0
2023-11-20 00:36:26 +0100 <m257> > div 4 2
2023-11-20 00:36:27 +0100 <lambdabot> 2
2023-11-20 00:36:33 +0100 <ski> > div 11 2
2023-11-20 00:36:34 +0100 <lambdabot> 5
2023-11-20 00:37:01 +0100 <ski> n = n `div` d * d + n `mod` d
2023-11-20 00:37:06 +0100 <m257> I need to check if the number is even.
2023-11-20 00:37:13 +0100 <ski> > map even [0 ..]
2023-11-20 00:37:15 +0100 <lambdabot> [True,False,True,False,True,False,True,False,True,False,True,False,True,Fals...
2023-11-20 00:37:20 +0100 <EvanR> @src even
2023-11-20 00:37:20 +0100 <lambdabot> even n = n `rem` 2 == 0
2023-11-20 00:37:22 +0100 <m257> Really?
2023-11-20 00:37:30 +0100 <m257> You map it to the set?
2023-11-20 00:37:34 +0100 <ski> the list
2023-11-20 00:37:35 +0100 <m257> That is so weird.
2023-11-20 00:37:37 +0100 <EvanR> :t even
2023-11-20 00:37:38 +0100 <lambdabot> Integral a => a -> Bool
2023-11-20 00:37:41 +0100 <ski> (infinite list, here)
2023-11-20 00:38:00 +0100 <ski> > filter even [0 ..]
2023-11-20 00:38:02 +0100 <lambdabot> [0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,52...
2023-11-20 00:38:07 +0100 <m257> so map even x?
2023-11-20 00:38:14 +0100 <ski> only if `x' is a list
2023-11-20 00:38:18 +0100 <EvanR> check if a number is even, use the function even
2023-11-20 00:38:28 +0100 <m257> Oh even is just a function.
2023-11-20 00:38:33 +0100 <ski> i was just showing `even' for a bunch of different numbers at the same time
2023-11-20 00:38:34 +0100 <ski> yes
2023-11-20 00:38:37 +0100 <m257> Can I see its definition?
2023-11-20 00:38:40 +0100 <ski> see above
2023-11-20 00:38:54 +0100 <m257> Its seems weird that their would be a function for something so simple.
2023-11-20 00:39:23 +0100 <EvanR> it's good that haskell has some many dumb things defined, and that everyone uses them
2023-11-20 00:39:31 +0100 <m257> How would I check for arbitary mod in idiomatic haskell.
2023-11-20 00:39:40 +0100 <m257> like x % n
2023-11-20 00:39:45 +0100 <EvanR> x `mod` n
2023-11-20 00:39:48 +0100 <ski> (`rem' is the same as `mod', except it behaves slightly differently, with negative numbers. `rem' is probably (very) slightly more efficient. but if your numerator might be negative, you probably want `mod' instead. similarly, if the numerator may be negative, you usually want `div' rather than `quot')
2023-11-20 00:40:37 +0100 <m257> Ambiguous type variable ‘a0’ arising from the literal ‘4’
2023-11-20 00:40:39 +0100 <ski> (with `div' and `mod', the sign of the denominator controls the sign of the result. with `quot' and `rem', it's the sign of the numerator which controls)
2023-11-20 00:40:45 +0100 <m257> main = print (collatz 4)
2023-11-20 00:40:55 +0100 <ski> (most processors, for some weird reason, seem to go the `quot' and `rem' route ..)
2023-11-20 00:40:58 +0100 <m257> Why is this wrong?
2023-11-20 00:41:00 +0100 <EvanR> not enough type info to know what number type 4 is
2023-11-20 00:41:10 +0100 <EvanR> try print (collatz (4 :: Int))
2023-11-20 00:41:20 +0100 <ski> collatz :: Int -> Int -- adding this should work
2023-11-20 00:41:23 +0100 <EvanR> or put a type signature on collatz
2023-11-20 00:41:30 +0100 <ski> (or `Integer')
2023-11-20 00:41:40 +0100 <m257> No instance for (Fractional Int) arising from a use of ‘collatz’
2023-11-20 00:41:50 +0100 <m257> How do I define input type?
2023-11-20 00:41:53 +0100 <ski> don't use `/'
2023-11-20 00:41:56 +0100 <EvanR> sounds like you tried to use /
2023-11-20 00:42:00 +0100 <ski> (yes)
2023-11-20 00:42:06 +0100 <m257> collatz x = if even x then x/2 else 3*x+1
2023-11-20 00:42:14 +0100 <ski> add, above that line :
2023-11-20 00:42:16 +0100 <ski> collatz :: Int -> Int -- adding this should work
2023-11-20 00:42:37 +0100 <ski> (and replace the / with `div` ..)
2023-11-20 00:43:02 +0100 <m257> It works!
2023-11-20 00:43:04 +0100 <m257> Thanks
2023-11-20 00:43:12 +0100 <ski> np :)
2023-11-20 00:43:15 +0100 <EvanR> slash does this
2023-11-20 00:43:20 +0100 <EvanR> > 7 / 2
2023-11-20 00:43:21 +0100 <m257> This is a bit of a culture shock.
2023-11-20 00:43:21 +0100 <lambdabot> 3.5
2023-11-20 00:43:26 +0100 <EvanR> > 7 `div` 2
2023-11-20 00:43:28 +0100 <m257> For floats?
2023-11-20 00:43:28 +0100 <lambdabot> 3
2023-11-20 00:43:36 +0100 <ski> > 7 / 2 :: Rational
2023-11-20 00:43:38 +0100 <lambdabot> 7 % 2
2023-11-20 00:43:45 +0100 <ski> > 14 / 4 :: Rational
2023-11-20 00:43:46 +0100 <lambdabot> 7 % 2
2023-11-20 00:43:55 +0100 <ski> > 1 % 2 + 1 & 3
2023-11-20 00:43:56 +0100 <ski> er
2023-11-20 00:43:56 +0100 <lambdabot> error:
2023-11-20 00:43:56 +0100 <lambdabot> • Could not deduce (Integral a0)
2023-11-20 00:43:56 +0100 <lambdabot> from the context: (Integral a, Num (Ratio a -> b))
2023-11-20 00:43:59 +0100 <ski> > 1 % 2 + 1 % 3
2023-11-20 00:44:00 +0100 <lambdabot> 5 % 6
2023-11-20 00:44:00 +0100 <EvanR> slash is for Fractional numbers, div is for Integral numbers
2023-11-20 00:44:11 +0100 <ski> @botsmack
2023-11-20 00:44:11 +0100 <lambdabot> :)
2023-11-20 00:44:13 +0100 <m257> so / is float division and div is integer division. Why make such a distinction? Why not figure out types from input?
2023-11-20 00:44:27 +0100 <EvanR> other languages have the same distinction, though spelled different ways
2023-11-20 00:44:55 +0100 <EvanR> you call them both "division" but it's really not the same operation
2023-11-20 00:45:05 +0100 <m257> I am going to just call div like a function rather use backticks
2023-11-20 00:45:13 +0100 <ski> > pi `divMod'` 2
2023-11-20 00:45:14 +0100 <lambdabot> (1,1.1415926535897931)
2023-11-20 00:45:15 +0100 <m257> What is the idiomatic way?
2023-11-20 00:45:16 +0100 <ski> > pi `divMod'` 0.5
2023-11-20 00:45:17 +0100 <lambdabot> (6,0.14159265358979312)
2023-11-20 00:45:32 +0100 <ski> m257 : either prefix or infix, whichever you prefer
2023-11-20 00:45:57 +0100 <m257> Now how do I loop till it hits one? and print out the numbers in between?
2023-11-20 00:45:58 +0100 <EvanR> > let (÷) = div in 7 ÷ 2
2023-11-20 00:45:59 +0100 <lambdabot> 3
2023-11-20 00:46:18 +0100 <ski> m257 : you can generate a list of the numbers
2023-11-20 00:46:27 +0100 <m257> Return a list?
2023-11-20 00:46:35 +0100 <ski> yes
2023-11-20 00:46:38 +0100 <ski> so, e.g.
2023-11-20 00:46:47 +0100 <ski> collatz 5
2023-11-20 00:46:54 +0100 <ski> = [5,16,8,4,2,1]
2023-11-20 00:46:55 +0100 <m257> There is probably some mad optimizations behind the scenes to get this to work.
2023-11-20 00:47:06 +0100 <m257> How do I create and combines list?
2023-11-20 00:47:16 +0100 <ski> > 2 : [3,5,7]
2023-11-20 00:47:18 +0100 <lambdabot> [2,3,5,7]
2023-11-20 00:47:22 +0100 <m257> Alright.
2023-11-20 00:47:24 +0100 <ski> > [2,3] ++ [5,7]
2023-11-20 00:47:26 +0100 <lambdabot> [2,3,5,7]
2023-11-20 00:47:27 +0100haskellbridge(~haskellbr@069-135-003-034.biz.spectrum.com)
2023-11-20 00:47:27 +0100ChanServ+v haskellbridge
2023-11-20 00:47:47 +0100skiwelcomes haskellbridge back
2023-11-20 00:48:04 +0100 <m257> Do I change the type signature of collatz to Int List?
2023-11-20 00:48:12 +0100 <ski> collatz :: Int -> [Int]
2023-11-20 00:49:01 +0100 <ski> collatz 1 = [1]
2023-11-20 00:49:07 +0100 <ski> collatz n
2023-11-20 00:49:35 +0100 <ski> | even n = ...
2023-11-20 00:49:40 +0100 <ski> | otherwise = ...
2023-11-20 00:49:57 +0100 <ski> that's another way to split cases, depending on even or not
2023-11-20 00:50:01 +0100 <ski> @src otherwise
2023-11-20 00:50:02 +0100 <lambdabot> otherwise = True
2023-11-20 00:51:47 +0100 <m257> Anything wrong with this: collatz x = if (x == 1)
2023-11-20 00:51:47 +0100 <m257> []
2023-11-20 00:51:47 +0100 <m257> if even x then
2023-11-20 00:51:47 +0100 <m257> (div x 2) : (collatz (div x 2))
2023-11-20 00:51:47 +0100 <m257> else
2023-11-20 00:51:50 +0100 <m257> 3*x+1 : (collatz (3*x+1))
2023-11-20 00:51:52 +0100 <m257> Woops.
2023-11-20 00:52:03 +0100 <m257> Probably should pastebin next time.
2023-11-20 00:52:10 +0100 <m257> tabs turns into Is
2023-11-20 00:52:43 +0100 <m257> https://pastebin.com/X2fuQicV
2023-11-20 00:52:49 +0100 <m257> Thats a bit better.
2023-11-20 00:53:56 +0100 <ski> no need for the brackets around `x == 1', nor around `div x 2', nor around `collatz (div x 2)'
2023-11-20 00:54:10 +0100 <ski> (nor `collatz (3*x+1)')
2023-11-20 00:54:29 +0100 <m257> I was thinking of lisp...
2023-11-20 00:54:36 +0100 <m257> It looks weird without it.
2023-11-20 00:54:51 +0100 <m257> Haskell seemed very lisp like in syntax.
2023-11-20 00:54:53 +0100 <ski> missing `then' and `else' for first `if'
2023-11-20 00:54:54 +0100 <EvanR> this is not lisp
2023-11-20 00:55:06 +0100 <EvanR> (((x))) is the same thing as x
2023-11-20 00:55:07 +0100Jackneill(~Jackneill@20014C4E1E1AA2000F2D4B0C673AE70E.dsl.pool.telekom.hu) (Ping timeout: 276 seconds)
2023-11-20 00:55:12 +0100 <ski> (all `if's have both `then' and `else')
2023-11-20 00:55:26 +0100 <m257> Forgot about the else case.
2023-11-20 00:55:43 +0100 <Axman6> m257: regardless of what happens to the tabs, please do not paste code into IRC
2023-11-20 00:55:53 +0100 <m257> Can I not use tabs in Haskell?
2023-11-20 00:55:59 +0100 <m257> It gives errors.
2023-11-20 00:56:00 +0100 <ski> m257 : but see the `collatz' sketch i gave seven minutes ago, above
2023-11-20 00:56:49 +0100 <EvanR> you can use tabs but the indentation of else makes it parse wrong
2023-11-20 00:56:51 +0100 <m257> Axman6: It looked shorter in neovim. Sorry.
2023-11-20 00:56:56 +0100 <EvanR> it has to be indented more than if
2023-11-20 00:57:20 +0100 <geekosaur> that's the problem with tabs: every program has its own interpretation of them
2023-11-20 00:57:26 +0100 <Axman6> You can use tabs in Haskell, but you shouldn't. They're defined to be 8 character tab stops, which is not what most people expect (and because of this it's generally considered a bad idea)
2023-11-20 00:57:40 +0100 <m257> This is what I have currently: https://pastebin.com/e3wvFgFX
2023-11-20 00:58:01 +0100 <m257> I have my neovim config to only tabs. Might have to change tabs to spaces.
2023-11-20 00:58:19 +0100 <ski> m257 : `ghci -Wno-tabs' to shut the tab warning up
2023-11-20 00:58:49 +0100 <monochrom> Or, tell your editor to use spaces :)
2023-11-20 00:58:53 +0100 <Axman6> but just use spaces
2023-11-20 00:59:02 +0100 <m257> yes i need to change that.
2023-11-20 00:59:14 +0100 <m257> The parse error for else is because of tabs right?
2023-11-20 00:59:16 +0100 <ski> m257 : "I mix tabs and spaces" by dmwit at <http://dmwit.com/tabs/> ; <http://ooxx.me/wp-content/uploads/2013/10/TabsSpacesBoth.png>
2023-11-20 00:59:29 +0100 <monochrom> I understand why tabs are better for other languages. That reason breaks with Haskell (and Python).
2023-11-20 00:59:41 +0100 <monochrom> (generally any layout-sensitive language)
2023-11-20 00:59:51 +0100 <Axman6> ski: just the URLs made me angry
2023-11-20 00:59:57 +0100skigrins
2023-11-20 01:00:05 +0100 <m257> I usually use tabs for indentations and spaces for alignment.
2023-11-20 01:00:22 +0100 <m257> That way people can configure their indentation while also rendering properly on all editors.
2023-11-20 01:00:23 +0100 <zzz> if i'm using Relude how do lookup a Map?
2023-11-20 01:00:31 +0100 <monochrom> Exactly. Haskell and Python have no indentation, only alignment.
2023-11-20 01:00:37 +0100SmirnoffBG(~Guest86@2a01:5a8:302:def2:8c8e:534:2c31:3b30) (Quit: Client closed)
2023-11-20 01:00:42 +0100 <zzz> do i have to `import Data.Map.Strict ( lookup )` ?
2023-11-20 01:00:56 +0100 <EvanR> m257, that will work, but you still have to follow layout rules with either tabs or spaces
2023-11-20 01:01:18 +0100 <ski> m257 : still missing a `then' in last paste
2023-11-20 01:01:18 +0100 <EvanR> haskell is indentation sensitive
2023-11-20 01:01:40 +0100 <Axman6> m257: that doesn't really make sense though, because tabs have configurable widths in most editors, and Haskell assumes that width is 8
2023-11-20 01:01:57 +0100 <EvanR> it should still work regardless of your tab settings
2023-11-20 01:01:58 +0100 <zzz> Axman6: haskell assumes what now?
2023-11-20 01:02:06 +0100 <EvanR> assuming you only use tabs
2023-11-20 01:02:11 +0100 <m257> Why does indentation matter in haskell? Most langauges ignore whitespace.
2023-11-20 01:02:29 +0100 <m257> It worked now by the way.
2023-11-20 01:02:29 +0100 <EvanR> no language ignores whitespace
2023-11-20 01:02:37 +0100 <EvanR> whitespace is used to separate tokens
2023-11-20 01:02:40 +0100 <Axman6> I;d say python is a pretty popular language, and it has similar rules
2023-11-20 01:03:12 +0100 <EvanR> e.g. f x is different from fx in any language that allows multi-letter variables
2023-11-20 01:03:13 +0100 <zzz> m257: a poor choice has been made. it's supposed to held readability by vertical aligning stuff
2023-11-20 01:03:21 +0100 <ski> Axman6 : it's fine if you always break line after layout-introducing keywords followed by a multi-line block, and then indent only with tabs. or, if you make sure that your mixing of tabs and spaces is consistent, the leading whitespace of one line is a prefix of that on an adjacent line
2023-11-20 01:03:58 +0100sawilagar(~sawilagar@user/sawilagar) (Ping timeout: 255 seconds)
2023-11-20 01:04:06 +0100 <Axman6> I feel that leads to really ugly code though
2023-11-20 01:04:15 +0100 <m257> How can I pass input to haskell programs from the commandline?
2023-11-20 01:04:17 +0100 <Axman6> spaces are unambiguous
2023-11-20 01:04:24 +0100 <m257> How do I access argv?
2023-11-20 01:04:28 +0100 <Axman6> @hoogle getArgs
2023-11-20 01:04:28 +0100 <lambdabot> System.Environment getArgs :: IO [String]
2023-11-20 01:04:28 +0100 <lambdabot> System.Environment.Blank getArgs :: IO [String]
2023-11-20 01:04:28 +0100 <lambdabot> System.Directory.Internal.Prelude getArgs :: IO [String]
2023-11-20 01:04:44 +0100 <ski> m257 : you can always use explicit `{',`;',`}' instead of layout, in Haskell. most people don't, for the most part, though. sometimes you'll see e.g. `x = 1; y = 2', fitting multiple declarations in the same line. and longer snippets passed to lambdabot also often use `;' and curly brackets
2023-11-20 01:04:55 +0100 <EvanR> the amount of tabs a space is worth is ambiguous, better to use tabs xD
2023-11-20 01:04:57 +0100 <ski> main = do
2023-11-20 01:05:02 +0100 <ski> args <- getArgs
2023-11-20 01:05:04 +0100 <Axman6> But if you need anything more structured, optparse-applicative is the general recommendation for command line option parsing
2023-11-20 01:05:10 +0100 <zzz> anyways, i'm trying out relude and i'm not sure what i'm supposed to do if i want to use functions from containers
2023-11-20 01:05:16 +0100 <ski> n <- readIO (head args)
2023-11-20 01:05:16 +0100 <Axman6> c-c-c-combo breaker
2023-11-20 01:05:38 +0100 <ski> EvanR : or to mix consistently
2023-11-20 01:05:49 +0100 <m257> So to get the first argument args <- getArgs; args[1]?
2023-11-20 01:05:50 +0100 <ski> (as in dmwit's article)
2023-11-20 01:05:53 +0100 <ski> no
2023-11-20 01:05:58 +0100 <Axman6> no
2023-11-20 01:06:00 +0100 <ski> arg:rest <- getArgs
2023-11-20 01:06:04 +0100 <Axman6> that's not how lists work
2023-11-20 01:06:18 +0100 <m257> I am completely new here so no clue.
2023-11-20 01:06:24 +0100 <ski> no worry, it's fine
2023-11-20 01:06:25 +0100 <Axman6> m257: you should probably start with a haskell tutorial if you're being tripped up by such basics
2023-11-20 01:06:44 +0100skipointed to LYAH, CIS194, and a few books, earlier
2023-11-20 01:06:56 +0100 <Axman6> Not sure what the corrent recommended place to start is - yeah probably those
2023-11-20 01:07:08 +0100 <ski> @where LYAH
2023-11-20 01:07:08 +0100 <lambdabot> http://www.learnyouahaskell.com/
2023-11-20 01:07:12 +0100 <ski> @where CIS194
2023-11-20 01:07:12 +0100 <lambdabot> <https://github.com/byorgey/haskell-course>,<https://www.seas.upenn.edu/~cis194/spring13/lectures.html>
2023-11-20 01:07:20 +0100 <m257> I am on that website right now.
2023-11-20 01:07:21 +0100 <ski> @where PiH
2023-11-20 01:07:22 +0100 <lambdabot> "Programming in Haskell" by Graham Hutton in 2007-01-15,2016-09-01 at <http://www.cs.nott.ac.uk/~pszgmh/pih.html>
2023-11-20 01:08:00 +0100 <Axman6> m257: Haskell is very different to most languages, both in its syntax, and how you program in it, so you should't expect to just be able to just start writing random things that look like other languages and have them work (this is a very common mistake, "I know language X, so I'm sure I can pick up Haskell easily")
2023-11-20 01:08:14 +0100 <ski> @where HPFFP
2023-11-20 01:08:14 +0100 <lambdabot> "Haskell Programming: from first principles - Pure functional programming without fear or frustration" by Chistopher Allen (bitemyapp),Julie Moronuki at <http://haskellbook.com/>,#haskell-beginners
2023-11-20 01:08:15 +0100 <EvanR> a gentle introduction to haskell, version 98 xD
2023-11-20 01:08:19 +0100 <ski> hah !
2023-11-20 01:08:23 +0100 <EvanR> would explain how to index a list
2023-11-20 01:08:31 +0100Tuplanolla(~Tuplanoll@91-159-68-236.elisa-laajakaista.fi) (Quit: Leaving.)
2023-11-20 01:08:46 +0100 <m257> So args !! [1]?
2023-11-20 01:08:52 +0100 <ski> args !! 0
2023-11-20 01:08:53 +0100 <ski> would work
2023-11-20 01:08:55 +0100 <EvanR> :t args !! [1]
2023-11-20 01:08:56 +0100 <lambdabot> error:
2023-11-20 01:08:56 +0100 <lambdabot> • Variable not in scope: args :: [a]
2023-11-20 01:08:56 +0100 <lambdabot> • Perhaps you meant data constructor ‘Args’ (imported from Lambdabot.Plugin.Haskell.Eval.Trusted)
2023-11-20 01:08:59 +0100 <Axman6> :t (!!)
2023-11-20 01:09:00 +0100 <lambdabot> [a] -> Int -> a
2023-11-20 01:09:02 +0100 <ski> (it doesn't include program name)
2023-11-20 01:09:14 +0100 <ski> but better is to use pattern-matching, probably
2023-11-20 01:09:18 +0100 <EvanR> m257, to do trial and error, you can write :t <code> in ghci
2023-11-20 01:09:18 +0100 <m257> In the tutorial "Steve Buscemi" !! 6 it says this probably should have realized I could apply it to args
2023-11-20 01:09:28 +0100 <EvanR> if it doesn't type check, it can't be right
2023-11-20 01:09:53 +0100 <ski> @hoogle getProgName
2023-11-20 01:09:55 +0100 <lambdabot> System.Environment getProgName :: IO String
2023-11-20 01:09:57 +0100 <lambdabot> System.Environment.Blank getProgName :: IO String
2023-11-20 01:09:59 +0100 <lambdabot> System.Environment.Compat getProgName :: IO String
2023-11-20 01:10:00 +0100pavonia(~user@user/siracusa)
2023-11-20 01:10:08 +0100 <Axman6> (!!) can be used on any kind of list, and strings in Haskell are just lists of characters (type String = [Char])
2023-11-20 01:10:28 +0100 <ski> % System.Environment.getProgName
2023-11-20 01:10:28 +0100 <yahb2> "<interactive>"
2023-11-20 01:10:30 +0100 <ski> % System.Environment.getArgs
2023-11-20 01:10:30 +0100 <yahb2> []
2023-11-20 01:10:34 +0100 <m257> Is program name just args !! 0 or is that the first arg?
2023-11-20 01:10:44 +0100 <ski> the latter
2023-11-20 01:11:01 +0100 <m257> Axman6: Yes I would I assume strings would char arrays.
2023-11-20 01:11:11 +0100 <probie> Lists are not arrays
2023-11-20 01:11:20 +0100 <Axman6> you should generally forget that arrays exist
2023-11-20 01:11:22 +0100 <ski> there are arrays, too (both mutable and immutable). but `String' is a list of `Char'acters
2023-11-20 01:11:23 +0100 <m257> Is there a distinction between arrays and list in haskell?
2023-11-20 01:11:29 +0100 <ski> yes
2023-11-20 01:11:30 +0100 <Axman6> yes
2023-11-20 01:11:37 +0100 <Axman6> they are very different
2023-11-20 01:11:44 +0100 <Axman6> @src []
2023-11-20 01:11:44 +0100 <lambdabot> data [] a = [] | a : [a]
2023-11-20 01:11:44 +0100 <ski> lists are single-linked lists
2023-11-20 01:12:03 +0100 <m257> I am use to char* str = "Blah" in C so I have never really though strings being linked list in other languages.
2023-11-20 01:12:08 +0100 <ski> like `struct int_list { int n; struct int_list *rest; }' in C .. very roughly
2023-11-20 01:12:14 +0100 <jackdk> m257: for historical reasons, `String` is a linked-list of `Char`. For teaching purposes this is kinda-fine-I-guess, but for anything nontrivial that works with text, use type `Text` from module `Data.Text`
2023-11-20 01:12:25 +0100 <m257> I would think they would just be dynamic logarithmic realloc arrays.
2023-11-20 01:12:34 +0100 <zzz> also note that lists are functional data structures while arrays are not
2023-11-20 01:12:48 +0100 <Axman6> arrays--
2023-11-20 01:12:49 +0100 <m257> Is the implementation of the strings different than the actual strings?
2023-11-20 01:12:55 +0100 <jackdk> But also you can not worry about it for now — just throw out many of your intuitions about data structures
2023-11-20 01:13:01 +0100 <Axman6> down with arrays and their O(n) nearly everything
2023-11-20 01:13:26 +0100 <probie> m257: the problem with an immutable array (and Haskell likes immutable data structures) is that "updating" a single element involves copying the entire array
2023-11-20 01:13:35 +0100 <Axman6> No, String in Haskell is literally a list of Char - but this is often far less expensive than it sounds
2023-11-20 01:13:44 +0100 <ski> m257 : lists are commonly more used as "control structures" ("generators"), to iterate. you can use them to store elements, too. but it's generally not that good an idea to use `length' or `!!', unless the list is short (so it doesn't matter). lists are good for sequential access, not random access
2023-11-20 01:13:59 +0100 <m257> To be honest assembly is simpler than this. Why do people use Haskell over other languages?
2023-11-20 01:14:01 +0100juri__(~juri@79.140.115.182)
2023-11-20 01:14:20 +0100 <Axman6> m257: you barely know any Haskell, how can you make thaty claim?
2023-11-20 01:14:28 +0100 <probie> m257: why do people choose C over assembly?
2023-11-20 01:14:59 +0100[_](~itchyjunk@user/itchyjunk/x-7353470)
2023-11-20 01:15:05 +0100 <jackdk> m257: speaking personally, because it's at the sweet spot of "I can use types to stop myself from making many, many errors" and "there are a good number of libraries to help me get things done"
2023-11-20 01:15:13 +0100juri_(~juri@84-19-175-187.pool.ovpn.com) (Ping timeout: 255 seconds)
2023-11-20 01:15:15 +0100 <m257> probie: This is not C though.
2023-11-20 01:15:34 +0100 <jackdk> and, importantly, I can't get that type safety from any imperative languages that I'm aware of
2023-11-20 01:15:36 +0100 <Axman6> Python is simpler than assembly, why do epople use assembly? C is simpler than python, why do people use python? Assembly is simpler than C, why do people use C? None of these things make sense
2023-11-20 01:15:38 +0100 <m257> Comparing Haskell and other languages to C and assembly is not entirely fair.
2023-11-20 01:15:40 +0100 <ski> Haskell is relatively high-level (although you can go lower-level, too, if you really want to). it also has an emphasis on correctness (over "please just let me run the code, okay ?")
2023-11-20 01:16:01 +0100 <Axman6> m257: then why did you do it? =)
2023-11-20 01:16:23 +0100 <m257> People reccomended it. I am curious and am willing to learn new things.
2023-11-20 01:16:34 +0100 <m257> It is better to have an experience with the other side.
2023-11-20 01:16:46 +0100 <m257> Than just ignore it because it is not the same.
2023-11-20 01:16:55 +0100 <ski> add tools to your toolbox. more (different !) ways to think about things
2023-11-20 01:17:47 +0100 <ski> different approaches, ways to solve programming problems
2023-11-20 01:18:02 +0100 <probie> m257: I was hoping it would provide insight into how you think about programming languages, and either provide an avenue to answer your question, or alternatively accept that Haskell offers nothing that you want
2023-11-20 01:18:40 +0100 <ski> m257 : anyway .. don't forget to have fun, while you're at it !
2023-11-20 01:18:55 +0100 <jackdk> This is a good instinct m257 but I recommend trying to set aside concerns around low-level data structure representation until you've got the language itself under your belt, and then go read Okasaki's thesis or book on purely functional data structures or something to see what you can do with laziness and purely functional data structures.
2023-11-20 01:18:57 +0100 <ski> (learning tends to become much nicer, and more efficient, if one's having fun)
2023-11-20 01:19:10 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470) (Ping timeout: 276 seconds)
2023-11-20 01:19:23 +0100 <ski> @where Okasaki
2023-11-20 01:19:23 +0100 <lambdabot> http://www.cs.cmu.edu/~rwh/theses/okasaki.pdf
2023-11-20 01:19:27 +0100 <ski> @where FPDS
2023-11-20 01:19:28 +0100 <lambdabot> I know nothing about fpds.
2023-11-20 01:19:41 +0100 <m257> Well it is harder to have fun with Haskell because I have previous experience with C.
2023-11-20 01:19:46 +0100 <ski> @where PFDS
2023-11-20 01:19:46 +0100 <lambdabot> "Purely Functional Data Structures" by Chris Okasaki : Ph. D. thesis in 1996-09 at <https://web.archive.org/web/20210917054102/https://www.cs.cmu.edu/~rwh/theses/okasaki.pdf> ; book in ((1st ed.)
2023-11-20 01:19:46 +0100 <lambdabot> 1998-04-13 -) 1999-06-13 at <https://www.amazon.com/Purely-Functional-Structures-Chris-Okasaki/dp/0521663504>
2023-11-20 01:20:14 +0100 <m257> Like writing programs with difficulty knowing you can do it easily with another tool.
2023-11-20 01:20:23 +0100 <ski> set aside your experience, and comparisions, for the time being. you'll have plenty of time to compare later. trust us, this really helps improve efficiency of learning
2023-11-20 01:20:28 +0100 <Axman6> m257: I've taught many people Haskell over the years, particularly first year university students, and it is very common that the students who know other languages struggle as much, if not more, when learning haskell because it requires you to thing differently. People who do make the effort to learn Haskell as a second or n+1 language often say it makes them a much better programmer in those other languages, and the work was well worth it
2023-11-20 01:21:44 +0100 <ski> (the harder part of learning a new programming paradigm is *unlearning*, becoming aware of unstated assumptions about how "programming must be", being able to come at it with a "fresh, open mind". in the end, you'll end up with a richer, more well-rounded understanding of the different approaches, and their pros and cons)
2023-11-20 01:21:50 +0100 <Axman6> m257: we can all add numbers together, so why bother learning integral calculus? We can all set things of fire, so why learn thermodynamics? You learn new thigns so you can have new thoughts, and few languages let you do that as well as Haskell
2023-11-20 01:22:16 +0100 <m257> Axman6: I am not arguing.
2023-11-20 01:22:24 +0100 <ski> you're fine, m257
2023-11-20 01:22:31 +0100 <m257> Just stating my experience so far.
2023-11-20 01:22:45 +0100 <ski> yes, that's quite okay, good
2023-11-20 01:23:31 +0100 <ski> we're just trying to explain what, in our experience, have been a more useful stance, when learning Haskell (or other functional programming), after being previously exposed to imperative programming
2023-11-20 01:23:50 +0100skistarted with BASIC and then assembler
2023-11-20 01:24:04 +0100 <Axman6> m257: well, when you say things like "To be honest assembly is simpler than this. Why do people use Haskell over other languages?", it kinda sounds like you are arguing that it's not worth it, when you're in a room full of people who have come to the realisation it is absolutely worth it
2023-11-20 01:24:37 +0100 <m257> Axman6: That wasn't my intent just so you know.
2023-11-20 01:24:42 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net)
2023-11-20 01:24:50 +0100 <ski> i don't doubt you, m257
2023-11-20 01:24:57 +0100 <Axman6> We've all come from other languages, it's pretty rare for Haskell to be anyone's first language (though I've taught plenty of people who that was the case for, and they enjoyed it)
2023-11-20 01:25:00 +0100 <m257> I should probably not do this over IRC and focus on the book.
2023-11-20 01:25:15 +0100 <ski> it's just that, sometimes, people may interpret it like that. especially if there's been experience with people trolling before
2023-11-20 01:25:33 +0100 <jackdk> "Like writing programs with difficulty knowing you can do it easily with another tool." <- this is a real and frustrating thought that many newcomers have. It has been my experience that when you take those "easy" shortcuts off the table, you have to sweat a bit more to get your head around the mental models that make programming possible without those shortcuts. But I find these models better than the ones more mainstream programming languages allow.
2023-11-20 01:25:41 +0100 <Axman6> Feel free to ask for clarification for things in the book here (with references to the book, many of us haven't used any of them for a long time)
2023-11-20 01:25:55 +0100 <ski> m257 : do come back and ask whenever you're wondering about something
2023-11-20 01:26:12 +0100 <jackdk> This is why I say that "Haskell is my favourite imperative language", as well as "Haskell is my favourite dynamically-typed language", with tongue only somewhat in-cheek.
2023-11-20 01:26:24 +0100 <m257> Axman6: I was asking about reasons why Haskell is more useful than other languages with that question. Like what types of programs are easier to write in haskell?
2023-11-20 01:26:46 +0100 <monochrom> I go up one meta level. It is simpler to not tell other people what to do than to tell other people what to do. So why is everyone telling other people what to do? >:)
2023-11-20 01:27:17 +0100 <m257> jackdk: lol
2023-11-20 01:27:21 +0100 <jackdk> I find it much easier to write programs which call AWS services, because the types describe the requests and responses so much more clearly than many of the first-class SDKs.
2023-11-20 01:27:26 +0100 <monochrom> (Answer: By a self-selection bias, programmers tend to be control freaks.)
2023-11-20 01:27:33 +0100 <Axman6> Writing maintainable programs is certainlyeasier in Haskell, the type system saves you from a hell of a lot of pain and is a tool that works for you - if you're used to static style systems like Java, Haskell's is significantly more usewful, flexible, terse and helpful
2023-11-20 01:27:35 +0100 <ski> monochrom : you can't tell me not to tell other people what to do
2023-11-20 01:27:36 +0100 <ski> ;)
2023-11-20 01:28:11 +0100ystael(~ystael@user/ystael) (Ping timeout: 252 seconds)
2023-11-20 01:28:23 +0100 <Axman6> m257: it's one of tyhe best languages for writing concurrent systems in (just ask Facebook, their entire spam filtering infrastructe is written in Haskell and handles on the order of 2 millions requests per second)
2023-11-20 01:29:23 +0100 <m257> Is Haskell in the real world running compiled or in a interpreter. I like how the langauge gives you the choice between them.
2023-11-20 01:29:27 +0100 <ski> m257 : handling mini-languages, and trees, is a joy in Haskell
2023-11-20 01:29:34 +0100 <ski> GHC is a compiler
2023-11-20 01:29:37 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net) (Ping timeout: 255 seconds)
2023-11-20 01:29:43 +0100 <m257> and ghci?
2023-11-20 01:29:58 +0100 <ski> also a compiler. byte-compiler. interactive (an interactor, aka REPL)
2023-11-20 01:30:01 +0100 <haskellbridge> 06<s​m> in ghci, kind of a mixture
2023-11-20 01:30:04 +0100 <Axman6> I've been writing Haskell professionally for about a decade, and the ability to just change something, and then find every thing that just broke, and keep making only the necessary changes until it compiles again, and be very confident it will work again is amazing
2023-11-20 01:30:06 +0100 <m257> I am currently just using ghc. But might use the interactive mode as well.
2023-11-20 01:30:23 +0100 <ski> (GHC is batch, not interactive)
2023-11-20 01:30:53 +0100 <m257> Axman6: I would assume they are less breakage in a functional language.
2023-11-20 01:31:02 +0100 <Axman6> ghci is generally what you want to use when developing small functions, so basically everything you will do as a beginner
2023-11-20 01:31:10 +0100 <m257> Like if you change a thing it won't cascade as much.
2023-11-20 01:31:30 +0100 <Axman6> Things definitely cascade, but the type system keeps you honest so you know exactly where to make changes
2023-11-20 01:31:38 +0100 <ski> Axman6 : `-Wincomplete-patterns' ftw
2023-11-20 01:31:46 +0100 <jackdk> Because your data dependencies are often much clearer (because of the purity thing), it's much less likely that changes induce spooky action at a distance.
2023-11-20 01:31:47 +0100 <m257> Can I get ghci to load from a file? and then interactively input?
2023-11-20 01:31:57 +0100zetef(~quassel@5.2.182.98) (Ping timeout: 256 seconds)
2023-11-20 01:32:11 +0100 <m257> jackdk: Coming from C any small change in memory management can be dangerous.
2023-11-20 01:32:11 +0100 <Axman6> Good luck doing that in Python, or even C - change something, think real hard, hope you thought hard enough to remember everything that change would affect, then wait for the bug reports
2023-11-20 01:32:15 +0100 <jackdk> For starting out, `ghci Foo.hs` and then entering `:r` (short for `:reload`) will give you a pretty decent experience
2023-11-20 01:32:18 +0100 <Axman6> ski: indeed
2023-11-20 01:32:27 +0100 <monochrom> Instead of break vs not break, it is: break silently vs break loudly
2023-11-20 01:32:28 +0100 <ski> m257 : `:l Foo.hs' in `ghci'
2023-11-20 01:32:37 +0100 <ski> m257 : or `ghci Foo.hs' from command line
2023-11-20 01:32:42 +0100 <m257> I often need to modularize in C to stop cascading effects.
2023-11-20 01:32:42 +0100 <Axman6> m257: ghci foo.hs (or :load foo.hs when you're inside ghci already)
2023-11-20 01:32:45 +0100 <ski> m257 : `:r' to reload, after you've saved changes to file
2023-11-20 01:32:47 +0100 <m257> ski: Thanks.
2023-11-20 01:33:53 +0100 <m257> Wait ghci can compile and call function like it is a shared object?
2023-11-20 01:33:58 +0100 <m257> That is really cool.
2023-11-20 01:34:03 +0100 <m257> I wish C had that.
2023-11-20 01:34:46 +0100 <Axman6> I wish all the time I had a repl for C, trying to debug programs with out a repl is madenss
2023-11-20 01:34:53 +0100 <jackdk> . o (If you really want to cause chaos, use tinycc as a library)
2023-11-20 01:34:57 +0100 <m257> Honestly its more performant than I thought.
2023-11-20 01:35:14 +0100 <m257> I just ran a massive recursive function and it executed quite quickly.
2023-11-20 01:35:28 +0100 <Axman6> Haskell's performance is much closer to C's than python's
2023-11-20 01:35:40 +0100 <ski> a lot of work has went into both low and high-level optimizations, and improving the baseline of the execution
2023-11-20 01:35:44 +0100 <sm[i]> welcome m257.. a late reply to "To be honest assembly is simpler than this" - of course, assembly is building blocks, but Haskell lets you build much larger, more portable, and more maintainable software
2023-11-20 01:35:48 +0100 <m257> Axman6: I have spent so many hours in gdb. I could have avoided if C had repls.
2023-11-20 01:35:56 +0100 <Axman6> > 3^324 `div` 5^46
2023-11-20 01:35:57 +0100 <lambdabot> 2720610248541694410640635749566672416827935594945917507340052388850816002134...
2023-11-20 01:36:13 +0100 <ski> > length (show (3^324 `div` 5^46))
2023-11-20 01:36:14 +0100 <lambdabot> 123
2023-11-20 01:36:35 +0100 <EvanR> that computation is pretty fast in python
2023-11-20 01:36:55 +0100 <Axman6> > let fibs = 0 : 1 : zipWith (+) fibs (tail fibs) in fibs !! 10000
2023-11-20 01:36:58 +0100 <lambdabot> 3364476487643178326662161200510754331030214846068006390656476997468008144216...
2023-11-20 01:37:06 +0100 <ski> > let fibs = 0 : 1 : zipWith (+) fibs (tail fibs) in fibs
2023-11-20 01:37:07 +0100 <lambdabot> [0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946,...
2023-11-20 01:37:14 +0100 <Axman6> > let fibs = 0 : 1 : zipWith (+) fibs (tail fibs) in length (show (fibs !! 10000))
2023-11-20 01:37:16 +0100 <lambdabot> 2090
2023-11-20 01:37:41 +0100 <ski> > let sieve (p:ns) = p : sieve [n | n <- ns,n `mod` p /= 0] in sieve [2 ..]
2023-11-20 01:37:42 +0100 <lambdabot> [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,...
2023-11-20 01:37:54 +0100 <Axman6> Yeah to be fair, python ints are not terrible, one of the few things I find not terrible about the language
2023-11-20 01:38:20 +0100 <m257> I try to avoid python but it seems to be everywhere.
2023-11-20 01:39:08 +0100 <m257> I am going to try and experiment with the basics of Haskell but as a beginner project would a compiler be a bit too complicated? What is a good beginner project in Haskell?
2023-11-20 01:40:04 +0100 <ski> @let infixr 5 /\/; (/\/) :: [a] -> [a] -> [a]; [ ] /\/ ys = ys; (x:xs) /\/ ys = x : ys /\/ xs
2023-11-20 01:40:06 +0100 <sm[i]> the simpler the better
2023-11-20 01:40:06 +0100 <lambdabot> Defined.
2023-11-20 01:40:27 +0100 <ski> > let abacaba = repeat 0 /\/ map (1 +) abacaba in abacaba
2023-11-20 01:40:28 +0100 <lambdabot> [0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1...
2023-11-20 01:41:18 +0100 <ski> > let popc = 0 : tail (popc /\/ map (1+) popc) in popc
2023-11-20 01:41:20 +0100 <lambdabot> [0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,1,2,2,3,2,3...
2023-11-20 01:41:40 +0100 <ski> > map popCount [0 ..]
2023-11-20 01:41:42 +0100 <lambdabot> [0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,1,2,2,3,2,3...
2023-11-20 01:41:49 +0100 <m257> What is good way to improve the readability of my code in Haskell? Should indent like lisp?
2023-11-20 01:42:07 +0100 <ski> (`popCount n' counts the number of `1' bits in the binary numeral representation of `n')
2023-11-20 01:42:32 +0100 <Axman6> m257: a compiler is a relatively common beginner-intermediate project - Haskell is very well known for implementing compilers in, but you must understand the fundamentals of the language first, and you're a long way off that
2023-11-20 01:42:43 +0100 <Axman6> m257: read a lot of other haskell code and see what others do
2023-11-20 01:42:44 +0100 <EvanR> m257, text adventure
2023-11-20 01:42:58 +0100 <sm[i]> I feel that is a very particular meaning of "beginner"
2023-11-20 01:43:00 +0100 <m257> yes that is why I said "experiment with the basics"
2023-11-20 01:43:05 +0100 <m257> EvanR: Good Idea
2023-11-20 01:43:15 +0100 <m257> That sounds simple enough.
2023-11-20 01:43:36 +0100 <EvanR> single player text adventure is simple enough, then you can graduate to multiplayer or MUD xD
2023-11-20 01:43:40 +0100 <sm[i]> most newcomers will struggle with a guess the number program
2023-11-20 01:43:58 +0100 <m257> EvanR: I can only imagine networking in haskell.
2023-11-20 01:44:01 +0100 <EvanR> (multi-user dungeon)
2023-11-20 01:44:55 +0100misterfish(~misterfis@84-53-85-146.bbserv.nl) (Ping timeout: 255 seconds)
2023-11-20 01:45:26 +0100 <m257> Alright thanks guys, I am going to go now.
2023-11-20 01:45:28 +0100 <m257> Bye
2023-11-20 01:45:30 +0100sm[i]would suggest https://www.joachim-breitner.de/blog/775-Learn_Haskell_on_CodeWorld_writing_Sokoban
2023-11-20 01:46:37 +0100 <m257> sm[i]: Why wouldn't I run it locally?
2023-11-20 01:47:04 +0100 <haskellbridge> 06<s​m> you will most likely hit a ton of tooling issues that will be a big distraction
2023-11-20 01:48:04 +0100 <haskellbridge> 06<s​m> it's nice to have a repeatable learning path to follow, and this seems like one
2023-11-20 01:48:25 +0100 <ski> "What I Wish I Knew When Learning Haskell" by Stephen Diehl <https://web.archive.org/web/20220513191346/https://dev.stephendiehl.com/hask/>,"Learn Haskell" by bitemyapp <https://github.com/bitemyapp/learnhaskell/>,"Functional Education" by ibid at <https://bitemyapp.com/blog/functional-education/>
2023-11-20 01:48:30 +0100 <ski> m257 ^
2023-11-20 01:48:30 +0100juri__(~juri@79.140.115.182) (Read error: Connection reset by peer)
2023-11-20 01:48:44 +0100 <ski> m257 : have fun, take care
2023-11-20 01:48:52 +0100juri_(~juri@79.140.115.182)
2023-11-20 01:49:08 +0100 <haskellbridge> 06<s​m> ski, WIWIKWLH seems not to be in the archive for me. (I really wish it was not dead!)
2023-11-20 01:49:20 +0100 <jackdk> m257: My default recommendation is http://jackkelly.name/blog/archives/2022/05/28/text-mode_games_as_first_haskell_projects/
2023-11-20 01:50:25 +0100 <ski> sm : "WIWIKWLH" ?
2023-11-20 01:50:40 +0100 <ski> oh
2023-11-20 01:50:41 +0100 <haskellbridge> 06<s​m> What I Wish I Knew When Learning Haskell
2023-11-20 01:50:45 +0100 <ski> right
2023-11-20 01:50:45 +0100 <jackdk> ski: What I Wish I Knew When Learning Haskell
2023-11-20 01:50:56 +0100skinever saw it abbreviated before
2023-11-20 01:51:03 +0100 <ski> sm : anyway .. link works for me ?
2023-11-20 01:51:26 +0100 <ski> sm : did you accidentally get the delimiting angle bracket at the end in the URL ?
2023-11-20 01:51:48 +0100 <haskellbridge> 06<s​m> ah, yes, in Element. Better: https://web.archive.org/web/20220513191346/https://dev.stephendiehl.com/hask
2023-11-20 01:52:39 +0100 <haskellbridge> 06<s​m> @where wiwikwlh
2023-11-20 01:53:06 +0100 <sm[i]> @where wiwikwlh
2023-11-20 01:53:07 +0100 <lambdabot> see wiwik
2023-11-20 01:53:11 +0100 <sm[i]> @where wiwik
2023-11-20 01:53:11 +0100 <lambdabot> https://github.com/sdiehl/wiwinwlh/blob/master/tutorial.md (tmp link until https://dev.stephendiehl.com/hask returns)
2023-11-20 01:53:27 +0100 <sm[i]> aha
2023-11-20 01:54:44 +0100 <sm[i]> @where+ wiwik https://github.com/sdiehl/wiwinwlh/blob/master/tutorial.md Steven Diehl's What I Wish I Knew When Learning Haskell
2023-11-20 01:54:44 +0100 <lambdabot> Done.
2023-11-20 01:56:44 +0100 <ski> <https://datatracker.ietf.org/doc/html/rfc1738#page-22>
2023-11-20 02:00:05 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:a57c:6e2:236b:24e3) (Remote host closed the connection)
2023-11-20 02:00:19 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:a57c:6e2:236b:24e3)
2023-11-20 02:02:17 +0100 <jackdk> ski: did you mean <URL:https://datatracker.ietf.org/doc/html/rfc1738#page-22> ?
2023-11-20 02:03:20 +0100 <ski> "In some cases"
2023-11-20 02:04:25 +0100 <jackdk> ;-)
2023-11-20 02:06:23 +0100skismiles
2023-11-20 02:07:00 +0100rosco(~rosco@175.136.157.149)
2023-11-20 02:08:08 +0100juri_(~juri@79.140.115.182) (Read error: Connection reset by peer)
2023-11-20 02:09:16 +0100juri_(~juri@79.140.115.182)
2023-11-20 02:10:27 +0100 <int-e> That standard was not written for people manually selecting the URL in their terminal. (It doesn't matter to browsers whether you grab an extra space, but they don't like < or > or :)
2023-11-20 02:11:06 +0100 <int-e> ...unfortunate smiley
2023-11-20 02:14:46 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:a57c:6e2:236b:24e3) (Remote host closed the connection)
2023-11-20 02:15:07 +0100 <ski> W3m used to not like extra spaces
2023-11-20 02:15:37 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:a57c:6e2:236b:24e3)
2023-11-20 02:15:49 +0100 <ski> (now it replaces them with `%20'. before it would beep)
2023-11-20 02:16:15 +0100 <int-e> Well, FF ignores them.
2023-11-20 02:16:23 +0100skinods
2023-11-20 02:20:51 +0100emmanuelux_(~emmanuelu@user/emmanuelux)
2023-11-20 02:22:16 +0100emmanuelux(~emmanuelu@user/emmanuelux) (Ping timeout: 255 seconds)
2023-11-20 02:26:33 +0100 <zzz> why don't we generalize take, replicate, etc to Integral?
2023-11-20 02:28:37 +0100 <ski> @type genericReplicate
2023-11-20 02:28:38 +0100 <lambdabot> Integral i => i -> a -> [a]
2023-11-20 02:29:40 +0100 <glguy> Keep in mind these generic* versions of the list functions do all the math at the generic type and are generally less efficient; you need a good reason to want to use them
2023-11-20 02:29:52 +0100 <probie> They are `Int` for historical reasons and there are generalised versions, but `Integral` is not suitable anyway, since their arguments should be non-negative
2023-11-20 02:30:29 +0100 <ski> `Word' ought to be used more
2023-11-20 02:30:29 +0100 <zzz> ok
2023-11-20 02:30:34 +0100 <zzz> ski: agreed
2023-11-20 02:31:30 +0100 <zzz> i use `default ([], Word, Text)` with ExtendedDefaultRules
2023-11-20 02:31:51 +0100 <ski> curious
2023-11-20 02:32:05 +0100 <ski> with `OverloadedStrings', i presume
2023-11-20 02:32:13 +0100 <zzz> and OverloadedLists
2023-11-20 02:32:18 +0100 <ski> mm
2023-11-20 02:33:31 +0100mima(~mmh@aftr-62-216-211-96.dynamic.mnet-online.de) (Ping timeout: 255 seconds)
2023-11-20 02:42:19 +0100 <m257> jackdk: Is that your personal blog? If so nice CSS. It is a very functional website.
2023-11-20 02:43:58 +0100 <ski> m257 : see "What I Wish I Knew When Learning Haskell" (and some more) links above
2023-11-20 02:44:16 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net)
2023-11-20 02:45:30 +0100 <jackdk> m257: yes, and thank you
2023-11-20 02:49:16 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net) (Ping timeout: 255 seconds)
2023-11-20 02:52:00 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Quit: ZNC - https://znc.in)
2023-11-20 02:56:42 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-20 03:00:20 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Remote host closed the connection)
2023-11-20 03:00:49 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643)
2023-11-20 03:00:53 +0100Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542) (Remote host closed the connection)
2023-11-20 03:06:11 +0100ec(~ec@gateway/tor-sasl/ec) (Remote host closed the connection)
2023-11-20 03:06:35 +0100otto_s(~user@p4ff27599.dip0.t-ipconnect.de) (Ping timeout: 256 seconds)
2023-11-20 03:06:36 +0100ec(~ec@gateway/tor-sasl/ec)
2023-11-20 03:07:43 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 256 seconds)
2023-11-20 03:08:19 +0100otto_s(~user@p4ff27179.dip0.t-ipconnect.de)
2023-11-20 03:15:25 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Quit: ZNC - https://znc.in)
2023-11-20 03:20:09 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-20 03:20:41 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com)
2023-11-20 03:20:42 +0100wroathe(~wroathe@207-153-38-140.fttp.usinternet.com) (Changing host)
2023-11-20 03:20:42 +0100wroathe(~wroathe@user/wroathe)
2023-11-20 03:36:49 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net)
2023-11-20 03:37:59 +0100Square(~Square@user/square) (Ping timeout: 252 seconds)
2023-11-20 03:40:37 +0100jumper149(~jumper149@base.felixspringer.xyz) (Quit: WeeChat 4.1.1)
2023-11-20 03:42:17 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net) (Ping timeout: 256 seconds)
2023-11-20 03:46:07 +0100emmanuelux_(~emmanuelu@user/emmanuelux) (Quit: au revoir)
2023-11-20 04:12:34 +0100rosco(~rosco@175.136.157.149) (Read error: Connection reset by peer)
2023-11-20 04:16:51 +0100td_(~td@i53870935.versanet.de) (Ping timeout: 256 seconds)
2023-11-20 04:18:47 +0100td_(~td@i5387090F.versanet.de)
2023-11-20 04:22:04 +0100FinnElija(~finn_elij@user/finn-elija/x-0085643) (Killed (NickServ (Forcing logout FinnElija -> finn_elija)))
2023-11-20 04:22:04 +0100finn_elija(~finn_elij@user/finn-elija/x-0085643)
2023-11-20 04:22:04 +0100finn_elijaFinnElija
2023-11-20 04:24:12 +0100arahael(~arahael@1.145.82.196)
2023-11-20 04:37:13 +0100emmanuelux(~emmanuelu@user/emmanuelux)
2023-11-20 04:42:29 +0100terrorjack(~terrorjac@2a01:4f8:c17:87f8::) (Quit: The Lounge - https://thelounge.chat)
2023-11-20 04:43:03 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net)
2023-11-20 04:43:55 +0100terrorjack(~terrorjac@2a01:4f8:c17:87f8::)
2023-11-20 04:44:55 +0100rosco(~rosco@175.136.157.149)
2023-11-20 04:45:34 +0100ystael(~ystael@user/ystael)
2023-11-20 04:47:46 +0100ystael(~ystael@user/ystael) (Client Quit)
2023-11-20 04:51:59 +0100m257(~maaz@184.147.203.180) (Ping timeout: 256 seconds)
2023-11-20 04:57:27 +0100emmanuelux(~emmanuelu@user/emmanuelux) (Read error: Connection reset by peer)
2023-11-20 04:57:51 +0100erty(~user@user/aeroplane)
2023-11-20 04:58:13 +0100emmanuelux(~emmanuelu@user/emmanuelux)
2023-11-20 04:59:19 +0100codedmart(codedmart@2600:3c01::f03c:92ff:fefe:8511) (Quit: ZNC 1.7.5+deb4 - https://znc.in)
2023-11-20 04:59:35 +0100codedmart(codedmart@2600:3c01::f03c:92ff:fefe:8511)
2023-11-20 05:05:56 +0100aforemny(~aforemny@i59F516DE.versanet.de)
2023-11-20 05:05:59 +0100ddellacosta(~ddellacos@ool-44c738de.dyn.optonline.net) (Ping timeout: 264 seconds)
2023-11-20 05:07:04 +0100aforemny_(~aforemny@2001:9e8:6cc8:5c00:9c1a:8ed9:7b58:2dc2) (Ping timeout: 255 seconds)
2023-11-20 05:07:41 +0100ddellacosta(~ddellacos@ool-44c738de.dyn.optonline.net)
2023-11-20 05:09:13 +0100johnw(~johnw@69.62.242.138)
2023-11-20 05:10:17 +0100emmanuelux(~emmanuelu@user/emmanuelux) (Quit: au revoir)
2023-11-20 05:27:27 +0100arahael(~arahael@1.145.82.196) (Ping timeout: 252 seconds)
2023-11-20 05:30:45 +0100riatre(~quassel@2001:310:6000:f::5198:1) (Ping timeout: 260 seconds)
2023-11-20 05:30:53 +0100riatre(~quassel@2001:310:6000:f::5198:1)
2023-11-20 05:40:43 +0100lisbeths(uid135845@id-135845.lymington.irccloud.com)
2023-11-20 05:41:44 +0100wroathe(~wroathe@user/wroathe) (Ping timeout: 252 seconds)
2023-11-20 05:48:01 +0100trev(~trev@user/trev)
2023-11-20 05:49:47 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net) (Ping timeout: 256 seconds)
2023-11-20 05:51:50 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Quit: = "")
2023-11-20 05:52:25 +0100erty(~user@user/aeroplane) (Ping timeout: 255 seconds)
2023-11-20 05:55:27 +0100vilya_(~vilya@user/vilya) (Ping timeout: 256 seconds)
2023-11-20 05:57:01 +0100vilya(~vilya@user/vilya)
2023-11-20 06:09:56 +0100arahael(~arahael@119-18-2-212.771202.syd.nbn.aussiebb.net)
2023-11-20 06:23:11 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex)
2023-11-20 06:27:17 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net)
2023-11-20 06:28:50 +0100misterfish(~misterfis@84-53-85-146.bbserv.nl)
2023-11-20 06:32:17 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net) (Ping timeout: 256 seconds)
2023-11-20 06:37:51 +0100erty(~user@user/aeroplane)
2023-11-20 06:40:11 +0100rosco(~rosco@175.136.157.149) (Ping timeout: 264 seconds)
2023-11-20 06:43:52 +0100dibblego(~dibblego@haskell/developer/dibblego) (Read error: Connection reset by peer)
2023-11-20 06:44:10 +0100dibblego(~dibblego@haskell/developer/dibblego)
2023-11-20 07:01:20 +0100_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl)
2023-11-20 07:03:36 +0100Guest35(~Guest82@ppp-27-55-74-218.revip3.asianet.co.th)
2023-11-20 07:05:02 +0100 <Guest35> Hi 👋
2023-11-20 07:05:07 +0100 <Guest35> https://hackage.haskell.org/package/StrictCheck
2023-11-20 07:05:15 +0100 <Guest35> this looks neat
2023-11-20 07:05:55 +0100 <Guest35> but it doesn't have any reverse dependencies
2023-11-20 07:06:11 +0100 <Guest35> is there a similar package that is more widely used?
2023-11-20 07:10:48 +0100zetef(~quassel@95.77.17.251)
2023-11-20 07:17:11 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net)
2023-11-20 07:17:44 +0100 <opqdonut> I guess it wouldn't show up in reverse deps if it's only used for testing a hackage library?
2023-11-20 07:18:46 +0100 <opqdonut> but I've also never heard of StrictCheck so I can't comment on how neat it is :)
2023-11-20 07:22:04 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net) (Ping timeout: 255 seconds)
2023-11-20 07:22:50 +0100takuan(~takuan@178-116-218-225.access.telenet.be)
2023-11-20 07:24:42 +0100Maeda(~Maeda@91-161-10-149.subs.proxad.net)
2023-11-20 07:31:11 +0100waleee(~waleee@h-176-10-144-38.NA.cust.bahnhof.se) (Ping timeout: 252 seconds)
2023-11-20 07:34:01 +0100harveypwca(~harveypwc@2601:246:c280:7940:585a:99af:3e4c:209b)
2023-11-20 07:34:29 +0100misterfish(~misterfis@84-53-85-146.bbserv.nl) (Ping timeout: 252 seconds)
2023-11-20 07:35:07 +0100Maeda(~Maeda@91-161-10-149.subs.proxad.net) (Quit: Time to sleep!)
2023-11-20 07:47:00 +0100Guest35(~Guest82@ppp-27-55-74-218.revip3.asianet.co.th) (Quit: Client closed)
2023-11-20 07:47:28 +0100rosco(~rosco@175.136.157.149)
2023-11-20 07:48:10 +0100rosco(~rosco@175.136.157.149) (Client Quit)
2023-11-20 07:57:10 +0100zetef(~quassel@95.77.17.251) (Ping timeout: 255 seconds)
2023-11-20 07:59:47 +0100analoq(~yashi@user/dies) (Ping timeout: 252 seconds)
2023-11-20 08:01:13 +0100analoq(~yashi@user/dies)
2023-11-20 08:03:34 +0100acidjnk(~acidjnk@p200300d6e72b9333e0d3f8384e141d02.dip0.t-ipconnect.de)
2023-11-20 08:10:19 +0100_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Ping timeout: 256 seconds)
2023-11-20 08:11:35 +0100_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl)
2023-11-20 08:18:00 +0100sord937(~sord937@gateway/tor-sasl/sord937)
2023-11-20 08:31:45 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-11-20 08:37:14 +0100erty(~user@user/aeroplane) (Read error: Connection reset by peer)
2023-11-20 08:38:09 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net)
2023-11-20 08:42:31 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 255 seconds)
2023-11-20 08:42:52 +0100euleritian(~euleritia@dynamic-002-247-250-127.2.247.pool.telefonica.de)
2023-11-20 08:43:11 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net) (Ping timeout: 256 seconds)
2023-11-20 08:50:40 +0100chele(~chele@user/chele)
2023-11-20 08:50:56 +0100lortabac(~lorenzo@2a01:e0a:541:b8f0:668:301b:fab1:c38d)
2023-11-20 09:04:33 +0100misterfish(~misterfis@87.215.131.102)
2023-11-20 09:05:01 +0100zetef(~quassel@95.77.17.251)
2023-11-20 09:09:49 +0100haskellbridge(~haskellbr@069-135-003-034.biz.spectrum.com) (Ping timeout: 256 seconds)
2023-11-20 09:17:02 +0100rosco(~rosco@175.136.157.149)
2023-11-20 09:23:55 +0100YoungFrog(~youngfrog@39.129-180-91.adsl-dyn.isp.belgacom.be) (Ping timeout: 255 seconds)
2023-11-20 09:25:10 +0100YoungFrog(~youngfrog@2a02:a03f:ca07:f900:97db:4ad1:c710:a642)
2023-11-20 09:25:23 +0100mima(~mmh@aftr-62-216-211-62.dynamic.mnet-online.de)
2023-11-20 09:26:29 +0100fendor(~fendor@2a02:8388:1640:be00:8705:c56:c793:802b)
2023-11-20 09:26:49 +0100euleritian(~euleritia@dynamic-002-247-250-127.2.247.pool.telefonica.de) (Ping timeout: 256 seconds)
2023-11-20 09:27:07 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-20 09:27:51 +0100harveypwca(~harveypwc@2601:246:c280:7940:585a:99af:3e4c:209b) (Quit: Leaving)
2023-11-20 09:30:16 +0100axeman(~quassel@ip5b40ac1e.dynamic.kabel-deutschland.de)
2023-11-20 09:33:32 +0100kmein(~weechat@user/kmein) (Ping timeout: 256 seconds)
2023-11-20 09:33:39 +0100gmg(~user@user/gehmehgeh)
2023-11-20 09:34:36 +0100CiaoSen(~Jura@2a05:5800:29e:f100:2a3a:4dff:fe84:dbd5)
2023-11-20 09:36:51 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-11-20 09:37:16 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net)
2023-11-20 09:41:55 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net) (Ping timeout: 255 seconds)
2023-11-20 09:43:36 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-11-20 09:49:19 +0100__monty__(~toonn@user/toonn)
2023-11-20 09:55:58 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net)
2023-11-20 09:57:10 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:a57c:6e2:236b:24e3) (Remote host closed the connection)
2023-11-20 09:58:28 +0100zetef(~quassel@95.77.17.251) (Ping timeout: 256 seconds)
2023-11-20 09:58:49 +0100Sgeo(~Sgeo@user/sgeo) (Read error: Connection reset by peer)
2023-11-20 10:00:55 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net) (Ping timeout: 255 seconds)
2023-11-20 10:05:22 +0100axeman(~quassel@ip5b40ac1e.dynamic.kabel-deutschland.de) (Ping timeout: 264 seconds)
2023-11-20 10:06:39 +0100tzh(~tzh@c-71-193-181-0.hsd1.or.comcast.net) (Quit: zzz)
2023-11-20 10:19:52 +0100axeman(~quassel@ip5b40ac1e.dynamic.kabel-deutschland.de)
2023-11-20 10:31:08 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:19c0:53d0:5da5:a978)
2023-11-20 10:31:17 +0100rosco(~rosco@175.136.157.149) (Quit: Lost terminal)
2023-11-20 10:39:35 +0100_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Ping timeout: 264 seconds)
2023-11-20 10:39:51 +0100pretty_dumm_guy(trottel@gateway/vpn/protonvpn/prettydummguy/x-88029655)
2023-11-20 10:41:18 +0100_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl)
2023-11-20 10:41:41 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net)
2023-11-20 10:46:43 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net) (Ping timeout: 255 seconds)
2023-11-20 10:47:29 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-11-20 10:48:31 +0100axeman(~quassel@ip5b40ac1e.dynamic.kabel-deutschland.de) (Ping timeout: 255 seconds)
2023-11-20 10:50:29 +0100gmg(~user@user/gehmehgeh) (Quit: Leaving)
2023-11-20 10:50:51 +0100kmein(~weechat@user/kmein)
2023-11-20 10:54:16 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:19c0:53d0:5da5:a978) (Ping timeout: 268 seconds)
2023-11-20 10:57:51 +0100axeman(~quassel@ip5b40ac1e.dynamic.kabel-deutschland.de)
2023-11-20 10:59:09 +0100danza(~francesco@151.57.216.176)
2023-11-20 11:00:17 +0100cdsloif^(~cd@c-98-242-74-66.hsd1.ga.comcast.net) (Remote host closed the connection)
2023-11-20 11:00:51 +0100dsrt^(~cd@c-98-242-74-66.hsd1.ga.comcast.net) (Remote host closed the connection)
2023-11-20 11:01:39 +0100econo_(uid147250@id-147250.tinside.irccloud.com) (Quit: Connection closed for inactivity)
2023-11-20 11:04:13 +0100Lord_of_Life_(~Lord@user/lord-of-life/x-2819915)
2023-11-20 11:05:25 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Ping timeout: 256 seconds)
2023-11-20 11:05:37 +0100Lord_of_Life_Lord_of_Life
2023-11-20 11:07:26 +0100danse-nr3(~danse@151.57.216.176)
2023-11-20 11:10:11 +0100danza(~francesco@151.57.216.176) (Ping timeout: 264 seconds)
2023-11-20 11:13:24 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net)
2023-11-20 11:18:53 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net) (Ping timeout: 252 seconds)
2023-11-20 11:27:49 +0100Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542)
2023-11-20 11:30:28 +0100 <lyxia> It's a research project, a paper was published, and its authors have moved on to other things.
2023-11-20 11:31:14 +0100juri_(~juri@79.140.115.182) (Read error: Connection reset by peer)
2023-11-20 11:31:35 +0100juri_(~juri@79.140.115.182)
2023-11-20 11:32:22 +0100haskellbridge(~haskellbr@069-135-003-034.biz.spectrum.com)
2023-11-20 11:32:22 +0100ChanServ+v haskellbridge
2023-11-20 11:32:51 +0100 <lyxia> And I think haskellers don't yet know what we really want out of laziness to the point that we'd write formal specification about it
2023-11-20 11:32:51 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-11-20 11:34:31 +0100axeman(~quassel@ip5b40ac1e.dynamic.kabel-deutschland.de) (Ping timeout: 255 seconds)
2023-11-20 11:37:37 +0100mokee(~mokee@37.228.215.150) (Quit: off)
2023-11-20 11:38:10 +0100kuribas(~user@ip-188-118-57-242.reverse.destiny.be)
2023-11-20 11:39:39 +0100rosco(~rosco@175.136.157.149)
2023-11-20 11:41:22 +0100ivelten(~ivelten@2804:82b8:8:ee01:7ceb:5700:d291:7d60)
2023-11-20 11:46:33 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-11-20 11:47:17 +0100axeman(~quassel@ip5b40ac1e.dynamic.kabel-deutschland.de)
2023-11-20 11:48:48 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net)
2023-11-20 11:54:04 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net) (Ping timeout: 256 seconds)
2023-11-20 11:56:34 +0100danse-nr3(~danse@151.57.216.176) (Read error: Connection reset by peer)
2023-11-20 11:56:59 +0100danse-nr3(~danse@151.57.216.176)
2023-11-20 12:01:21 +0100jespada(~jespada@cpc121308-nmal25-2-0-cust15.19-2.cable.virginm.net) (Quit: Textual IRC Client: www.textualapp.com)
2023-11-20 12:02:22 +0100ubert(~Thunderbi@91.141.78.225.wireless.dyn.drei.com)
2023-11-20 12:03:37 +0100danse-nr3(~danse@151.57.216.176) (Remote host closed the connection)
2023-11-20 12:03:59 +0100danse-nr3(~danse@151.57.216.176)
2023-11-20 12:06:42 +0100juri_(~juri@79.140.115.182) (Read error: Connection reset by peer)
2023-11-20 12:09:12 +0100zetef(~quassel@95.77.17.251)
2023-11-20 12:12:06 +0100Inst(~Inst@120.244.192.250) (Read error: Connection reset by peer)
2023-11-20 12:18:08 +0100CiaoSen(~Jura@2a05:5800:29e:f100:2a3a:4dff:fe84:dbd5) (Ping timeout: 268 seconds)
2023-11-20 12:22:16 +0100juri_(~juri@faikvm.com)
2023-11-20 12:25:20 +0100arkeet(arkeet@moriya.ca) (Ping timeout: 252 seconds)
2023-11-20 12:25:24 +0100idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-11-20 12:25:47 +0100zetef(~quassel@95.77.17.251) (Ping timeout: 264 seconds)
2023-11-20 12:28:50 +0100chomwitt(~chomwitt@2a02:587:7a24:bc00:1ac0:4dff:fedb:a3f1)
2023-11-20 12:33:26 +0100arkeet(~arkeet@moriya.ca)
2023-11-20 12:34:47 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 268 seconds)
2023-11-20 12:35:29 +0100euleritian(~euleritia@dynamic-002-247-251-139.2.247.pool.telefonica.de)
2023-11-20 12:37:05 +0100lortabac(~lorenzo@2a01:e0a:541:b8f0:668:301b:fab1:c38d) (Ping timeout: 256 seconds)
2023-11-20 12:48:59 +0100_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Read error: Connection reset by peer)
2023-11-20 12:49:00 +0100ht_(~Thunderbi@28-52-174-82.ftth.glasoperator.nl)
2023-11-20 12:51:50 +0100_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl)
2023-11-20 12:52:39 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:19c0:53d0:5da5:a978)
2023-11-20 12:53:29 +0100ht_(~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Ping timeout: 252 seconds)
2023-11-20 12:56:22 +0100euleritian(~euleritia@dynamic-002-247-251-139.2.247.pool.telefonica.de) (Read error: Connection reset by peer)
2023-11-20 12:56:24 +0100vilya(~vilya@user/vilya) (Ping timeout: 256 seconds)
2023-11-20 12:56:41 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-20 12:58:14 +0100vilya(~vilya@user/vilya)
2023-11-20 13:00:51 +0100lortabac(~lorenzo@2a01:e0a:541:b8f0:85bb:2bfd:621:a9d4)
2023-11-20 13:02:10 +0100sawilagar(~sawilagar@user/sawilagar)
2023-11-20 13:04:59 +0100danse-nr3(~danse@151.57.216.176) (Ping timeout: 256 seconds)
2023-11-20 13:07:17 +0100haskl(~haskl@user/haskl) (Remote host closed the connection)
2023-11-20 13:07:34 +0100haskl(~haskl@user/haskl)
2023-11-20 13:08:14 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net)
2023-11-20 13:08:39 +0100alp_(~alp@2001:861:e3d6:8f80:8c15:d658:f6c0:b840)
2023-11-20 13:12:58 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net) (Ping timeout: 255 seconds)
2023-11-20 13:15:32 +0100[itchyjunk](~itchyjunk@user/itchyjunk/x-7353470)
2023-11-20 13:18:25 +0100danse-nr3(~danse@151.57.216.176)
2023-11-20 13:19:22 +0100[_](~itchyjunk@user/itchyjunk/x-7353470) (Ping timeout: 276 seconds)
2023-11-20 13:24:38 +0100jinsun_(~jinsun@user/jinsun)
2023-11-20 13:24:38 +0100jinsunGuest5647
2023-11-20 13:24:38 +0100jinsun_jinsun
2023-11-20 13:25:18 +0100axeman(~quassel@ip5b40ac1e.dynamic.kabel-deutschland.de) (Ping timeout: 256 seconds)
2023-11-20 13:29:07 +0100Guest5647(~jinsun@user/jinsun) (Ping timeout: 276 seconds)
2023-11-20 13:40:42 +0100edr(~edr@user/edr)
2023-11-20 13:42:43 +0100ft(~ft@mue-88-130-106-120.dsl.tropolys.de) (Quit: leaving)
2023-11-20 13:53:13 +0100idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 4.1.1)
2023-11-20 13:59:16 +0100CiaoSen(~Jura@2a05:5800:29e:f100:2a3a:4dff:fe84:dbd5)
2023-11-20 14:09:06 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net)
2023-11-20 14:13:19 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-11-20 14:13:49 +0100jmdaemon(~jmdaemon@user/jmdaemon) (Ping timeout: 255 seconds)
2023-11-20 14:13:59 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:19c0:53d0:5da5:a978) (Ping timeout: 256 seconds)
2023-11-20 14:14:23 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net) (Ping timeout: 264 seconds)
2023-11-20 14:21:08 +0100Square2(~Square4@user/square)
2023-11-20 14:21:37 +0100akegalj(~akegalj@78-1-185-234.adsl.net.t-com.hr)
2023-11-20 14:23:56 +0100alp_(~alp@2001:861:e3d6:8f80:8c15:d658:f6c0:b840) (Ping timeout: 268 seconds)
2023-11-20 14:25:47 +0100alp_(~alp@2001:861:e3d6:8f80:3334:bb1d:62ea:76e2)
2023-11-20 14:37:22 +0100rosco(~rosco@175.136.157.149) (Quit: Lost terminal)
2023-11-20 14:39:48 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-11-20 14:48:46 +0100Feuermagier_(~Feuermagi@user/feuermagier)
2023-11-20 14:48:46 +0100FeuermagierGuest2344
2023-11-20 14:48:46 +0100Guest2344(~Feuermagi@user/feuermagier) (Killed (lithium.libera.chat (Nickname regained by services)))
2023-11-20 14:48:46 +0100Feuermagier_Feuermagier
2023-11-20 14:52:22 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net)
2023-11-20 14:55:11 +0100misterfish(~misterfis@87.215.131.102) (Ping timeout: 264 seconds)
2023-11-20 14:57:35 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net) (Ping timeout: 264 seconds)
2023-11-20 15:01:12 +0100danse-nr3(~danse@151.57.216.176) (Read error: Connection reset by peer)
2023-11-20 15:01:51 +0100danse-nr3(~danse@151.57.151.166)
2023-11-20 15:07:06 +0100CiaoSen(~Jura@2a05:5800:29e:f100:2a3a:4dff:fe84:dbd5) (Ping timeout: 268 seconds)
2023-11-20 15:09:02 +0100__monty__(~toonn@user/toonn) (Quit: leaving)
2023-11-20 15:12:33 +0100ystael(~ystael@user/ystael)
2023-11-20 15:22:05 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915) (Excess Flood)
2023-11-20 15:22:48 +0100Unicorn_Princess(~Unicorn_P@user/Unicorn-Princess/x-3540542) (Remote host closed the connection)
2023-11-20 15:23:19 +0100califax(~califax@user/califx) (Remote host closed the connection)
2023-11-20 15:24:44 +0100califax(~califax@user/califx)
2023-11-20 15:26:25 +0100Lord_of_Life(~Lord@user/lord-of-life/x-2819915)
2023-11-20 15:28:52 +0100danse-nr3(~danse@151.57.151.166) (Ping timeout: 255 seconds)
2023-11-20 15:31:41 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net)
2023-11-20 15:32:08 +0100danse-nr3(~danse@151.57.151.166)
2023-11-20 15:36:31 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net) (Ping timeout: 255 seconds)
2023-11-20 15:55:24 +0100Simikando(~Simikando@adsl-dyn216.91-127-84.t-com.sk)
2023-11-20 15:57:37 +0100alp_(~alp@2001:861:e3d6:8f80:3334:bb1d:62ea:76e2) (Ping timeout: 246 seconds)
2023-11-20 15:59:23 +0100axeman(~quassel@91.64.172.30)
2023-11-20 16:00:29 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 252 seconds)
2023-11-20 16:00:42 +0100euleritian(~euleritia@dynamic-002-247-251-031.2.247.pool.telefonica.de)
2023-11-20 16:01:52 +0100earldouglas(~james@user/earldouglas)
2023-11-20 16:12:36 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:19c0:53d0:5da5:a978)
2023-11-20 16:14:06 +0100zetef(~quassel@95.77.17.251)
2023-11-20 16:15:56 +0100idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c)
2023-11-20 16:20:57 +0100kiriakos(~kiriakos@p5b03e17a.dip0.t-ipconnect.de)
2023-11-20 16:23:59 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net)
2023-11-20 16:29:23 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net) (Ping timeout: 264 seconds)
2023-11-20 16:31:55 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:19c0:53d0:5da5:a978) (Ping timeout: 246 seconds)
2023-11-20 16:40:20 +0100axeman(~quassel@91.64.172.30) (Ping timeout: 245 seconds)
2023-11-20 16:43:03 +0100dolio(~dolio@130.44.134.54) (Quit: ZNC 1.8.2 - https://znc.in)
2023-11-20 16:46:51 +0100bitdex(~bitdex@gateway/tor-sasl/bitdex) (Quit: = "")
2023-11-20 16:47:42 +0100ivelten(~ivelten@2804:82b8:8:ee01:7ceb:5700:d291:7d60) (Quit: My MacBook has gone to sleep. ZZZzzz…)
2023-11-20 16:50:22 +0100bontaq(~user@ool-45707d2c.dyn.optonline.net)
2023-11-20 16:50:35 +0100alp_(~alp@2001:861:e3d6:8f80:30:6015:6959:7134)
2023-11-20 16:56:02 +0100zetef(~quassel@95.77.17.251) (Ping timeout: 252 seconds)
2023-11-20 16:56:21 +0100misterfish(~misterfis@84-53-85-146.bbserv.nl)
2023-11-20 16:59:01 +0100Feuermagier(~Feuermagi@user/feuermagier) (Ping timeout: 256 seconds)
2023-11-20 16:59:06 +0100Feuermagier_(~Feuermagi@user/feuermagier)
2023-11-20 16:59:06 +0100Feuermagier_Feuermagier
2023-11-20 16:59:10 +0100euleritian(~euleritia@dynamic-002-247-251-031.2.247.pool.telefonica.de) (Read error: Connection reset by peer)
2023-11-20 16:59:28 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-20 17:02:59 +0100danse-nr3(~danse@151.57.151.166) (Ping timeout: 264 seconds)
2023-11-20 17:04:49 +0100Simikando(~Simikando@adsl-dyn216.91-127-84.t-com.sk) (Ping timeout: 255 seconds)
2023-11-20 17:06:12 +0100Simikando(~Simikando@adsl-dyn216.91-127-84.t-com.sk)
2023-11-20 17:06:51 +0100zetef(~quassel@95.77.17.251)
2023-11-20 17:10:28 +0100danse-nr3(~danse@151.57.151.166)
2023-11-20 17:15:04 +0100Inst(~Inst@120.244.192.250)
2023-11-20 17:15:15 +0100 <Inst> Can I have a bit of help with the applicative laws?
2023-11-20 17:15:21 +0100 <Inst> The way I understand the 5 monad labs
2023-11-20 17:16:05 +0100 <Inst> left identity guarantees that pure u in do notation is equivalent to let u, and is useful when you have a monadic action that can return no effect
2023-11-20 17:16:26 +0100 <Inst> right identity guarantees that ending with pure foo at the end do notation results in no unexpected side effects
2023-11-20 17:17:23 +0100 <Inst> associativity means that the sequence of effects is the same whether you inline a composite monadic action or refer to it as a value defined elsewhere
2023-11-20 17:17:43 +0100 <Inst> pure = return links applicative and monad by needing the same eta operation
2023-11-20 17:18:15 +0100 <Inst> <*> = ap means that applicatives, to have a monad, must have a sequential series of effects
2023-11-20 17:18:25 +0100 <Inst> (<*>) = ap
2023-11-20 17:18:40 +0100 <Inst> that matches the ap sequencing of effects
2023-11-20 17:18:53 +0100 <Inst> pure id <*> v = v, that's identity
2023-11-20 17:19:08 +0100 <Inst> pure f <*> pure x = pure (f x) homomorphism
2023-11-20 17:19:27 +0100 <Inst> u <*> pure y = pure ($ y) <*> u interchange
2023-11-20 17:19:59 +0100 <Inst> pure (.) <*> u <*> v <*> w = u <*> (v <*> w)
2023-11-20 17:20:01 +0100Simikando(~Simikando@adsl-dyn216.91-127-84.t-com.sk) (Ping timeout: 255 seconds)
2023-11-20 17:20:04 +0100 <Inst> bleh, too sick to do this
2023-11-20 17:20:26 +0100 <ncf> was there a question?
2023-11-20 17:21:35 +0100 <Inst> I guess, why?
2023-11-20 17:21:55 +0100 <Inst> The monad laws given above show how the monad laws provide useful properties
2023-11-20 17:22:02 +0100 <Inst> how do the applicative laws provide useful properties?
2023-11-20 17:22:53 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:19c0:53d0:5da5:a978)
2023-11-20 17:24:16 +0100pavonia(~user@user/siracusa) (Quit: Bye!)
2023-11-20 17:24:44 +0100 <Inst> composition, at the end
2023-11-20 17:24:58 +0100 <ncf> they're really just monoid laws in disguise; they ensure that you can express any applicative computation as liftAn f a1 ... an, where f is an n-ary function
2023-11-20 17:25:25 +0100 <Inst> would you say monad laws are monoid laws in disguise? Because that doesn't achieve the same level of utility as the "monad laws provide useful properties for reasoning about programs"
2023-11-20 17:25:35 +0100 <Inst> or, rather, brain dead guarantees that ensure that code works as it should
2023-11-20 17:25:46 +0100 <Inst> ah, i see
2023-11-20 17:26:11 +0100 <ncf> monad laws are monoid laws in even less of a disguise
2023-11-20 17:26:50 +0100 <Inst> but thinking of monads as just a monoid in the category of burritos is, imo, less useful than thinking about them as guaranteeing braindead behavior and saving probably millions of hours by now of debugging
2023-11-20 17:26:58 +0100 <Inst> because we're not silly enough to have too many unlawful typeclasses
2023-11-20 17:30:28 +0100 <Inst> so, identity law, homomorphism, and interchange with applicative is just monoidal identity laws?
2023-11-20 17:30:48 +0100Simikando(~Simikando@adsl-dyn216.91-127-84.t-com.sk)
2023-11-20 17:31:36 +0100sawilagar(~sawilagar@user/sawilagar) (Quit: Leaving)
2023-11-20 17:31:49 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net)
2023-11-20 17:33:21 +0100 <Inst> and composition is monoidal associativity
2023-11-20 17:34:20 +0100sawilagar(~sawilagar@user/sawilagar)
2023-11-20 17:36:51 +0100vilya(~vilya@user/vilya) (Ping timeout: 256 seconds)
2023-11-20 17:37:11 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net) (Ping timeout: 264 seconds)
2023-11-20 17:38:06 +0100 <ncf> yeah they don't correspond 1:1 but that's roughly it
2023-11-20 17:38:23 +0100vilya(~vilya@user/vilya)
2023-11-20 17:40:02 +0100 <Inst> but still, i'm going by the purscript explanation of the monad slaws, slightly modified
2023-11-20 17:40:07 +0100 <Inst> why would we want these laws to hold?
2023-11-20 17:40:35 +0100 <Inst> Identity basically means "your pure must inject no actual effects"
2023-11-20 17:40:47 +0100 <Inst> or rather the identity effect has to be neutral relative to otther effects
2023-11-20 17:41:15 +0100lortabac(~lorenzo@2a01:e0a:541:b8f0:85bb:2bfd:621:a9d4) (Quit: WeeChat 3.5)
2023-11-20 17:41:16 +0100Luj(~Luj@2a01:e0a:5f9:9681:bd33:ad1d:bf52:f952) (Ping timeout: 255 seconds)
2023-11-20 17:41:45 +0100 <Inst> homomorphism means pures have to be neutral relative to each other, i.e, i'm reading it as pures of applicative values apped together is the same as one pure of the result
2023-11-20 17:42:08 +0100Luj(~Luj@2a01:e0a:5f9:9681:865:6f61:bdb5:3f47)
2023-11-20 17:44:14 +0100 <Inst> interchange means that pure must satisfy both left and right identity laws
2023-11-20 17:44:16 +0100ph88(~ph88@2a02:8109:9e26:c800::302a)
2023-11-20 17:44:43 +0100Simikando(~Simikando@adsl-dyn216.91-127-84.t-com.sk) (Remote host closed the connection)
2023-11-20 17:45:30 +0100Simikando(~Simikando@adsl-dyn216.91-127-84.t-com.sk)
2023-11-20 17:46:57 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net)
2023-11-20 17:47:22 +0100idgaen(~idgaen@2a01:e0a:498:fd50:fcc6:bb5d:489a:ce8c) (Quit: WeeChat 4.1.1)
2023-11-20 17:49:58 +0100dhil(~dhil@2001:8e0:2014:3100:6b2c:5543:96da:7482)
2023-11-20 17:51:58 +0100lortabac(~lorenzo@2a01:e0a:541:b8f0:85bb:2bfd:621:a9d4)
2023-11-20 17:52:04 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net) (Ping timeout: 255 seconds)
2023-11-20 17:52:33 +0100ivelten(~ivelten@2804:82b8:8:ee01:7ceb:5700:d291:7d60)
2023-11-20 17:56:01 +0100zetef(~quassel@95.77.17.251) (Ping timeout: 255 seconds)
2023-11-20 17:56:19 +0100econo_(uid147250@id-147250.tinside.irccloud.com)
2023-11-20 18:05:07 +0100lortabac(~lorenzo@2a01:e0a:541:b8f0:85bb:2bfd:621:a9d4) (Quit: WeeChat 3.5)
2023-11-20 18:05:45 +0100leungbk(~user@2603-8000-1201-2dd2-3eb4-4f01-3467-c066.res6.spectrum.com)
2023-11-20 18:08:21 +0100kiriakos_(~kiriakos@p57b644d2.dip0.t-ipconnect.de)
2023-11-20 18:09:17 +0100kiriakos(~kiriakos@p5b03e17a.dip0.t-ipconnect.de) (Ping timeout: 256 seconds)
2023-11-20 18:09:17 +0100kiriakos_kiriakos
2023-11-20 18:11:33 +0100vilya(~vilya@user/vilya) (Ping timeout: 256 seconds)
2023-11-20 18:11:59 +0100alp_(~alp@2001:861:e3d6:8f80:30:6015:6959:7134) (Ping timeout: 256 seconds)
2023-11-20 18:13:18 +0100vilya(~vilya@user/vilya)
2023-11-20 18:13:35 +0100dtman34(~dtman34@c-76-156-89-180.hsd1.mn.comcast.net) (Ping timeout: 260 seconds)
2023-11-20 18:13:36 +0100alp_(~alp@2001:861:e3d6:8f80:e42:7f5f:7c38:1b67)
2023-11-20 18:18:54 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-11-20 18:19:10 +0100Square(~Square@user/square)
2023-11-20 18:19:49 +0100ThofVe(~ThofVe@178.208.16.70)
2023-11-20 18:20:37 +0100Square2(~Square4@user/square) (Ping timeout: 256 seconds)
2023-11-20 18:26:54 +0100leungbk(~user@2603-8000-1201-2dd2-3eb4-4f01-3467-c066.res6.spectrum.com) (Ping timeout: 268 seconds)
2023-11-20 18:27:31 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 255 seconds)
2023-11-20 18:28:15 +0100euleritian(~euleritia@dynamic-002-247-251-031.2.247.pool.telefonica.de)
2023-11-20 18:28:24 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net)
2023-11-20 18:28:48 +0100euleritian(~euleritia@dynamic-002-247-251-031.2.247.pool.telefonica.de) (Read error: Connection reset by peer)
2023-11-20 18:29:04 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-20 18:29:25 +0100Simikando(~Simikando@adsl-dyn216.91-127-84.t-com.sk) (Ping timeout: 255 seconds)
2023-11-20 18:33:04 +0100Simikando(~Simikando@adsl-dyn216.91-127-84.t-com.sk)
2023-11-20 18:33:28 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net) (Ping timeout: 255 seconds)
2023-11-20 18:33:38 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:19c0:53d0:5da5:a978) (Remote host closed the connection)
2023-11-20 18:39:53 +0100kuribas(~user@ip-188-118-57-242.reverse.destiny.be) (Quit: ERC (IRC client for Emacs 27.1))
2023-11-20 18:43:12 +0100Tuplanolla(~Tuplanoll@91-159-68-236.elisa-laajakaista.fi)
2023-11-20 18:43:12 +0100ThofVe(~ThofVe@178.208.16.70) (Ping timeout: 250 seconds)
2023-11-20 18:44:35 +0100tzh(~tzh@c-71-193-181-0.hsd1.or.comcast.net)
2023-11-20 18:48:24 +0100axeman(~quassel@ip5b40ac1e.dynamic.kabel-deutschland.de)
2023-11-20 18:53:59 +0100target_i(~target_i@217.175.14.39)
2023-11-20 18:58:25 +0100fweht(uid404746@id-404746.lymington.irccloud.com)
2023-11-20 18:59:34 +0100Simikando(~Simikando@adsl-dyn216.91-127-84.t-com.sk) (Ping timeout: 255 seconds)
2023-11-20 18:59:45 +0100gmg(~user@user/gehmehgeh)
2023-11-20 19:00:13 +0100danse-nr3(~danse@151.57.151.166) (Read error: Connection reset by peer)
2023-11-20 19:01:18 +0100dtman34(~dtman34@c-76-156-89-180.hsd1.mn.comcast.net)
2023-11-20 19:07:06 +0100ivelten(~ivelten@2804:82b8:8:ee01:7ceb:5700:d291:7d60) (Quit: Textual IRC Client: www.textualapp.com)
2023-11-20 19:07:29 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:19c0:53d0:5da5:a978)
2023-11-20 19:08:07 +0100Simikando(~Simikando@adsl-dyn216.91-127-84.t-com.sk)
2023-11-20 19:10:19 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:19c0:53d0:5da5:a978) (Remote host closed the connection)
2023-11-20 19:10:33 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:19c0:53d0:5da5:a978)
2023-11-20 19:13:44 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net)
2023-11-20 19:14:14 +0100danse-nr3(~danse@151.57.168.105)
2023-11-20 19:16:04 +0100lisbeths(uid135845@id-135845.lymington.irccloud.com) (Quit: Connection closed for inactivity)
2023-11-20 19:18:59 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net) (Ping timeout: 256 seconds)
2023-11-20 19:19:16 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-11-20 19:23:31 +0100 <dminuoso_> Haskell wins again. I really enjoy the type separations in the `time` library. It forces you to consider timezones in a rather appropriate way, down to things like ZonedTime not having an Eq instance.
2023-11-20 19:24:20 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Read error: Connection reset by peer)
2023-11-20 19:24:49 +0100 <dminuoso_> Though I kind of wish there was an ISO8601 type, a kind of MaybeZonedTime.
2023-11-20 19:24:49 +0100 <monochrom> Not having Eq is a bit extremeist though...
2023-11-20 19:25:04 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-20 19:25:45 +0100 <dminuoso_> Which behavior is the right Eq though? Extensional? Intensional?
2023-11-20 19:26:06 +0100 <dminuoso_> No matter how long I think about it, I wouldnt know which one will upset people less.
2023-11-20 19:26:15 +0100szkl(uid110435@id-110435.uxbridge.irccloud.com)
2023-11-20 19:31:32 +0100Arsen(arsen@gentoo/developer/managarm.dev.Arsen) (Read error: Connection reset by peer)
2023-11-20 19:31:50 +0100Arsen(arsen@gentoo/developer/managarm.dev.Arsen)
2023-11-20 19:33:43 +0100danse-nr3(~danse@151.57.168.105) (Ping timeout: 256 seconds)
2023-11-20 19:34:16 +0100 <opqdonut> doesn't something like the new java time API have those same distinctions though?
2023-11-20 19:35:39 +0100 <dminuoso_> Yeah, it has a very comparable API
2023-11-20 19:38:37 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 255 seconds)
2023-11-20 19:39:22 +0100euleritian(~euleritia@dynamic-002-247-251-031.2.247.pool.telefonica.de)
2023-11-20 19:40:06 +0100simendsjo(~user@84.209.170.3)
2023-11-20 19:40:46 +0100euleritian(~euleritia@dynamic-002-247-251-031.2.247.pool.telefonica.de) (Read error: Connection reset by peer)
2023-11-20 19:41:03 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de)
2023-11-20 19:43:31 +0100sawilagar(~sawilagar@user/sawilagar) (Ping timeout: 276 seconds)
2023-11-20 19:45:38 +0100euleritian(~euleritia@ip4d16fc38.dynamic.kabel-deutschland.de) (Ping timeout: 260 seconds)
2023-11-20 19:45:55 +0100euleritian(~euleritia@dynamic-002-247-251-031.2.247.pool.telefonica.de)
2023-11-20 19:46:47 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net) (Ping timeout: 264 seconds)
2023-11-20 19:49:06 +0100danza(~francesco@151.57.168.105)
2023-11-20 19:53:26 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net)
2023-11-20 19:58:01 +0100L29Ah(~L29Ah@wikipedia/L29Ah) ()
2023-11-20 19:58:47 +0100nate4(~nate@c-98-45-158-125.hsd1.ca.comcast.net) (Ping timeout: 264 seconds)
2023-11-20 20:08:00 +0100_xor(~xor@72.49.195.41) (Quit: Ping timeout (120 seconds))
2023-11-20 20:08:40 +0100_xor(~xor@72.49.195.41)
2023-11-20 20:10:28 +0100alp_(~alp@2001:861:e3d6:8f80:e42:7f5f:7c38:1b67) (Ping timeout: 256 seconds)
2023-11-20 20:13:41 +0100JuanDaugherty(~juan@user/JuanDaugherty)
2023-11-20 20:18:09 +0100_xor8(~xor@72.49.195.41)
2023-11-20 20:19:55 +0100ezzieyguywuf(~Unknown@user/ezzieyguywuf) (Ping timeout: 276 seconds)
2023-11-20 20:20:01 +0100_xor(~xor@72.49.195.41) (Ping timeout: 255 seconds)
2023-11-20 20:20:01 +0100_xor8_xor
2023-11-20 20:21:12 +0100ezzieyguywuf(~Unknown@user/ezzieyguywuf)
2023-11-20 20:23:25 +0100waleee(~waleee@h-176-10-144-38.NA.cust.bahnhof.se)
2023-11-20 20:25:14 +0100chele(~chele@user/chele) (Remote host closed the connection)
2023-11-20 20:27:09 +0100_xor(~xor@72.49.195.41) (Read error: Connection reset by peer)
2023-11-20 20:27:33 +0100Pickchea(~private@user/pickchea)
2023-11-20 20:27:59 +0100_xor(~xor@72.49.195.41)
2023-11-20 20:29:01 +0100swamp_(~zmt00@user/zmt00)
2023-11-20 20:29:10 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:19c0:53d0:5da5:a978) (Remote host closed the connection)
2023-11-20 20:31:01 +0100alp_(~alp@2001:861:e3d6:8f80:b67b:de87:7872:e69f)
2023-11-20 20:31:23 +0100Simikando(~Simikando@adsl-dyn216.91-127-84.t-com.sk) (Ping timeout: 256 seconds)
2023-11-20 20:33:04 +0100_xor(~xor@72.49.195.41) (Ping timeout: 255 seconds)
2023-11-20 20:33:07 +0100zmt01(~zmt00@user/zmt00) (Ping timeout: 260 seconds)
2023-11-20 20:33:12 +0100_xor(~xor@72.49.195.41)
2023-11-20 20:33:15 +0100sord937(~sord937@gateway/tor-sasl/sord937) (Quit: sord937)
2023-11-20 20:51:50 +0100vilya(~vilya@user/vilya) (Ping timeout: 256 seconds)
2023-11-20 20:53:22 +0100vilya(~vilya@user/vilya)
2023-11-20 20:53:31 +0100target_i(~target_i@217.175.14.39) (Quit: leaving)
2023-11-20 20:54:27 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-11-20 20:55:38 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl)
2023-11-20 20:57:23 +0100fendor(~fendor@2a02:8388:1640:be00:8705:c56:c793:802b) (Remote host closed the connection)
2023-11-20 21:01:26 +0100 <zzz> what does the "unwords" mean when i do :t unwords in ghci and get: unwords :: Relude.String.Reexport.IsText t "unwords" => [t] -> t
2023-11-20 21:02:00 +0100 <monochrom> :(
2023-11-20 21:02:46 +0100 <monochrom> That is a type-level string literal. The jargon in the manuals (GHC's and library's) is "[type-level] symbol".
2023-11-20 21:03:26 +0100 <zzz> monochrom: ty
2023-11-20 21:03:29 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:19c0:53d0:5da5:a978)
2023-11-20 21:03:33 +0100 <monochrom> "symbol" can be the right wording because we don't have any type-level string operations. So all you can do is use them as labels.
2023-11-20 21:03:54 +0100 <geekosaur> as for what it's doing there, you probably need to ask a Relude developer
2023-11-20 21:04:16 +0100 <monochrom> E.g., sometimes someone asks "can I ++ them at the type level?" Answer: Nah, don't hold your breath. :)
2023-11-20 21:04:46 +0100 <tomsmeding> https://hackage.haskell.org/package/relude-1.2.1.0/docs/src/Relude.String.Reexport.html#IsText
2023-11-20 21:04:57 +0100 <geekosaur> hm, I thought there were some type families for that these days
2023-11-20 21:05:25 +0100 <kaol> Is there an extension that'd let me define something like "foo Int = 1; foo Char = 2"?
2023-11-20 21:05:39 +0100 <geekosaur> not yet
2023-11-20 21:05:44 +0100 <tomsmeding> it's a type class that forces t ~ Text, but gives a derogatory error message if you use String instead
2023-11-20 21:06:21 +0100 <zzz> geekosaur: yet?
2023-11-20 21:06:26 +0100 <zzz> how many languages is Haskell?
2023-11-20 21:06:58 +0100 <geekosaur> there is work on Dependent Haskell, slowly
2023-11-20 21:07:09 +0100 <kaol> I guess full blown dependent types could give this. Though don't ask me, I just read that somewhere.
2023-11-20 21:07:23 +0100 <zzz> ah i didn't know that
2023-11-20 21:08:18 +0100 <geekosaur> anyway I think `forall a ->` went into 9.8 but it's still somewhat limited
2023-11-20 21:08:43 +0100 <monochrom> Do you mind a class with method foo :: Proxy a -> Int? Then the Int instance can give 1, the Char instance can give 2.
2023-11-20 21:09:58 +0100 <kaol> I still have a fair bit to go before I'll yet need to tackle this thing.
2023-11-20 21:10:28 +0100 <tomsmeding> using AllowAmbiguousTypes, TypeApplications and Typeable (eqTypeRep) you can get a bit closer
2023-11-20 21:10:34 +0100simendsjo(~user@84.209.170.3) (Ping timeout: 260 seconds)
2023-11-20 21:10:38 +0100 <tomsmeding> but that's kind of ugly
2023-11-20 21:11:12 +0100 <tomsmeding> (i.e. only use that if you're playing around anyway)
2023-11-20 21:11:45 +0100akegalj(~akegalj@78-1-185-234.adsl.net.t-com.hr) (Quit: leaving)
2023-11-20 21:13:48 +0100 <monochrom> Does Agda allow that? Because Lean doesn't.
2023-11-20 21:15:10 +0100 <ncf> allow what?
2023-11-20 21:15:28 +0100 <monochrom> foo Int = 1; foo Char = 2. Or simpler: foo Int = 1; foo _ = 2
2023-11-20 21:16:06 +0100 <ncf> there's no type case, but you can define an inductive-recursive universe with Int and Char in it
2023-11-20 21:18:21 +0100 <ncf> well you can emulate something like that with a type class i guess
2023-11-20 21:19:07 +0100notzmv(~zmv@user/notzmv) (Ping timeout: 256 seconds)
2023-11-20 21:19:35 +0100 <monochrom> Yeah, it's Type->Value, seems to be type classes. Dependent typing is Value->Type.
2023-11-20 21:20:09 +0100motherfsck(~motherfsc@user/motherfsck) (Read error: Connection reset by peer)
2023-11-20 21:21:38 +0100 <Lycurgus> is there a workaround/fix for ghcup leaving the font of the footer, polluting the shell?
2023-11-20 21:23:29 +0100 <monochrom> I don't have that problem. But most terminals have a "reset".
2023-11-20 21:23:40 +0100 <Lycurgus> nvm, toggling the font does it
2023-11-20 21:23:56 +0100 <johnw> I've never seen that issue either
2023-11-20 21:23:59 +0100 <Lycurgus> (in xterm)
2023-11-20 21:24:40 +0100 <Lycurgus> it may have something to do with the fact I run thru vnc
2023-11-20 21:24:54 +0100 <johnw> layers upon layers
2023-11-20 21:25:01 +0100 <Lycurgus> but found an effective and quick fix so i'm good
2023-11-20 21:25:16 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Ping timeout: 255 seconds)
2023-11-20 21:25:20 +0100 <zzz> some ssh wrappers tend to mess stuff up like that
2023-11-20 21:25:30 +0100dhil(~dhil@2001:8e0:2014:3100:6b2c:5543:96da:7482) (Ping timeout: 260 seconds)
2023-11-20 21:27:33 +0100 <Lycurgus> vnc does encrypt so ... .
2023-11-20 21:30:25 +0100Jackneill(~Jackneill@20014C4E1E1AA20094762E075B8F16EC.dsl.pool.telekom.hu)
2023-11-20 21:31:25 +0100JuanDaugherty(~juan@user/JuanDaugherty) (Quit: JuanDaugherty)
2023-11-20 21:32:11 +0100Pickchea(~private@user/pickchea) (Quit: Leaving)
2023-11-20 21:33:00 +0100 <ski> `ghcup' changes font setting ?
2023-11-20 21:33:08 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:19c0:53d0:5da5:a978) (Ping timeout: 268 seconds)
2023-11-20 21:33:42 +0100 <ski> (not color, or markup like bold,underlined,inverse,italic, then ?)
2023-11-20 21:33:48 +0100L29Ah(~L29Ah@wikipedia/L29Ah)
2023-11-20 21:33:57 +0100johnw(~johnw@69.62.242.138) (Quit: ZNC - http://znc.in)
2023-11-20 21:34:24 +0100johnw(~johnw@69.62.242.138)
2023-11-20 21:34:29 +0100 <Lycurgus> no, it just leaves the slant font of footer legend as the shell font
2023-11-20 21:34:40 +0100 <Lycurgus> after tui display
2023-11-20 21:35:02 +0100 <ski> slat sounds like italic, to me
2023-11-20 21:35:07 +0100 <ski> slant
2023-11-20 21:35:14 +0100 <Lycurgus> right that
2023-11-20 21:35:47 +0100 <ski> `tput sgr0' would probably reset it
2023-11-20 21:36:43 +0100 <Lycurgus> it does not
2023-11-20 21:37:18 +0100 <Lycurgus> but selecting or deselecting true type does
2023-11-20 21:38:20 +0100motherfsck(~motherfsc@user/motherfsck)
2023-11-20 21:39:46 +0100 <ski> hm, how about
2023-11-20 21:40:10 +0100 <ski> $ printf '\033[23m'
2023-11-20 21:40:11 +0100 <ski> ?
2023-11-20 21:40:34 +0100 <Lycurgus> prolly not i use that in a script but checking
2023-11-20 21:40:58 +0100 <ski> (or '\e' instead of `\033')
2023-11-20 21:41:59 +0100 <Lycurgus> nope
2023-11-20 21:43:41 +0100maaz(~maaz@bras-base-hspron0502w-grc-02-184-147-203-180.dsl.bell.ca)
2023-11-20 21:43:42 +0100 <ski> what terminal ?
2023-11-20 21:44:07 +0100maazm257
2023-11-20 21:44:11 +0100 <Lycurgus> xterm
2023-11-20 21:44:13 +0100 <ski> using any terminal multiplexer ?
2023-11-20 21:44:20 +0100 <Lycurgus> no
2023-11-20 21:44:25 +0100 <ski> $ printf '\e]50;#0\a'
2023-11-20 21:44:33 +0100 <ski> that changes font (not markup) to default, here
2023-11-20 21:45:12 +0100 <Lycurgus> nope
2023-11-20 21:45:19 +0100 <ski> with `1'-'7' in place of `0', it changes to other fonts, in the "VT Fonts" menu (`C-mouse2')
2023-11-20 21:45:28 +0100 <ski> (also using XTerm)
2023-11-20 21:45:31 +0100 <Lycurgus> but I am happy with just toggling true type to clear it
2023-11-20 21:48:24 +0100 <Lycurgus> any action in the VT menu resets it
2023-11-20 21:48:40 +0100 <ski> hm, i see no escape sequence to toggle "TrueType Fonts"
2023-11-20 21:49:09 +0100 <ski> hm, a control
2023-11-20 21:49:45 +0100 <Lycurgus> well it's ctrl right click in xterm to show the menu
2023-11-20 21:50:03 +0100 <Lycurgus> as fast as typing a cmd
2023-11-20 21:51:05 +0100 <ski> $ printf '\e[31mfoo\e[1mbar\e[22;32;4mbaz\e[24mquux\e[39m\n'
2023-11-20 21:51:19 +0100 <ski> does that display with some color, and bold resp. underlined ?
2023-11-20 21:53:28 +0100 <Lycurgus> yes (in an instance where ghcup tui hadn been run)
2023-11-20 21:53:49 +0100 <Lycurgus> as well as one where it had
2023-11-20 21:54:05 +0100 <ski> ok (checking that you're not running some other version of 'printf' or shell with it, where `\e' isn't supported or something)
2023-11-20 21:54:06 +0100 <Lycurgus> it's a pretty clear bug
2023-11-20 21:54:16 +0100 <Lycurgus> has been there since first use
2023-11-20 21:54:40 +0100 <ski> does `ghcup' set/change the font, while running ? or just at the end, when exiting ?
2023-11-20 21:54:44 +0100 <Lycurgus> clear/classic did restore a mode
2023-11-20 21:54:52 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2023-11-20 21:55:10 +0100 <Lycurgus> well it's gotta set the slant font for the footer
2023-11-20 21:55:21 +0100 <ski> mhm, ic
2023-11-20 21:55:27 +0100 <Lycurgus> *didn restore
2023-11-20 21:58:15 +0100 <ski> $ infocmp -1 | grep -e rs1 -e rs2 -e rf -e rs3 -e iprog -e is1 -e is2 -e if -e is3
2023-11-20 21:58:20 +0100 <ski> displays anything for you ?
2023-11-20 21:58:49 +0100 <Lycurgus> is2=\E[!p\E[?3;4l\E[4l\E>,
2023-11-20 21:58:49 +0100 <Lycurgus> rs1=\Ec,
2023-11-20 21:58:50 +0100 <Lycurgus> rs2=\E[!p\E[?3;4l\E[4l\E>,
2023-11-20 21:59:18 +0100 <Lycurgus> (in a state corrupted by the bug)
2023-11-20 21:59:21 +0100Inst(~Inst@120.244.192.250) (Ping timeout: 256 seconds)
2023-11-20 21:59:48 +0100 <Lycurgus> as well as after a reset
2023-11-20 22:00:03 +0100 <mauke> infocmp shouldn't be affected by terminal state; it reads static files
2023-11-20 22:00:33 +0100 <Lycurgus> that's not the response you expected?
2023-11-20 22:01:26 +0100 <ski> hm, those escape sequences look reasonable, i guess
2023-11-20 22:01:31 +0100 <ski> did you try
2023-11-20 22:01:37 +0100 <ski> $ printf '\e]50;#0\a'
2023-11-20 22:01:43 +0100 <ski> with `1' through `7' in place of `0' ?
2023-11-20 22:01:50 +0100 <Lycurgus> wait gotta tui
2023-11-20 22:02:28 +0100 <ski> mauke : yea, checking what `reset' would do
2023-11-20 22:03:05 +0100 <ski> i guess
2023-11-20 22:03:14 +0100 <ski> $ infocmp -1 | grep -e sitm -e ritm
2023-11-20 22:03:16 +0100 <ski> shows nothing
2023-11-20 22:03:39 +0100 <ski> (those are the terminfo capability names for turning on and off italic/slant)
2023-11-20 22:03:50 +0100 <ski> hm, guess one could also double check with
2023-11-20 22:03:59 +0100 <Lycurgus> did 8X (0-7) no effect
2023-11-20 22:04:42 +0100 <ski> $ printf '\e[31mfoo\e[3mbar\e[32mbaz\e[23mquux\e[39m\n'
2023-11-20 22:04:49 +0100 <ski> hm, curious
2023-11-20 22:04:56 +0100 <Lycurgus> ritm=\E[23m,
2023-11-20 22:04:56 +0100 <Lycurgus> sitm=\E[3m,
2023-11-20 22:05:02 +0100 <ski> ah .. ok
2023-11-20 22:05:08 +0100 <geekosaur> long shot: what's your window manager? (more to the point: is it tiling?)
2023-11-20 22:05:48 +0100 <ski> hm, "did 8X (0-7) no effect" -- with out without "TrueType Font" enabled ?
2023-11-20 22:06:00 +0100 <ski> s/out /or /
2023-11-20 22:06:05 +0100 <Lycurgus> well the whole shebang is after boot I go to tty outside of the gui and start vncserver with fvwm as the wm
2023-11-20 22:06:17 +0100 <geekosaur> some versions of xterm aren't smart enough to clear parts of the window outside its scrolling area as set by the expected aspect ratio, and with e.g. xmonad you need to use the LayoutHints layout modifier to make it work
2023-11-20 22:06:25 +0100 <ski> ah, fvwm :)
2023-11-20 22:06:27 +0100 <geekosaur> okay, fvwm isn't tiling
2023-11-20 22:06:34 +0100 <Lycurgus> then I go back to ubuntu/unity and start stumpwm (used to use xmonad)
2023-11-20 22:06:35 +0100mima(~mmh@aftr-62-216-211-62.dynamic.mnet-online.de) (Ping timeout: 264 seconds)
2023-11-20 22:07:02 +0100 <Lycurgus> then i start a shell in stump and connect to the vnc
2023-11-20 22:07:17 +0100 <ski> Lycurgus : do you get italic/slant with last `printf' above ?
2023-11-20 22:07:25 +0100 <ski> (i'd imagine so, just double-checking)
2023-11-20 22:08:02 +0100 <Lycurgus> ski, yes
2023-11-20 22:08:09 +0100 <ski> (`xmonad' uses `stumpwm' !?)
2023-11-20 22:08:15 +0100 <ski> mm, good
2023-11-20 22:08:22 +0100 <Lycurgus> sry, n
2023-11-20 22:08:25 +0100zetef(~quassel@95.77.17.251)
2023-11-20 22:08:31 +0100 <geekosaur> I read that as they switched from xmonad to stumpwm
2023-11-20 22:08:31 +0100 <Lycurgus> foobarbazquux not slanted
2023-11-20 22:08:40 +0100 <ski> <ski> $ printf '\033[23m'
2023-11-20 22:08:43 +0100 <ski> what about
2023-11-20 22:08:50 +0100 <ski> $ printf '\0e[23m'
2023-11-20 22:08:53 +0100 <ski> er
2023-11-20 22:08:54 +0100 <Lycurgus> yeah i switched from xmonad to stump
2023-11-20 22:08:55 +0100 <ski> $ printf '\e[23m'
2023-11-20 22:09:12 +0100 <ski> Lycurgus : oh
2023-11-20 22:09:19 +0100 <Lycurgus> oh but i had cleared the slant
2023-11-20 22:09:31 +0100_ht(~Thunderbi@28-52-174-82.ftth.glasoperator.nl) (Remote host closed the connection)
2023-11-20 22:10:23 +0100 <Lycurgus> when i tui foobarbaz is slanted but quux isn
2023-11-20 22:10:54 +0100 <ski> well, "barbaz" ought to be slanted, but not "foo" nor "quux"
2023-11-20 22:11:48 +0100 <Lycurgus> right, rechecked only barbaz slants
2023-11-20 22:11:54 +0100 <ski> ye
2023-11-20 22:12:32 +0100 <ski> and .. the last `printf' above, after `ghcup' ?
2023-11-20 22:13:14 +0100 <Lycurgus> repeat it to be clear
2023-11-20 22:13:21 +0100 <ski> $ printf '\e[23m'
2023-11-20 22:14:14 +0100 <ski> (`tput ritm' ought to be equivalent)
2023-11-20 22:14:19 +0100zetef(~quassel@95.77.17.251) (Ping timeout: 255 seconds)
2023-11-20 22:14:33 +0100 <Lycurgus> no effect after tui
2023-11-20 22:14:35 +0100zetef(~quassel@5.2.182.98)
2023-11-20 22:14:47 +0100 <Lycurgus> (i.e. slant persists)
2023-11-20 22:14:47 +0100 <ski> strange
2023-11-20 22:14:56 +0100 <Lycurgus> i think we better drop this
2023-11-20 22:15:01 +0100trev(~trev@user/trev) (Quit: trev)
2023-11-20 22:15:06 +0100 <ski> does `ghcup' somehow change the "TrueType Fonts" state ?
2023-11-20 22:15:08 +0100alp_(~alp@2001:861:e3d6:8f80:b67b:de87:7872:e69f) (Ping timeout: 256 seconds)
2023-11-20 22:15:13 +0100 <ski> also, you didn't answer
2023-11-20 22:15:19 +0100 <ski> <ski> hm, "did 8X (0-7) no effect" -- with out without "TrueType Font" enabled ?
2023-11-20 22:15:40 +0100elkcl(~elkcl@broadband-95-84-226-240.ip.moscow.rt.ru) (Ping timeout: 255 seconds)
2023-11-20 22:15:42 +0100 <Lycurgus> the underlying truth is that minor bugs are let go, it's a judicious use of resources
2023-11-20 22:15:51 +0100 <ski> mhm
2023-11-20 22:16:42 +0100 <Lycurgus> right i retrieved the command 7x without intervening ghcup
2023-11-20 22:16:49 +0100 <ski> yes
2023-11-20 22:17:07 +0100 <ski> and "TrueType Fonts" was off, at that time ?
2023-11-20 22:17:15 +0100 <Lycurgus> yeah
2023-11-20 22:17:26 +0100 <ski> ok .. i dunno
2023-11-20 22:17:59 +0100 <Lycurgus> i'd bet money it's what I said
2023-11-20 22:19:12 +0100 <ski> (well, perhaps you only have one (non TrueType) font configured or something. perhaps manyally changing VT Fonts (Default,Unreadable,Tiny,Small,Medium,Large,Huge,Enormous) doesn't actually change font, either, for you)
2023-11-20 22:19:25 +0100 <ski> "what I said" -- being ?
2023-11-20 22:19:51 +0100 <Lycurgus> well that can't be true because I can set different size TT fonts
2023-11-20 22:20:28 +0100 <Lycurgus> what I said was that the bug will turn out to be the entering state of the term wasn restored
2023-11-20 22:20:40 +0100 <Lycurgus> after the slant was set
2023-11-20 22:20:41 +0100 <ski> mm, those probably wouldn't be conrolled by `\]50;#0\ª' and friends
2023-11-20 22:20:44 +0100 <ski> , though
2023-11-20 22:21:27 +0100 <ski> $ infocmp -1 | grep -e sgr
2023-11-20 22:21:36 +0100 <ski> does that display an `sgr0' entry ?
2023-11-20 22:22:31 +0100 <ski> (er, i meant `\]50;#0]a', just before)
2023-11-20 22:22:37 +0100 <Lycurgus> i will try that and respond in #haskell-offtopic
2023-11-20 22:22:41 +0100 <ski> `sgr0' is supposed to reset the color and markup
2023-11-20 22:22:53 +0100 <ski> ok
2023-11-20 22:23:49 +0100takuan(~takuan@178-116-218-225.access.telenet.be) (Remote host closed the connection)
2023-11-20 22:25:32 +0100elkcl(~elkcl@broadband-95-84-226-240.ip.moscow.rt.ru)
2023-11-20 22:35:59 +0100misterfish(~misterfis@84-53-85-146.bbserv.nl) (Ping timeout: 264 seconds)
2023-11-20 22:43:16 +0100hc(~hc@mail.hce.li) (Remote host closed the connection)
2023-11-20 22:50:20 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de) (Quit: ZNC - https://znc.in)
2023-11-20 22:53:21 +0100alp_(~alp@2001:861:e3d6:8f80:3e0c:4d1b:db32:9e54)
2023-11-20 22:54:09 +0100todi(~todi@p4fd1a3e6.dip0.t-ipconnect.de)
2023-11-20 22:54:49 +0100machinedgod(~machinedg@d198-53-218-113.abhsia.telus.net)
2023-11-20 22:58:24 +0100Square2(~Square4@user/square)
2023-11-20 22:58:43 +0100hc(~hc@mail.hce.li)
2023-11-20 22:58:46 +0100Square(~Square@user/square) (Ping timeout: 256 seconds)
2023-11-20 23:00:11 +0100tromp(~textual@92-110-219-57.cable.dynamic.v4.ziggo.nl) (Quit: My iMac has gone to sleep. ZZZzzz…)
2023-11-20 23:03:43 +0100danza(~francesco@151.57.168.105) (Ping timeout: 276 seconds)
2023-11-20 23:08:47 +0100 <Lycurgus> fwiw channel, it turned out to be the window manager
2023-11-20 23:10:48 +0100 <int-e> that's odd, it shouldn't be involved... but I *would* compare the output of `env`.
2023-11-20 23:11:03 +0100 <int-e> or, at least, `locale`
2023-11-20 23:11:25 +0100Guest97(~Guest97@2a01:e0a:d5d:c580:4526:81bd:b54d:9149)
2023-11-20 23:11:35 +0100 <int-e> ah dang, but you'd need to capture that before the shell starts modifying the environment
2023-11-20 23:13:12 +0100Guest97(~Guest97@2a01:e0a:d5d:c580:4526:81bd:b54d:9149) ()
2023-11-20 23:14:15 +0100 <ski> `env' ? not `setenv' ?
2023-11-20 23:15:33 +0100 <int-e> This, maybe? < /proc/$PPID/environ tr '\0' '\n' ...assuming $PPID is actually the terminal.
2023-11-20 23:15:55 +0100 <int-e> ski: `env` without arguments prints environment variables
2023-11-20 23:15:56 +0100ft(~ft@p508db3bc.dip0.t-ipconnect.de)
2023-11-20 23:17:26 +0100 <ski> oh .. guess i never tried using it like that
2023-11-20 23:17:44 +0100 <ski> (also, i meant `printenv', not `setenv' ..)
2023-11-20 23:20:47 +0100 <monochrom> :) I put this on an exam: Why I used printenv instead of echo in the previous part? With the previous part having an envvar set to something that contains \a etc.
2023-11-20 23:22:04 +0100 <mauke> TIL about printenv
2023-11-20 23:22:39 +0100 <mauke> I can honestly say I can't imagine a situation where I'd ever use it
2023-11-20 23:24:10 +0100 <monochrom> Sure, I had to contrive a back story to justify having \a at all. (Hint: This envvar follows the Windows PATH convention. >:) )
2023-11-20 23:25:07 +0100internatetional(~nate@2001:448a:20a3:c2e5:71b9:a710:2866:667f)
2023-11-20 23:25:13 +0100 <mauke> wat
2023-11-20 23:25:18 +0100 <geekosaur> printenv dates back to csh days
2023-11-20 23:25:32 +0100 <mauke> what's the issue with \a?
2023-11-20 23:25:36 +0100 <monochrom> In bash there are also options to tell echo to not interpret \ . However, in my course, I stick to very barebone sh.
2023-11-20 23:25:40 +0100 <ski> rings the bell
2023-11-20 23:25:57 +0100 <monochrom> echo interprets \ codes by default.
2023-11-20 23:26:00 +0100 <mauke> are we talking about a literal control character or backslash a?
2023-11-20 23:26:06 +0100 <mauke> monochrom: no, it doesn't
2023-11-20 23:26:17 +0100 <geekosaur> backslash a is "alarm" / ASCII 7
2023-11-20 23:26:19 +0100 <probie> mauke: I've found it useful when I know the value of the environment variable that's breaking things, but don't know _which_ environment variable it is, which I think has come up for me about twice
2023-11-20 23:26:22 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net) (Ping timeout: 260 seconds)
2023-11-20 23:26:24 +0100internatetional(~nate@2001:448a:20a3:c2e5:71b9:a710:2866:667f) (Client Quit)
2023-11-20 23:26:33 +0100 <mauke> probie: that's just env
2023-11-20 23:26:37 +0100 <mauke> | grep
2023-11-20 23:26:37 +0100internatetional(~nate@2001:448a:20a3:c2e5:71b9:a710:2866:667f)
2023-11-20 23:27:02 +0100 <ski> talking about backslash a, i think
2023-11-20 23:27:25 +0100 <geekosaur> (env was introduced by UNIX System III, so 2.x/4.xBSD didn't have it)
2023-11-20 23:27:32 +0100 <mauke> $ echo '\a'
2023-11-20 23:27:32 +0100 <mauke> \a
2023-11-20 23:27:34 +0100 <monochrom> Put it this way. printenv and env outputs literally \a
2023-11-20 23:28:13 +0100 <ski> the issue would be something like `C:\foobar\aardvark'
2023-11-20 23:28:25 +0100 <int-e> monochrom: which horrible shell are you using that has this broken `echo` builtin
2023-11-20 23:28:30 +0100 <monochrom> Also, I teach barebone sh, so try it on sh? I certainly tested it before setting it as an exam question.
2023-11-20 23:28:51 +0100 <int-e> dash?
2023-11-20 23:28:55 +0100 <monochrom> Yeah
2023-11-20 23:29:01 +0100 <int-e> ewww
2023-11-20 23:29:40 +0100 <mauke> ok, why would you ever use dash interactively?
2023-11-20 23:29:42 +0100 <monochrom> Here is my excuse. I want to ban <(cmd). I want students to learn cmd1 | cmd2.
2023-11-20 23:30:00 +0100 <int-e> why
2023-11-20 23:30:16 +0100 <mauke> point-free style :-)
2023-11-20 23:30:19 +0100 <ski> simpler solutions over more complicated ones ?
2023-11-20 23:30:22 +0100 <monochrom> They need to learn cmd1 | cmd2.
2023-11-20 23:30:23 +0100 <int-e> those aren't even interchangeable, they serve different though related purposes
2023-11-20 23:30:30 +0100 <mauke> true
2023-11-20 23:30:49 +0100 <int-e> do you prefer `cmd < foo` or `< foo cmd`
2023-11-20 23:30:49 +0100 <ski> but somewhat overlapping, for commands that can both take a path, and stdin
2023-11-20 23:30:55 +0100skiuses both
2023-11-20 23:31:11 +0100 <monochrom> If I allow bash, they just copy code from the Internet and use <(cmd)
2023-11-20 23:31:12 +0100 <ski> (the latter, usually, with pipelines)
2023-11-20 23:31:36 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:19c0:53d0:5da5:a978)
2023-11-20 23:31:37 +0100 <mauke> what kind of internet are you guys using?!
2023-11-20 23:32:01 +0100 <monochrom> ... in the context of for example using sort so cmd1 | sort can also be done with sort <(cmd1) for example.
2023-11-20 23:32:03 +0100 <ski> monochrom : i guess they'll soon ask GPT to solve it for them ?
2023-11-20 23:32:12 +0100notzmv(~zmv@user/notzmv)
2023-11-20 23:32:16 +0100 <ski> right
2023-11-20 23:32:31 +0100 <ski> int-e : why ?
2023-11-20 23:33:08 +0100 <geekosaur> I only use `< foo cmd` to annoy people 🙂
2023-11-20 23:33:10 +0100 <int-e> ski: the preference? just curiosity. I also use both.
2023-11-20 23:33:19 +0100 <mauke> printf '%s\n' "$var" # works in dash
2023-11-20 23:33:21 +0100 <int-e> I tend to use < foo cmd in longer pipes
2023-11-20 23:33:57 +0100 <ski> right, ditto
2023-11-20 23:34:00 +0100 <int-e> mauke: you could also use /bin/echo :)
2023-11-20 23:34:10 +0100 <ski> otherwise, my default is 'cmd < foo'
2023-11-20 23:34:31 +0100 <mauke> int-e: not if var=-n :-)
2023-11-20 23:34:48 +0100 <int-e> true
2023-11-20 23:34:49 +0100 <ski> shells are so much fun
2023-11-20 23:35:09 +0100 <int-e> mauke: tbf I had \a in mind specifically
2023-11-20 23:41:25 +0100eggplantade(~Eggplanta@2600:1700:38c5:d800:19c0:53d0:5da5:a978) (Ping timeout: 276 seconds)
2023-11-20 23:46:37 +0100son0p(~ff@181.136.122.143)
2023-11-20 23:46:42 +0100dcoutts(~duncan@cpc69402-oxfd27-2-0-cust903.4-3.cable.virginm.net)
2023-11-20 23:49:52 +0100acidjnk(~acidjnk@p200300d6e72b9333e0d3f8384e141d02.dip0.t-ipconnect.de) (Ping timeout: 276 seconds)
2023-11-20 23:50:09 +0100 <duncan> ski: but there's no dtrace monad
2023-11-20 23:55:21 +0100 <ski> ?
2023-11-20 23:59:25 +0100gmg(~user@user/gehmehgeh) (Quit: Leaving)