←2020-02-07 2020-02-08 2020-02-09→ ↑2020 ↑all
00:07:11 -!- Phantom_Hoover has quit (Ping timeout: 260 seconds).
00:33:55 -!- Lord_of_Life_ has joined.
00:36:01 -!- Lord_of_Life has quit (Ping timeout: 268 seconds).
00:36:48 -!- Lord_of_Life_ has changed nick to Lord_of_Life.
00:38:19 -!- imode has joined.
00:40:35 -!- oerjan has joined.
00:45:58 -!- imode has quit (Ping timeout: 256 seconds).
02:20:31 <oerjan> iirc the Very Galactic Array in schlock observes ordinary slow light, i'm not sure how that'll help here...
02:34:19 <esowiki> [[User talk:A]] https://esolangs.org/w/index.php?diff=69632&oldid=69583 * A * (-22531) What's the matter with all the zalgo!?
02:36:21 <esowiki> [[User talk:A]] https://esolangs.org/w/index.php?diff=69633&oldid=69632 * A * (+81)
02:36:59 <esowiki> [[User talk:A]] https://esolangs.org/w/index.php?diff=69634&oldid=69633 * A * (+22533)
02:38:23 <esowiki> [[User talk:A]] https://esolangs.org/w/index.php?diff=69635&oldid=69634 * A * (+160)
02:56:28 -!- imode has joined.
03:00:57 <esowiki> [[User talk:A]] https://esolangs.org/w/index.php?diff=69636&oldid=69635 * A * (+110)
03:04:20 <esowiki> [[User talk:A]] https://esolangs.org/w/index.php?diff=69637&oldid=69636 * A * (+35)
03:13:02 <zzo38> Someone I know asked me if there is a pre-processor for PHP which inlines all included files and strips all comments. Is there such a program?
03:13:26 -!- Ethan30 has joined.
03:14:09 <Ethan30> I heard fungot lives here, and had to see for myself
03:14:10 <fungot> Ethan30: edit formicidae.sh and add the result to what fnord pushes a onto the stack" instead of ' the strict definition of pun ais523, though
03:14:57 <Ethan30> ^help
03:14:57 <fungot> ^<lang> <code>; ^def <command> <lang> <code>; ^show [command]; lang=bf/ul, code=text/str:N; ^str 0-9 get/set/add [text]; ^style [style]; ^bool
03:42:26 -!- Ethan30 has left.
03:44:48 <esowiki> [[FiM++]] https://esolangs.org/w/index.php?diff=69638&oldid=66808 * Salpynx * (+1130) /* Examples */ Everypony likes Collatz, and cake.
03:57:54 <oerjan> fungot: how does it feel to be famous
03:57:55 <fungot> oerjan: nobody needs more than 100mb x_x
04:32:37 -!- Sgeo__ has joined.
04:36:03 -!- Sgeo_ has quit (Ping timeout: 272 seconds).
04:37:56 -!- MDude has quit (Quit: Going offline, see ya! (www.adiirc.com)).
06:33:57 -!- xkapastel has joined.
06:37:07 -!- xelxebar_ has joined.
06:37:43 -!- xelxebar has quit (Ping timeout: 240 seconds).
06:49:07 -!- oerjan has quit (Quit: Nite).
06:50:41 <b_jonas> fungot, are you asbestos-free?
06:50:41 <fungot> b_jonas: use sara to leave him message... eh never mind), then i have to
07:59:28 -!- rain1 has joined.
08:00:55 -!- imode has quit (Ping timeout: 265 seconds).
08:10:09 -!- Phantom_Hoover has joined.
09:40:56 <rain1> hello all
10:09:36 <esowiki> [[User talk:A]] https://esolangs.org/w/index.php?diff=69639&oldid=69637 * A * (+893)
10:15:21 <esowiki> [[User talk:A]] https://esolangs.org/w/index.php?diff=69640&oldid=69639 * A * (+777)
10:57:28 <esowiki> [[User talk:A]] https://esolangs.org/w/index.php?diff=69641&oldid=69640 * A * (-24581) Remove the mess as that's really interfering with my ideas.
11:01:24 <esowiki> [[User talk:A]] https://esolangs.org/w/index.php?diff=69642&oldid=69641 * A * (+290)
11:18:23 <esowiki> [[User talk:A]] https://esolangs.org/w/index.php?diff=69643&oldid=69642 * A * (+885)
11:19:13 -!- arseniiv has joined.
11:28:12 <esowiki> [[User talk:A]] https://esolangs.org/w/index.php?diff=69644&oldid=69643 * A * (+1045)
11:34:18 -!- xkapastel has quit (Quit: Connection closed for inactivity).
11:36:30 <esowiki> [[User talk:A]] https://esolangs.org/w/index.php?diff=69645&oldid=69644 * A * (+1141)
11:41:53 <esowiki> [[User talk:A]] https://esolangs.org/w/index.php?diff=69646&oldid=69645 * A * (+527)
11:47:46 <esowiki> [[User talk:A]] https://esolangs.org/w/index.php?diff=69647&oldid=69646 * A * (+532)
11:51:59 <esowiki> [[User talk:A]] https://esolangs.org/w/index.php?diff=69648&oldid=69647 * A * (+398) /* The action of fill over a string (i.e. "rainbow-paint") */
11:55:40 <esowiki> [[User talk:A]] https://esolangs.org/w/index.php?diff=69649&oldid=69648 * A * (+255) The catch is that I want to put in as many documentation for my language as the length of the Zalgo text.
12:00:54 <esowiki> [[User talk:A]] https://esolangs.org/w/index.php?diff=69650&oldid=69649 * A * (+453) /* Task: Create a 10x10 grid of asterisks. */
12:06:31 <esowiki> [[User talk:A]] https://esolangs.org/w/index.php?diff=69651&oldid=69650 * A * (+334)
12:09:08 <esowiki> [[User talk:A]] https://esolangs.org/w/index.php?diff=69652&oldid=69651 * A * (+332)
12:17:16 <esowiki> [[User talk:A]] https://esolangs.org/w/index.php?diff=69653&oldid=69652 * A * (+1114)
12:22:15 <esowiki> [[User talk:A]] https://esolangs.org/w/index.php?diff=69654&oldid=69653 * A * (+272) Little edit.
12:26:06 -!- Sgeo_ has joined.
12:29:47 -!- Sgeo__ has quit (Ping timeout: 272 seconds).
12:33:49 -!- Lord_of_Life_ has joined.
12:34:28 <esowiki> [[User talk:A]] https://esolangs.org/w/index.php?diff=69655&oldid=69654 * A * (+660)
12:37:07 -!- Lord_of_Life has quit (Ping timeout: 260 seconds).
12:37:10 -!- Lord_of_Life_ has changed nick to Lord_of_Life.
12:42:49 <esowiki> [[User talk:A]] https://esolangs.org/w/index.php?diff=69656&oldid=69655 * A * (+538)
12:50:42 <esowiki> [[User talk:A]] https://esolangs.org/w/index.php?diff=69657&oldid=69656 * A * (+780)
12:58:12 <esowiki> [[User talk:A]] https://esolangs.org/w/index.php?diff=69658&oldid=69657 * A * (+455)
12:59:57 <esowiki> [[Golf]] https://esolangs.org/w/index.php?diff=69659&oldid=65013 * A * (+11971)
13:00:29 <esowiki> [[Golf]] https://esolangs.org/w/index.php?diff=69660&oldid=69659 * A * (-1)
13:05:39 <esowiki> [[User:PythonshellDebugwindow]] M https://esolangs.org/w/index.php?diff=69661&oldid=69563 * PythonshellDebugwindow * (+42)
13:05:52 <esowiki> [[User:PythonshellDebugwindow]] M https://esolangs.org/w/index.php?diff=69662&oldid=69661 * PythonshellDebugwindow * (+9)
13:29:15 <esowiki> [[XENBLN]] M https://esolangs.org/w/index.php?diff=69663&oldid=69330 * PythonshellDebugwindow * (+0)
13:38:07 -!- Sgeo__ has joined.
13:41:14 -!- Sgeo_ has quit (Ping timeout: 240 seconds).
14:57:25 -!- kspalaiologos has joined.
14:59:07 -!- arseniiv has quit (Ping timeout: 240 seconds).
15:17:21 <esowiki> [[XENBLN]] M https://esolangs.org/w/index.php?diff=69664&oldid=69663 * PythonshellDebugwindow * (+0) /* Truth-machine (7 bytes) */ This is from last year
15:18:43 -!- arseniiv has joined.
15:27:00 <esowiki> [[Eso2D]] N https://esolangs.org/w/index.php?oldid=69665 * PythonshellDebugwindow * (+2216) Eso2D
15:28:41 <esowiki> [[Eso2D]] M https://esolangs.org/w/index.php?diff=69666&oldid=69665 * PythonshellDebugwindow * (+117) /* Instruction pointer */
15:37:43 -!- kspalaiologos has quit (Quit: Leaving).
16:31:30 -!- MDude has joined.
16:32:14 <arseniiv> how do you like an approach between no closures in a language at all and their full support (but that needs tricky things without GC, and not many people would like to implement them). Instead we don’t allow functions to capture variables, but we do allow constructing partially applied functions and passing them around. That should definitely be not as tricky?
16:53:01 <rain1> i guess it could work
17:26:47 -!- rain1 has quit (Quit: Lost terminal).
18:15:35 -!- Phantom_Hoover has quit (Ping timeout: 272 seconds).
18:19:49 <zzo38> I don't know.
18:31:44 <spruit11> I don't understand the difference..
18:33:19 <spruit11> If you pass around partially applied functions wouldn't that imply some form of GC too?
18:36:31 <zzo38> Yes, that is what I thought. The difference seems to be that captured variables might be used and altered by multiple functions (and multiple calls to the same function), I think.
18:46:46 <zzo38> SQLite still uses ARCFOUR for random numbers, even though I have read somewhere that sometimes the period is too small.
18:56:59 <moony> This makes me think of just how tricky to design Rust's closures probably were
18:57:26 <moony> the language is built around tracking the lifetimes of everything, i'd imagine they could throw a wrench in the works
19:11:39 <kmc> yes, it was tricky
19:14:48 <kmc> https://doc.rust-lang.org/1.30.0/book/second-edition/ch19-02-advanced-lifetimes.html
19:15:04 <kmc> it's one of the reasons why they support bounds of the form "Type: 'lifetime" as well as "Type: Trait"
19:15:18 <kmc> meaning "everything in this Type is live for at least 'lifetime"
19:16:05 <kmc> it's not really unique to closures, because Rust closures (like C++ closures) are sugar for creating and populating an anonymous struct type with appropriate Fn/FnMut/FnOnce implementation
19:16:49 <kmc> and (like C++) higher order functions are either generic over that type (static dispatch) or take a "trait object" (dynamic dispatch)
19:17:21 <kmc> anyway it's a lot of complexity but integrating closures into this scheme of things is really powerful
19:18:00 <kmc> for example you can capture stack objects by reference without fear that the closure will escape that stack frame
19:18:28 <kmc> you can even build a "scoped threads" library around this, which allows you to spawn a thread that is guaranteed not to outlive that scope
19:18:56 <kmc> which is a nice starting point for very efficient data parallelism
19:19:18 <kmc> splitting work up among threads without having to copy the data that they will be working on
19:20:15 <kmc> although it's not perfect, I think the design of Rust came together really well
19:21:30 -!- imode has joined.
19:22:28 <kmc> it was designed by some very smart people who didn't give up on having the trifecta of safe, fast, convenient
19:22:48 <kmc> and the tradeoff is complexity
19:22:59 <kmc> but the complexity is pretty harmonious and most of it's there for a good reason
19:23:19 <kmc> unlike C++, which is similarly or more complex but for mostly accidental reasons
19:23:48 <kmc> but yeah closures in Rust are funky
19:23:57 <kmc> there's the lifetime-bounds-on-captures thing I just discussed
19:24:28 <kmc> and then there's the question of capture by move vs. capture by reference
19:24:54 <kmc> and then there's the three call traits Fn/FnMut/FnOnce which determine whether you can move *out* of the captures, and whether you can mutate them
19:25:16 <kmc> 'mut' in Rust really means 'exclusive pointer' not 'mutation-allowing pointer'
19:25:38 <kmc> you need exclusive access to mutate, but it's the exclusivity that actually drives so much of the language design
19:25:51 <kmc> it's a much stronger difference than &T vs const &T in C++
19:48:40 <zzo38> If you have "abcdefhijk" then you can put into the order "akbjcidhef" what is such an ordering called?
19:49:15 <myname> like in the movie memento?
19:49:50 -!- Phantom_Hoover has joined.
19:50:43 <zzo38> (That is, put the lowest element first, and then the highest element, and alternate the lowest and highest remaining element)
21:07:16 <arseniiv> <spruit11> If you pass around partially applied functions wouldn't that imply some form of GC too? => maybe not, if we would do something awful to pointers :D
21:07:30 <arseniiv> didn’t see there was answers, as no one mentioned me :P
21:11:06 <arseniiv> <zzo38> If you have "abcdefhijk" then you can put into the order "akbjcidhef" what is such an ordering called? => interesting thing, I haven’t seen a name for this
21:11:40 <zzo38> arseniiv: Have you seen this kind of ordering used with anything though?
21:12:45 <arseniiv> zzo38: maybe in a deck shuffling method, but I’m not sure that’s not my imagination
21:14:36 <b_jonas> arseniiv: I don't think that works as a deck shuffling method, because you can't quickly reverse a deck. it could be a pancake shuffling method, because you can reverse a stack of pancakes.
21:15:02 <arseniiv> I would name that a spiral ordering maybe, as one can draw an archimedean spiral with center somewhere near the midpoint of the string, and it will pass through the string’s characters in that order
21:15:18 <zzo38> It is used in a method of storing a Huffman tree that I invented, but I don't know how good it is compared with other methods. The values for each code length are stored in this order.
21:15:39 <zzo38> O, that is what it is called.
21:15:55 <arseniiv> b_jonas: now I want pancakes
21:16:04 <zzo38> I don't know what other uses there might be of such ordering
21:16:25 <zzo38> Do you have the ingredients to make pancakes?
21:17:05 <arseniiv> yeah, but it’s very late here and I’m going to take a bath and then sleep
21:17:33 <arseniiv> not so very late but still
21:17:43 <zzo38> O, OK. In morning you can make pancake then, if you like to do.
21:18:05 <arseniiv> it’s a good suggestion!
21:18:19 <arseniiv> well, bye
21:18:19 <b_jonas> fungot, do you eat pancakes
21:18:20 <fungot> b_jonas: i don't think you'd like grad cs? ( other than one .cpp
21:18:50 <arseniiv> fungot: do you bathe or are you intristically clean and shiny as bots go?
21:18:50 <fungot> arseniiv: wait a second
21:18:57 <arseniiv> haha
21:19:37 <arseniiv> maybe it’s because I again typoed “intrinsically”
21:23:38 -!- arseniiv has quit (Ping timeout: 240 seconds).
21:44:07 -!- ais523 has joined.
21:52:32 -!- ArthurStrong has joined.
22:09:45 <spruit11> egelbot: try 1 + throw ([X Y -> say X " "] "hello") catch [ F -> F "world!" ]
22:09:46 <egelbot> hello
22:09:55 <spruit11> egelbot: try 1 + throw ([X Y -> say X " " Y] "hello") catch [ F -> F "world!" ]
22:09:55 <egelbot> hello world!
22:09:59 <spruit11> \o/
22:10:31 <spruit11> Just checking.
22:15:01 <b_jonas> what? how does that work
22:15:06 <b_jonas> egelbot: say "a" "b" "c"
22:15:06 <egelbot> abc
22:15:08 <b_jonas> what
22:15:11 <b_jonas> egelbot: (say "a") "b" "c"
22:15:11 <egelbot> abc
22:15:22 <b_jonas> egelbot: say "a"
22:15:22 <egelbot> a
22:15:33 <b_jonas> egelbot: (say "a", 0)
22:15:34 <egelbot> a
22:15:34 <egelbot> (System:tuple System:nop 0)
22:15:48 <b_jonas> egelbot: [(X, Y) -> X "b"] (say "a", 0)
22:15:48 <egelbot> a
22:16:01 <b_jonas> that's evil
22:16:06 <b_jonas> variadic magic
22:18:20 -!- HackEso has quit (Read error: Connection reset by peer).
22:19:13 -!- HackEso has joined.
22:19:45 <b_jonas> egelbot: [X -> X "b"] say "a"
22:20:02 <b_jonas> egelbot: [X -> X "b"] (say "a")
22:20:02 <egelbot> a
22:20:18 <b_jonas> egelbot: nop "a"
22:20:31 <b_jonas> nop as a head suppresses the printing?
22:21:04 <b_jonas> egelbot: [V -> (V, V)] (7; 6)
22:21:04 <egelbot> (System:tuple 6 6)
22:21:41 <myname> egel looks a lot like haskell imo
22:22:49 <zzo38> It looks like difference to me.
22:23:20 <b_jonas> myname: egel is not lazy, and it's weakly typed
22:23:58 <b_jonas> egelbot: [V -> "unused"] (say "side effect")
22:23:58 <egelbot> side effect
22:23:58 <egelbot> "unused"
22:24:28 -!- ArthurStrong has quit (Quit: leaving).
22:28:18 <ais523> I can imagine a strict language that looks identical to Haskell, and is semantically very similar apart from being strict
22:28:37 <ais523> I guess I can imagine untyped Haskell too; does Haskell ever use its type system to figure out how to parse something?
22:29:26 <b_jonas> ais523: no, but Haskell uses typeclasses in a way that which class is chosen depends on the type of the result, not of the input arguments, like rust but unlike C++
22:29:43 <spruit11> egelbot: try 1 + throw ([X Y -> say X " " Y] (2+2)) catch [ F -> F "?" ]
22:29:43 <egelbot> 4 ?
22:29:55 <spruit11> Just to be sure.
22:30:51 <spruit11> Yah, variadic magic _is_ evil when combined with eager semantics.
22:31:02 <b_jonas> > (maxBound - (0::Int8), maxBound - (0::Int)) -- ais523: try that in an untyped language
22:31:04 <lambdabot> (127,9223372036854775807)
22:31:04 <spruit11> But, ah well.
22:31:59 <ais523> b_jonas: I wasn't thinking in terms of existing programs still working, just in terms of the syntax and semantics making sense
22:32:19 <b_jonas> fizzie: can you please install libicu-dev onto HackEso inside, plus make it ignore egelbot while you're there?
22:33:48 <spruit11> b_jonas: nop is just the return value for "say". It needs to rewrite to some value.
22:34:03 <spruit11> b_jonas: Egel is impure, eager, weakly typed.
22:34:28 <ais523> spruit11: I think the "consensus" return value for that among computer scientists is to use an empty tuple
22:34:39 <ais523> there are a number of mathematical benefits to that particular value
22:34:45 <spruit11> ais523: Could be. I am not that informed.
22:34:52 <b_jonas> ais523: I don't think that's the consensus, that's just what Haskell uses
22:34:58 <ais523> OCaml too
22:36:04 <ais523> the reason is based on the properties of product and sum types, a type with only one possible value is a unit for a product type, thus a type with only one possible value is an empty tuple
22:36:24 <b_jonas> yes, but there can be multiple distinct types with only one possible value
22:36:27 <ais523> (likewise, the return value from functions that never return is an empty enum / a variant with no options, because it's the unit for a sum type)
22:36:45 <ais523> b_jonas: how do you distinguish the types?
22:37:07 <b_jonas> regardless of whether the language is weakly typed or compile time typed, you can use different types to distinguish isomorphic types for catching programming errors or making programming easier to think about
22:37:24 <ais523> I guess you just have to arbitraily say "these things belong to different types", mathematicians dislike that sort of arbitrary requirement
22:37:42 <ais523> because they're semantically identical after the language is compiled, they only affect type checking
22:37:49 <b_jonas> sure
22:52:47 <b_jonas> fungot, do lions eat watermelons?
22:52:48 <fungot> b_jonas: and got really scared :p. but, not a technical problem... altho my cat is in a
22:56:41 <kmc> Rust also uses an empty tuple
22:57:02 <kmc> if a function has no declared return type then it returns ()
22:57:18 <kmc> and "return;" is short for "return ();"
22:57:25 <spruit11> It makes a bit more sense to use a special value in an untyped language.
22:57:43 <spruit11> egelbot: nop
22:57:48 <kmc> and a { ... } block which ends with a non-expression (e.g. a semicolon-terminated statement) produces the value ()
22:57:49 <spruit11> egelbot: tuple
22:57:49 <egelbot> System:tuple
22:57:57 <spruit11> ^ because of that.
22:58:14 <kmc> (because blocks are expressions so it has to produce *something*)
22:58:42 <kmc> Rust's concrete syntax is all braces-and-semicolons but the abstract syntax is closer to ML than C
22:59:06 <kmc> seeing as most constructs are expressions and there are only a few kinds of non-expression statement
23:01:48 <ais523> Rust has a bit of a backwards compatibility mess, though, with various competing empty types
23:02:08 <ais523> there's ! which wasn't a type for ages, and various empty enums invented to serve as an empty type until ! became a type
23:02:14 <ais523> I think that's likely to get fixed eventually though
23:04:39 <kmc> yeah
23:05:37 <kmc> Haskell doesn't have a standard empty type either, does it
23:05:48 <Taneb> Data.Void.Void is in base now
23:05:49 <kmc> and I don't think you can define it in standard Haskell
23:05:51 <kmc> ok
23:06:00 <Taneb> But that's a GHCism
23:06:09 <kmc> yeah
23:06:13 <b_jonas> kmc: you can define it with the GADT syntax these days
23:06:20 <kmc> but that's not in standard Haskell, is it?
23:06:23 <b_jonas> I think it's like data Void where {}
23:06:26 <b_jonas> no clue
23:06:39 <b_jonas> doesn't matter, GHC is the de facto standard
23:06:50 <kmc> if it's a de facto standard then it should be a lot better documented
23:07:03 <kmc> and they should at least have a subset of extensions which are semi guaranteed not to change randomly
23:07:04 <b_jonas> kmc: it is, there's a user manual that explains all the extensions
23:07:08 <kmc> """explains""
23:07:22 <kmc> "read this paper that we implemented a variant of half of"
23:07:39 <kmc> "and may completely change in the next minor version release"
23:09:15 <b_jonas> https://downloads.haskell.org/ghc/latest/docs/html/users_guide/glasgow_exts.html#declaring-data-types-with-explicit-constructor-signatures specifically
23:09:26 <b_jonas> kmc: well some extensions are like that, but some are pretty stable
23:09:43 <kmc> but there's no actual indication of which is which, is there?
23:10:28 <kmc> Rust has a lot of unstable features as well, and there's no Rust standard to begin with. but they're pretty careful about distinguishing stable from unstable features and not breaking backwards compat after something is declared stable
23:10:33 <b_jonas> and there's another extension to declare an empty enum, https://downloads.haskell.org/ghc/latest/docs/html/users_guide/glasgow_exts.html#data-types-with-no-constructors , but the GADT syntax is clearer
23:10:39 <kmc> GHC doesn't even comply with the Haskell spec anymore
23:10:46 <kmc> even with all extensions off
23:11:01 <kmc> there is valid Haskell 98 code that isn't accepted by GHC because they've defined stdlib stuff differently
23:11:31 -!- Phantom_Hoover has quit (Ping timeout: 265 seconds).
23:11:40 <b_jonas> kmc: you know there's a haskell 2010 standard, right? www.haskell.org/onlinereport/haskell2010/
23:11:44 <kmc> sure
23:11:59 <kmc> s/98/2010/ in what I said
23:12:00 <kmc> it's still true
23:12:08 <kmc> and Haskell 2010 is only a minor revision of Haskell 98
23:12:13 <b_jonas> and yes, one of the important changes is in the class hierarchy where Monads are now a ... Functor? or an Applicative? I don't follow
23:12:25 <kmc> it didn't capture most of the GHC extensions in use in 2010 let alone whatever crazy shit people are using now
23:12:48 <b_jonas> "minor revision"? it's what documents a lot of nice stable what used to be GHC extensions to haskell 98
23:13:04 <b_jonas> it doesn't want to revolutionize the language, but it gives you tools that you'll want to use without a standard anyway
23:13:21 <b_jonas> it only documents the more stable stuff, not every crazy experimental ghc extension
23:13:30 <b_jonas> and obviously it's like nine years old
23:13:57 <kmc> yes, it's a minor revision
23:14:31 <kmc> it included a small number of minor extensions to Haskell 98
23:14:47 <kmc> there are not many large Haskell programs that required GHC extensions with 98 but are valid standard Haskell 2010
23:14:51 <kmc> imo
23:15:17 <kmc> if they're going to have one language release per decade then they need to step up the pace a lot to be relevant at all
23:15:23 <kmc> and well
23:15:27 <kmc> they aren't relevant
23:15:35 <kmc> as you yourself said
23:15:56 <kmc> people don't code Haskell they code for GHC and whatever version happens to be available now
23:16:52 <b_jonas> kmc: yes. and that's not particularly different for rust either at the moment, until someone puts serious work into a rust frontend for gcc
23:17:18 <b_jonas> kmc: most current rust programs target the one rust compiler, and depend on how exactly it does type inference
23:18:38 <kmc> the difference is that they have a strong committment to not break code which compiles without extensions turned on
23:18:52 <kmc> and even run regression tests against the entire published ecosystem on crates.io
23:18:56 <b_jonas> kmc: except for when it depends on the type inference. but sure.
23:19:41 <b_jonas> anyway, I do understand that haskell isn't too relevant, and I wouldn't recommend to write programs in it, but that's mostly because it's this strange research language based on lazy pure garbage-collected you know what
23:21:07 <b_jonas> and I do like rust
23:21:15 <b_jonas> I'm just saying that some of your complaints seem unfair
23:22:26 <b_jonas> and yes, the rust devs do indeed to good job about backwards compatibility in practice, but you do get most of the backwards compatibility with GHC too, except for the stupid Monad superclass issue, which you can fix, unless you use one of the crazy experimental extensions
23:25:17 -!- xkapastel has joined.
23:28:15 <zzo38> Is there a auto super class extension?
23:28:37 <b_jonas> dunno. you can try asking in #haskell.
23:28:40 <b_jonas> I mean
23:28:43 <b_jonas> dunno. you can try asking in #haskell .
←2020-02-07 2020-02-08 2020-02-09→ ↑2020 ↑all