00:02:17 <Lykaina> gonna set out out in in on both r and s
00:02:40 <imode> reasoning about arithmetic using queues is uh... confusing.
00:04:17 <imode> https://hastebin.com/utigeyadaq.md
00:05:20 <Lykaina> as max for the R- and S-ops
00:07:24 <imode> it's really hard to sequence queue operations in your head, compared to a stack.
00:08:00 <imode> even then I had to resort to a roll operation that rotates the queue.
00:08:23 <imode> lemme see if I can write a factorial function.
00:09:07 <arseniiv> <imode> is there any mathematical foundation to dataflow programming? => hm AFAIR there is a single framework in Haskell to express all of them (I don’t remember is it closer to comonads or ArrowFix, what it was called) so maybe there is something in category theory to base all of it too. Though I have read only a few introductory things and don’t remember them by now
00:11:30 <arseniiv> or not, I seem to confuse that with stream processing or what it’s called, when each tick all the values are recomputed using a fixed set of rules, using only the previous available values or something like this, ultimately like a usual digital circuit
00:12:48 <esowiki> [[But Is It Art?]] https://esolangs.org/w/index.php?diff=66110&oldid=58846 * Qpliu * (+0) /* External resources */
00:13:03 <arseniiv> the last thing is of course more or less simple so the question is probably not about that
00:20:47 -!- arseniiv has quit (Ping timeout: 246 seconds).
00:21:30 <esowiki> [[Talk:Intramodular Transaction]] N https://esolangs.org/w/index.php?oldid=66111 * Qpliu * (+383) Created page with "An alternative reverse bits: main input = reverse input trailer input; trailer input = ? input trailer ..input input; reverse input output = ? input ? .input reverse ..inpu..."
01:22:39 -!- tromp has quit (Read error: Connection reset by peer).
01:35:50 <imode> I haven't even thought of how I'd translate that quadratic formula to an actual _function_... jesus.
02:00:10 -!- Phantom_Hoover has joined.
02:01:43 -!- xkapastel has quit (Quit: Connection closed for inactivity).
02:08:23 -!- Phantom_Hoover has quit (Ping timeout: 276 seconds).
02:22:17 <imode> seems like a register machine requires indirect addressing to be conveniently turing complete, else you're going to be spending your time encoding your TM tape into one of the registers.
02:33:36 <imode> I'm so indecisive with what I want to devote my time doing. I've tried stack machines and queue machines with some fancy logic on top.
02:33:53 <imode> can't seem to find just the right model.
02:39:36 <Lykaina> http://sif.lesidhetree.com/sara/echidna/Echidna%20v0_03a7.pdf
02:41:52 -!- craigo has joined.
02:44:15 <kmc> hi Hooloovo0
02:45:13 <kmc> what's new?
02:46:08 <Hooloovo0> and also thinking about a paper for my ethics class
02:47:06 <Hooloovo0> demo is TI calculators + a vax, and
02:47:23 <kmc> what's VCF?
02:47:34 <kmc> when is that?
02:47:38 <kmc> is that the thing @ the computer history museum?
02:48:04 <Hooloovo0> there's a couple other ones scattered around the country
02:48:23 <Hooloovo0> they have pretty boring names if you ask me
02:48:26 <kmc> oh, VCF west was last month
02:48:44 <kmc> CHM is a cool place
02:48:45 <Hooloovo0> vcfmw.org is the one I'm going to, this weekend
02:48:45 <kmc> I want to go back
02:49:16 <Hooloovo0> they definitely have a bunch of cool stuff... but only a couple things are turned on
02:49:34 <kmc> my wife works 5 min away from there
02:49:35 <Hooloovo0> if you go, definitely make sure you get to see the IBM demo
02:49:38 <kmc> yeah, that's true
02:50:37 <Hooloovo0> hmm, if you show up with your own punch cards, I wonder if they'd let you run them through the 1401...
02:52:01 <kmc> did some grocery shopping, that's about it
02:53:03 <Lykaina> 22:42:17 < Hooloovo0> why is it called echidna?
02:53:28 <Lykaina> there was a good reason, though
03:06:41 -!- tromp has joined.
03:08:00 -!- tromp_ has joined.
03:10:54 -!- tromp has quit (Ping timeout: 246 seconds).
03:12:44 -!- tromp_ has quit (Ping timeout: 276 seconds).
03:23:37 <Lykaina> http://sif.lesidhetree.com/sara/echidna/Echidna%20v0_03a7-fix.pdf
03:35:46 <Lykaina> well, Echidna not, it is hard to program in.
03:36:44 -!- tromp has joined.
03:41:20 -!- tromp has quit (Ping timeout: 276 seconds).
03:41:22 <shachaf> Linux stack growth behavior was changed apparently: https://github.com/torvalds/linux/commit/1d8ca3be86ebc6a38dad8236f45c7a9c61681e78
03:41:57 <shachaf> It used to check %rsp against the fault address on page faults, and grow the stack if %rsp was lower.
03:44:56 <Lykaina> i picked echidna because the first echidna, which was very different, needed to start with the letter 'e'
03:45:15 <Lykaina> and be an animal, as that was my convention
03:46:12 <Lykaina> this echidna was a lot closer to the first ecidna than to calamari or hydra
03:47:28 <Lykaina> next one i make will probably be calamari
03:47:42 -!- hppavilion[2] has joined.
03:48:50 <Lykaina> *my* hydra might not have been esoteric
03:49:10 <Lykaina> no relation to the hydra on the wiki
03:50:28 -!- hppavilion[1] has quit (Ping timeout: 265 seconds).
03:52:37 <Lykaina> i don't think the original Echidna was esoteric, but it was a pain in the ass. It shares some code with the current Echidna, which I believe to be esoteric.
03:58:45 -!- hppavilion[1] has joined.
04:01:38 -!- hppavilion[2] has quit (Ping timeout: 240 seconds).
04:31:11 -!- tromp has joined.
04:35:36 -!- tromp has quit (Ping timeout: 246 seconds).
04:43:00 <imode> https://hastebin.com/elifuxehir.md spent the evening working out what the quadratic formula might look like in a queue-based Forth.
04:45:05 <imode> 38 instructions vs. the 31 for Forth on rosetta code.
04:45:19 <imode> difficult. but interesting
05:20:23 -!- imode has quit (Ping timeout: 246 seconds).
05:22:28 <esowiki> [[User:CarlosLuna]] M https://esolangs.org/w/index.php?diff=66112&oldid=66084 * CarlosLuna * (+14)
05:29:16 -!- Lykaina has quit (Quit: leaving).
06:19:09 -!- tromp has joined.
06:23:50 -!- tromp has quit (Ping timeout: 276 seconds).
06:24:56 -!- imode has joined.
06:26:19 -!- tromp has joined.
06:30:59 -!- tromp has quit (Ping timeout: 276 seconds).
06:59:02 -!- tromp has joined.
07:20:53 <imode> my factorial algorithm got shorter once I swapped to a queue.
07:28:59 <imode> designing an 'if' statement with a queue is a little tougher. the body of the if statement may do work that gets in the way of signalling the next block.
07:29:51 <imode> a good primitive might be "roll to the last element of the queue".
07:53:12 -!- Frater_EST has joined.
08:14:59 -!- imode has quit (Ping timeout: 276 seconds).
08:23:59 <esowiki> [[Talk:AAAAAAAAAAAAAA!!!!]] https://esolangs.org/w/index.php?diff=66113&oldid=65790 * YamTokTpaFa * (+374) /* Command changing commands and operations */ new section
08:32:26 -!- Phantom_Hoover has joined.
08:41:26 -!- tromp has quit (Remote host closed the connection).
08:42:36 -!- hppavilion[1] has quit (Remote host closed the connection).
08:44:06 -!- hppavilion[1] has joined.
08:55:17 -!- Lord_of_Life has quit (Ping timeout: 276 seconds).
08:56:25 -!- Lord_of_Life has joined.
09:09:22 <esowiki> [[Alisj]] https://esolangs.org/w/index.php?diff=66114&oldid=43587 * YamTokTpaFa * (+24)
09:16:30 -!- tromp has joined.
09:17:25 <esowiki> [[Parent the Sizing]] https://esolangs.org/w/index.php?diff=66115&oldid=55580 * YamTokTpaFa * (+9) +WIP
09:17:41 -!- cpressey has joined.
09:22:43 -!- Frater_EST has left.
09:23:04 <cpressey> Good morning. I just realized that both the Prompt monad and the Operational monad *require* you to define the insert with a GADT. I also suspect this is how they can guarantee the resulting monad adheres to the monad laws.
09:23:40 <Taneb> cpressey: I think it's more that GADTs are the only way to get any use out of them
09:24:43 <esowiki> [[Chromos]] https://esolangs.org/w/index.php?diff=66116&oldid=60901 * YamTokTpaFa * (+51)
09:25:14 <Taneb> ProgramT Identity m a isn't particularly unreasonable, although not very useful
09:25:39 <esowiki> [[TwoFiftyFive]] https://esolangs.org/w/index.php?diff=66117&oldid=65725 * YamTokTpaFa * (+24)
09:26:16 <cpressey> I think I don't know enough about this to ask a sensible follow-up question
09:26:37 <Taneb> That's OK, I don't know enough to answer one
09:26:56 <esowiki> [[SLOBOL (2015 language)]] https://esolangs.org/w/index.php?diff=66118&oldid=63937 * YamTokTpaFa * (+34)
09:27:34 <esowiki> [[WILSON]] https://esolangs.org/w/index.php?diff=66119&oldid=46781 * YamTokTpaFa * (+23)
09:27:39 <shachaf> cpressey: What's the distinction between Prompt and Operational? I thought people used those words to mean the same thing.
09:28:30 <shachaf> Whichever one we were talking about the other way, it should be a monad regardless of the type constructor you give it.
09:31:49 <cpressey> shachaf: What kinds of type constructors are you allowed to give it? Is List a type constructor? Can you give it List?
09:32:34 <shachaf> I don't know what "it" is.
09:33:17 <cpressey> The "it" in my question was the final "it" in your sentence that started with "Whichever".
09:33:36 <shachaf> I think the answer is yes, and it'll give you a particular kind of n-ary trees.
09:33:59 <shachaf> This one: data Tree a = Leaf a | Branch [Tree a]
09:34:22 <shachaf> (With a pretty complicated encoding.)
09:36:20 <cpressey> OK, to back up: yes, I think the distinction between Prompt and Operational is not very important, they're just two different APIs/libraries/implementations of the same basic idea.
09:37:51 <cpressey> Taking Operational b/c it seems slightly simpler to understand, the definition is: type Program instr = ProgramT instr Identity
09:37:58 <cpressey> "The primitive instructions are given by the type constructor instr :: * -> *."
09:38:03 <cpressey> I don't think that includes List.
09:38:32 <cpressey> I'm not sure it includes anything that isn't a GADT?
09:38:58 <cpressey> I guess ProgramT's defintion is more fundamental
09:39:17 <cpressey> but similar: data ProgramT instr m a ... with "The primitive instructions are given by the type constructor instr :: * -> *."
09:39:20 <shachaf> * is the kind of types, so it certainly includes List.
09:39:31 <shachaf> Uh, so * -> * certainly includes List.
09:39:48 <shachaf> Since List takes types (like Int : *) to types (like List Int : *)
09:40:29 <cpressey> I'll try putting List there but based on my futzing around with it yesterday I 100% expect ghc to complain.
09:41:00 <shachaf> Is it https://hackage.haskell.org/package/operational-0.2.3.5/docs/Control-Monad-Operational.html ?
09:45:21 <shachaf> I'm surprised that it says "Bind :: ProgramT instr m b -> (b -> ProgramT instr m a) -> ProgramT instr m a".
09:45:55 <shachaf> I haven't thought about how to make this a monad transformer, but in the non-transformer case I'd expect "Bind :: instr b -> (b -> Program instr a) -> Program instr a"?
09:46:15 <shachaf> Recursing on both sides seems to make it non-canonical?
09:48:15 <shachaf> Oh, you're probably supposed to use ProgramViewT.
09:49:30 <shachaf> Anyway, this certainly "works" for instr=List, it's just a very roundabout way to express that type.
09:52:35 <cpressey> import Control.Monad.Operational ; type MyListProgram s a = Program ([s]) a
09:53:00 <cpressey> ghc complains: The first argument of ‘Program’ should have kind ‘* -> *’, but ‘[s]’ has kind ‘*’
09:53:07 <shachaf> I think you mean Program [] a
09:53:42 <cpressey> That works, for reasons I do not at all understand.
09:53:57 <shachaf> Because Haskell syntax is confusing?
09:54:23 <shachaf> Hmm, Maybe isn't a very good example except syntactically.
09:54:44 <cpressey> Maybe also works. Well, at least this establishes that it doesn't *have* to be a GADT, which was half of my question.
09:54:59 <cpressey> Whether the result of doing this is useful for no, that's another matter.
09:55:23 <cpressey> Is there something like :t that shows the kind of a type constructor?
09:55:41 <cpressey> That was my first guess but I was being cautious.
09:55:51 <shachaf> Well, no, I don't think any of this is actually that useful.
09:56:24 <shachaf> All this is pretty paged out of my memory, but I can try to clarify things if it's helpful.
09:56:34 <cpressey> Maybe not useful, but very fitting to #esoteric somehow.
09:56:36 <shachaf> How do you feel about this type: data Free a = Pure a | Free (f (Free f a))
09:57:45 <shachaf> I think there's an important underlying point about what monads are, or something, such that it makes the same amount of sense for any type constructor you pass to Program.
09:59:44 <cpressey> I have no feelings about that type except perhaps bewilderment.
10:00:37 <shachaf> Let's think about ways to invent I/O in Haskell, assuming you don't know any of this nonsense.
10:01:07 <shachaf> Here's one simple way to do it: main :: String
10:01:16 <shachaf> This is really just O, not I/O.
10:02:14 <cpressey> Wait, where did I/O come from?
10:02:26 <shachaf> I think it's a useful concrete example.
10:02:49 <shachaf> If you prefer another one we can probably make it work too?
10:03:24 <shachaf> OK. The problem with this approach is that you can't do input.
10:03:47 -!- arseniiv has joined.
10:03:51 <shachaf> You could define main :: String -> String, but then the problem is that (modulo laziness) you do all the input upfront, and then all the output, which is pretty limited.
10:04:12 <shachaf> So what you want is a way to interleave input and output.
10:05:25 <shachaf> Note that the idea of all of these things is that you have some external runtime system/interpreter that can take a Haskell value like main and interpret it together with the outside world.
10:06:25 <cpressey> On second thought maybe I/O isn't the best example.
10:07:52 <shachaf> (Actually the question is only whether it's good enough.)
10:08:55 <cpressey> It's not intuitive to me that interleaving input and output is desriable. In Javascript, as one example, it is not possible to interleave input and output. Events cause computations which enqueue more events.
10:09:30 <cpressey> You end up writing promises and state machines.
10:10:28 <cpressey> Also, it gives the impression that the only reason Haskell has monads is so that it can do I/O despite the handicap of being a lazy, referentially transparent language, and that is of course unfair to say.
10:11:23 <shachaf> OK. If you have another example I can probably use that one instead.
10:11:57 <shachaf> I think IO is kind of a special monad in Haskell in that it's maybe best understood as a free monad since we don't particularly have semantics for it.
10:12:02 <shachaf> (Among other ways it's special.)
10:12:24 <cpressey> OK, parsing. That's an actual use case. I want to produce an AST and consume some of the string (i.e. produce the remainder of the string) but I don't want to constantly write destructuring pattern matches.
10:13:20 <cpressey> Or State, I suppose, you could treat the string as the state.
10:13:34 <shachaf> Parsing sounds pretty complicated.
10:13:54 <cpressey> What were you hoping to explain to me again?
10:14:19 <shachaf> I wanted to give some motivation for free monads such that nothing is too mystifying at any point.
10:14:53 <shachaf> Program is a kind of free monad and free monads are especially relevant when you apply Program to functors.
10:16:40 <shachaf> I think interleaved I/O makes sense in JavaScript. You need interleaved I/O to write programs like main() { print("what's your name?"); let name = get_line(); print("hi, " + name); }
10:17:05 <shachaf> It's true that it's often done with callbacks but that's true in Haskell too.
10:17:49 <cpressey> In Javascript you *have* to do it with callbacks (or promises, which are glorified callbacks).
10:17:51 <shachaf> I'm also at most 3/4 coherent at this hour, probably less.
10:18:21 <shachaf> In Haskell you also have to do it with callbacks (even more than in JavaScript, where some systems have synchronous APIs).
10:19:18 <cpressey> If 'do' notation is just callbacks in disguise.
10:19:48 <shachaf> How about I finish the I/O example which is very simple, and then I'll think of another example.
10:20:19 <shachaf> If you have a program operating on input bits and producing output bits, you can define a type like this:
10:21:08 <shachaf> data P = Done | Out Bit P | In (Bit -> P)
10:24:22 <shachaf> As an extra bonus we'll have our programs produce a value, as in
10:24:37 <shachaf> data P a = Done a | Out Bit (P a) | In (Bit -> P a)
10:25:44 <shachaf> And of course we could add more constructors to have more behaviors.
10:25:54 <shachaf> P is used to define interactions, but it's really just a kind of tree. Right?
10:26:11 <shachaf> As in, you could write "data P a = Out Bit (P a) | In (P a) (P a)"
10:27:52 <shachaf> Does the previous version make sense?
10:28:20 <shachaf> (Bit -> x) has the same information as (x, x) specifying a value for the 0 and 1 cases.
10:29:12 <cpressey> The previous version of P is a complicated kind of tree, okay.
10:30:24 <shachaf> Right. It has one kind of leaf -- that's Done -- and a slightly unusual shape of branches, which is one of two things -- either an output "branch" (which has a bit and one child) or an input branch (which has two children).
10:30:40 <shachaf> This tree is probably infinite but it describes our entire program.
10:31:53 -!- Phantom_Hoover has quit (Ping timeout: 246 seconds).
10:31:56 <shachaf> The branch shape, in particular, is this: data F a = OutF Bit a | InF (Bit -> a)
10:32:48 <shachaf> If you abstract the branch shape, you can get the type I mentioned above: data Tree f a = Leaf a | Branch (f (Tree f a))
10:34:45 <shachaf> I feel like I'm not being that helpful here.
10:37:00 <shachaf> The general point is that this kind of tree describes an interaction with something, and you can have some external program interpret the tree in some way.
10:37:40 <shachaf> OK, another example is making probabilistic choices.
10:38:38 <shachaf> You can have a probability tree where each branch is labeled with a probability and you pick the left side with that probability.
10:39:14 <shachaf> data Tree a = Done a | FlipCoin Probability (Tree a) (Tree a)
10:39:37 <shachaf> An "interpreter" for this tree might sample a particular path through it, or evaluate all the possibilities exhaustively.
10:42:27 <cpressey> I guess I can try to distill my question.
10:42:34 <cpressey> You keep talking about "interpreters".
10:43:46 <cpressey> For each of these trees you define, you need an "interpreter" to walk it and make sense of it.
10:46:00 <cpressey> But, in the first example at least, part of the tree also has a function in it.
10:46:31 <cpressey> You can't "interpret" a function, you can only run it.
10:47:28 <cpressey> OK, that's not a question I guess.
10:47:50 <cpressey> I guess my question is: why is it intuitive to anyone to mix these two modes?
10:47:58 <shachaf> Hmm, this is about "interpreting" the "effects".
10:48:37 <shachaf> A Haskell program already knows how to do computation, but it doesn't know how to do probability, and it doesn't have a source of randomness and so on.
10:49:13 <shachaf> So we add the notion of random choice (which might be a function (Real -> a), or flipping a coin, or whatever), but we don't say how specifically it's implemented.
10:49:20 <esowiki> [[Talk:Epsilo]] N https://esolangs.org/w/index.php?oldid=66120 * YamTokTpaFa * (+153) /* Where is the source and detailed descriptions!? */ new section
10:50:00 <shachaf> Then we end up with this tree data structure which has all the computation built in, but yields to you whenever it needs to take one of these effect actions like flipping a coin.
10:50:19 <shachaf> Your interpreter just adds these extra abilities.
10:52:15 <cpressey> Defining a data structure to represent an external service, and then embedding function types in the data structure to represent the computation you're going to do with the data you get from the external service, gets you a data structure like this.
10:53:56 <cpressey> People go out of their way to write unification algorithms like this.
10:54:37 <cpressey> It doesn't really matter if I like it or not.
10:55:30 <cpressey> I shouldn't say "out of their way"; it probably becomes a learned habit after a while.
10:55:51 <cpressey> Writing it the other way, would be going out of their way.
10:56:25 <cpressey> shachaf: Thanks for the explanation.
10:57:36 <HackEso> This is something people on the channel like to talk about. We're often unsure what this is, though. Nobody likes this.
11:17:16 -!- hppavilion[1] has quit (Quit: Leaving).
11:19:06 -!- hppavilion[1] has joined.
11:20:09 -!- hppavilion[1] has quit (Client Quit).
11:20:56 -!- hppavilion[1] has joined.
11:27:10 <cpressey> Ehm, OK. In Javascript the "interpreter" is the thing that waits to dequeue an event, finds the handler(s) for the event, runs the handlers (which may add more events to the queue), and repeats.
11:28:36 <cpressey> You could probably define a type that describes this if you had to.
11:34:32 <cpressey> I mean, in some idealized model of Javascript running in a browser, where the handlers are pure functions, etc.
11:40:10 <cpressey> The word "trampoline" also comes to mind.
11:43:42 -!- Lykaina has joined.
11:53:06 -!- hppavilion[1] has quit (Ping timeout: 246 seconds).
12:30:04 <Lykaina> http://sif.lesidhetree.com/sara/echidna/Echidna%20v0_03a8.pdf
12:53:41 -!- xkapastel has joined.
13:16:40 <Lykaina> http://sif.lesidhetree.com/sara/echidna/Echidna%20v0_03a8-fix.pdf
13:17:06 <Lykaina> clock example was outputting hours:minutes:minutes
13:46:27 <Lykaina> oh no...not another bug in documentation
14:00:30 <cpressey> arseniiv: If it means anything, I also have a half-written proof-checker with some issues with beta-reduction and metavariables, sitting in my experiments repo, which I'd like to continue on, but I don't really know where it's going
14:00:51 <Lykaina> http://sif.lesidhetree.com/sara/echidna/Echidna%20v0_03a8-fix2.pdf
14:03:48 <arseniiv> cpressey: thanks, I’ll look at it some time!
14:04:53 <Lykaina> i'll print out the compiled docs and go through them later.
14:05:14 <Lykaina> those were just the key ones i noticed
14:21:45 <cpressey> arseniiv: Oh, I haven't released the code publicly, it's still half-formed. You mentioned you had something similar I think.
14:26:27 <arseniiv> acpressey: yeah. My code is in a Python notebook :D
15:17:14 -!- sprocklem has quit (Ping timeout: 240 seconds).
15:31:01 <Lykaina> screw it. i'm going from 0.03a8 to 0.10a0
15:31:58 <Lykaina> after all the documentation fixes, it deserved a new version
15:55:48 -!- b_jonas has joined.
16:06:15 -!- tromp_ has joined.
16:09:53 -!- tromp has quit (Ping timeout: 245 seconds).
16:31:22 -!- cpressey has quit (Quit: You'll pry my programmable semicolons from my cold, dead hands).
16:40:05 -!- atslash has quit (Quit: This computer has gone to sleep).
16:51:49 -!- FreeFull has joined.
16:57:02 -!- Phantom_Hoover has joined.
16:57:52 -!- MrBismuth has joined.
16:59:49 -!- imode has joined.
17:00:50 -!- MrBusiness3 has quit (Ping timeout: 276 seconds).
17:08:20 <imode> finally made an `if` statement. had to add a `last` operator, which rolls to the last element of the queue.
17:12:38 <imode> https://hastebin.com/iwafudayes.rb
17:22:34 -!- sprocklem has joined.
17:34:48 <int-e> what a miserable communication failure
17:35:19 <int-e> I guess that makes a good self-referential statement.
17:37:26 <b_jonas> int-e: did you call a shop on phone, they said they had a product or service, but when you went there in person to buy it, they claim they never had it, denied the phone conversation, and tried to upsell?
17:39:49 <int-e> b_jonas: You might enjoy https://notalwaysright.com/all/ ;-) (maybe only some subcategories; your store may belong to "not always legal")
17:40:25 <b_jonas> int-e: eww no, that site is addictive and low-quality in the long run. I no longer read it.
17:40:49 <b_jonas> I wasted enough time on iy
17:41:21 <int-e> It's better than thedailywtf :P
17:57:06 -!- craigo has quit (Ping timeout: 246 seconds).
18:16:08 -!- sprocklem has quit (Ping timeout: 245 seconds).
18:36:11 <imode> arseniiv: yeah, took me a while. though you get good at queue juggling the more you do.
18:36:41 <imode> I wonder if you used a dequeue instead.
18:39:12 <arseniiv> I wonder whether there is some natural occurence of deque, like of stack and queue in DFS and BFS
18:39:47 <arseniiv> imode: np, I secretly hoped there is a new data structure lurking nearby
18:42:04 <imode> I think you could make a rather usable language if you used a deque, but toggle between where enqueuing and dequeueing take place with operations.
18:42:23 <imode> so you could use it like a stack and a regular queue.
18:42:40 <imode> this means RPN works, but deep stack access is possible.
18:43:31 <arseniiv> also here’s a bad joke I made just few minutes ago and was translating properly: “What do you prefer writing, Sp or tr?” — “I prefer to wipe my shoes”
18:44:22 <arseniiv> hm well it’s even worse in English where trace ≠ track
18:46:01 <b_jonas> arseniiv: you mean a full deque, as oppoed to a queue where you can push on either end but pop only from the start?
18:46:31 <int-e> Wtf is Sp, if not span (which has nothing to do with trace...)?
18:46:33 <arseniiv> b_jonas: either one suffices maybe
18:46:41 <int-e> It's the german "Spur".
18:47:16 <int-e> I should've recognized that immediately. But no... I forgot all the german linear algebra terms it seems.
18:49:46 <arseniiv> I wouldn’t even have an idea of Sp vs. tr if not for encountering Sp yesterday by pure chance
18:51:58 <arseniiv> also what do you all think is more natural for a “half-deque”, pushing from bith sides but popping from only one, or popping from both and pushing from one?
18:52:49 <arseniiv> I don’t know how often these are needed in general
18:52:54 <b_jonas> arseniiv: pushing on both sides and popping from one, because (1) you can implement it with a singly linked list, and
18:53:34 <b_jonas> (2) you can use it to implement a priority queue with only two possible weights, if you don't care which element with the lowest weight is popped
18:54:04 <int-e> arseniiv: I still don't get the joke. It must be really bad ;-)
18:55:06 <b_jonas> wait, aren't those the same, as in Spur vs trace?
18:55:33 <arseniiv> int-e: like, the second person doesn’t leave tracks so they have no need to call trace either way
18:56:17 <b_jonas> or maybe it's trail or track...
18:56:17 <arseniiv> I wonder in what languages trace and foot track are homonymous
18:57:02 <int-e> Hrm. "Spur" is a curious word.
18:58:03 <arseniiv> though I think of a trail as something long and linguistically uncountable and a track as something countable. Though there are tracks like paths or roads, these ones would be different
18:58:19 <int-e> But 'trace' covers a similar spectrum of meanings.
18:58:35 <arseniiv> b_jonas: also thank you about deque
18:59:04 <arseniiv> int-e: I didn’t really thought on it before now
19:00:06 <arseniiv> my fluency is not too high yet maybe, so these things don’t occur as idle thoughts, only when consciously playing
19:02:17 <arseniiv> though I already start to make typos of the “to” instead of “too” kind. I hoped that wouldn’t come
19:02:21 <b_jonas> int-e: nah, I think that's a more normal word than the crazy English triplet trace, track, trail, all three of which can be noun or verb, and any two persons I ask explain the difference among them differently
19:03:40 <int-e> hmm tracking animals by tracing trails
19:04:41 <b_jonas> road vehicles that go to places where there are no roads or even paths can be tracked, which means that there's a continuous strip on two of their wheels and that strip is what gives them traction
19:05:38 <Lykaina> http://sif.lesidhetree.com/sara/echidna/Echidna%20v0_10a0.pdf
19:06:43 <arseniiv> there’s even a DAW called Tracktion. Though they’ve renamed it a while ago
19:12:53 -!- sprocklem has joined.
19:17:16 <esowiki> [[Wutlang]] M https://esolangs.org/w/index.php?diff=66121&oldid=50063 * Dtuser1337 * (-1) /* Commands */
19:17:20 -!- Sgeo has quit (Ping timeout: 276 seconds).
19:38:56 -!- sprocklem has quit (Ping timeout: 246 seconds).
20:39:41 -!- arseniiv has quit (Read error: Connection reset by peer).
20:40:00 -!- arseniiv has joined.
20:45:54 -!- b_jonas has quit (Quit: leaving).
20:53:35 -!- Lord_of_Life_ has joined.
20:56:35 -!- Lord_of_Life has quit (Ping timeout: 265 seconds).
20:56:41 -!- Lord_of_Life_ has changed nick to Lord_of_Life.
20:59:29 <imode> writing a factorial function with a queue is uh... irritating.
21:03:17 -!- xkapastel has quit (Quit: Connection closed for inactivity).
21:04:18 <int-e> imode: Shouldn't be hard as long as you know the size of the queue at each step?
21:04:47 <int-e> I'd expect things to be fairly sane in queue-land until you want to do recursion.
21:05:17 <int-e> (And no, the factorial function isn't recursive unless you want it to be.)
21:05:44 <imode> I know, I wrote an iterative version, now I'm trying to write a recursive version.
21:06:39 <int-e> Yeah, good luck, have fun!
21:06:52 <imode> I got _one_ iteration down.
21:07:35 <int-e> (I guess I'd do the irritating thing where there's a marker in the queue that indicates the end of a simulated stack.)
21:08:00 <imode> yeah, that's the sane part.
21:08:13 <imode> the insane thing is queue juggling via rolling and a 'last' operator, that seeks to the last element in the queue.
21:08:48 <imode> https://hastebin.com/jegujageqe.rb the iterative version.
21:09:29 <imode> the first segment is the shortcode, the middle segment is the "readable" version, the final segment is the line noise version of the first segment.
21:13:06 <imode> 'roll' just dequeues and enqueues an item.
21:13:35 <int-e> <script type="text/javascript" src="https://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js"></script> <script type="text/javascript" src="highlight.min.js"></script> <script type="text/javascript" src="application.min.js"></script>
21:14:59 <imode> I take it I should use hatebin then. :P
21:15:18 <imode> hastebin was down for a non-insignificant amount of time when I last used it.
21:18:30 <int-e> imode: Ugh, does that exist (of course it does, meh.)
21:18:53 <imode> you'd like it. stripped down.
21:18:58 <int-e> <script async src="https://www.googletagmanager.com/gtag/js?id=UA-116452247-1"></script>
21:19:04 <int-e> I don't see anything to like.
21:19:17 <imode> well, I didn't know what you were complaining about. I assumed jquery and highlight.
21:19:29 <int-e> I'm using the Debian pastebin for a reason :)
21:19:37 <int-e> imode: Javascript.
21:20:21 <int-e> Mandatory... fetching the content with XHR. There's no *good* reason for doing that in a pastebin.
21:20:24 -!- ghost2501 has joined.
21:20:26 <imode> until someone does away with the idea of a web browser with arbitrarily executable code being delivered to you, javascript is here to stay. I say that through gritted teeth.
21:22:06 <int-e> It's a losing fight. But it's also a great filter.
21:22:35 <int-e> 90% of the time when a site demands JS I decide I wasn't *that* interested in the content in the first place.
21:24:18 -!- ghost2501 has left ("Leaving").
21:29:54 -!- atslash has joined.
21:34:15 <int-e> imode: Anyway, pastebins are one niche where I see *some* prospect of getting people to use non-JS variants. So I keep bringing it up.
21:47:52 -!- Sgeo has joined.
21:52:28 -!- Sgeo_ has joined.
21:54:03 -!- Sgeo has quit (Ping timeout: 245 seconds).
23:05:46 -!- sprocklem has joined.
23:08:25 -!- FreeFull has quit.
23:10:20 -!- sftp has quit (Excess Flood).
23:10:48 -!- sftp has joined.
23:25:38 -!- Phantom_Hoover has quit (Ping timeout: 240 seconds).
23:35:29 <imode> forget factorial, generating a queue of descending integers is hard. :\
23:35:55 <shachaf> What do you need a queue of descending integers for?
23:36:56 <imode> breaking the problem into two tasks to unblock myself. generate the numbers, then you can interleave the multiplications, etc. into them.
23:37:18 <imode> 5 4 3 2 1 * * * * ...
23:37:21 <shachaf> Multiplying a queue of descending integers? What could that be for?
23:37:46 <imode> I'm working on a queue-based language.
23:37:56 <imode> seeing if I can do some basic things in it.
23:38:02 <imode> like, for instance, a recursive factorial function.
23:38:19 <imode> it's just a product of a range.
23:38:28 <shachaf> Yes, but you said to forget it.
23:41:57 <esowiki> [[Encapsulation]] https://esolangs.org/w/index.php?diff=66122&oldid=66064 * Hakerh400 * (+6) Update computational class
23:47:53 <esowiki> [[Intramodular Transaction]] https://esolangs.org/w/index.php?diff=66123&oldid=66018 * Hakerh400 * (+244) Update computational class
23:51:43 -!- atslash has quit (Quit: Leaving).