←2020-09-01 2020-09-02 2020-09-03→ ↑2020 ↑all
00:16:17 <int-e> b_jonas: I gave it a shot. Won't try again, didn't leave any contact information.
00:16:26 -!- mniip has quit (Ping timeout: 600 seconds).
00:16:54 -!- mniip has joined.
00:22:48 -!- tromp has joined.
00:23:45 -!- tromp_ has quit (Read error: Connection reset by peer).
01:16:39 <esowiki> [[Special:Log/newusers]] create * Me * New user account
01:24:08 -!- Arcorann__ has joined.
01:24:36 -!- Arcorann__ has quit (Remote host closed the connection).
01:25:03 -!- Arcorann__ has joined.
01:41:31 -!- t20kdc has quit (Ping timeout: 256 seconds).
02:12:53 <Cale> Have you guys heard about the new Jace, Mirror Mage combo with Teferi's Ageless Insight?
02:13:44 <Cale> 4 cards per turn
02:15:25 <Cale> Because Insight replaces the draw effect, the second half doesn't go off and so Jace doesn't lose loyalty.
02:15:34 <shachaf> I don't know either of those cards.
02:16:00 <shachaf> whoa, why doesn't the second half go off?
02:16:01 <shachaf> Oh, I see.
02:16:06 <shachaf> It's because the CMC is effectively zero?
02:16:48 <Cale> 614.11b If an effect would have a player both draw a card and perform an additional action on that card, and the draw is replaced, the additional action is not performed on any cards that are drawn as a result of that replacement effect.
02:17:25 <shachaf> Aha.
02:18:01 <shachaf> Why four and not three cards per turn?
02:18:04 <shachaf> Oh, is it the kicker?
02:18:05 <zzo38> I have not seen those cards (or maybe I have, but do not remember).
02:18:09 <Cale> Yeah, the kicker
02:18:16 <Cale> This is the just-spoiled new Jace
02:19:23 <shachaf> So it's a total of five cards per turn including the draw step?
02:19:29 <Cale> yeah
02:19:42 <shachaf> That's a lot of cards.
02:20:05 <shachaf> Cale: Remind me, did you slay any spires?
02:20:13 <Cale> Long ago, I did
02:20:16 <zzo38> I have not seen it, so copy the text here so that we can see, I suppose
02:21:01 <Cale> Card Name:
02:21:01 <Cale> Teferi's Ageless Insight
02:21:01 <Cale> Mana Cost:
02:21:01 <Cale> 2BlueBlue
02:21:01 <Cale> Converted Mana Cost:
02:21:02 <Cale> 4
02:21:03 <Cale> Types:
02:21:05 <Cale> Legendary Enchantment
02:21:07 <Cale> Card Text:
02:21:11 <Cale> If you would draw a card except the first one you draw in each of your draw steps, draw two cards instead.
02:21:23 <Cale> Jace, Mirror Mage {1}{U}{U}
02:21:23 <Cale> Legendary Planeswalker — Jace
02:21:23 <Cale> Kicker {2}
02:21:23 <Cale> When Jace, Mirror Mage enters the battlefield, if Jace was kicked, create a token that’s a copy of Jace, Mirror Mage except it’s not legendary and its starting loyalty is 1.
02:21:23 <Cale> +1: Scry 2.
02:21:25 <Cale> 0: Draw a card and reveal it. Remove a number of loyalty counters equal to that card’s converted mana cost from Jace, Mirror Mage.
02:21:28 <Cale> Loyalty: 4
02:22:03 <zzo38> Next time you could use the abbreviated single line format like I do, perhaps.
02:22:20 <Cale> ah, I don't know how to get nice copy/pasteable text for cards
02:22:35 <Cale> I just googled them and copy/pasted from the first results I could find
02:23:14 <zzo38> (It also looks like whoever typed that has entered bad alt text for the mana symbols. Alt text is the text that should be displayed when the image isn't displayed.)
02:27:05 <shachaf> You also didn't include the flavor text.
02:28:27 <zzo38> That is OK, though; for what you were discussing, flavor text (and art) is not relevant.
02:31:26 <zzo38> Do you like the abbreviated single line format that I like to use?
02:34:06 <Cale> I think so
02:38:57 <shachaf> `card-by-name teferi's ageless insight
02:38:58 <HackEso> No output.
02:39:05 <shachaf> Must not be updated for M21.
02:39:13 <shachaf> `random-card
02:39:14 <HackEso> Desert of the True \ Land -- Desert \ Desert of the True enters the battlefield tapped. \ {T}: Add {W}. \ Cycling {1}{W} ({1}{W}, Discard this card: Draw a card.) \ HOU-C
03:25:19 <spruit11> Neat, there goes the moneyz again. Anything else to look forward to?
03:25:30 <spruit11> I'll check the spoilers.
04:02:57 -!- xelxebar has quit (Remote host closed the connection).
04:04:07 -!- xelxebar has joined.
04:49:25 -!- Lord_of_Life has quit (Ping timeout: 240 seconds).
04:49:47 -!- Lord_of_Life has joined.
05:03:27 <zzo38> How to construct a va_list dynamically in C?
05:08:10 <shachaf> I don't think there's a portable way to do it.
05:08:17 <shachaf> Presumably you can make one based on the ABI.
05:09:05 <shachaf> You can also do something like http://www.talchas.net/tape.c
05:28:39 <zzo38> How common was it in various periods of history (including now) for someone to learn to read and write Latin but not to speak Latin (although they could speak other languages)?
05:50:57 -!- diverger has quit (Ping timeout: 260 seconds).
05:52:40 -!- diverger has joined.
05:58:08 -!- olsner has quit (Ping timeout: 256 seconds).
06:00:55 -!- pikhq has quit (Ping timeout: 240 seconds).
06:03:07 -!- pikhq has joined.
06:14:43 -!- olsner has joined.
06:45:49 -!- olsner has quit (Ping timeout: 264 seconds).
06:51:19 -!- olsner has joined.
06:54:42 -!- Sgeo has quit (Read error: Connection reset by peer).
06:57:21 -!- LKoen has joined.
07:28:53 -!- LKoen has quit (Quit: “It’s only logical. First you learn to talk, then you learn to think. Too bad it’s not the other way round.”).
07:32:00 -!- kspalaiologos has joined.
07:38:25 -!- imode has quit (Ping timeout: 240 seconds).
07:40:22 -!- kspalaiologos has quit (Quit: leaving).
08:03:21 -!- cpressey has joined.
08:20:15 -!- kritixilithos has joined.
09:22:34 -!- sprocklem has quit (Ping timeout: 258 seconds).
09:22:52 -!- sprocklem has joined.
09:37:08 -!- sprocklem has quit (Ping timeout: 258 seconds).
09:55:09 -!- tromp has quit (Remote host closed the connection).
09:55:26 -!- tromp has joined.
09:55:41 <int-e> b_jonas: http://www.madore.org/cgi-bin/comment.pl/showcomments?href=http%3a%2f%2fwww.madore.org%2f~david%2fweblog%2f2011-04.html%23d.2011-04-25.1871#comment-27034
09:56:08 <int-e> (funny link, hmm)
09:56:51 -!- Sinthorion has joined.
10:02:44 -!- arseniiv has joined.
10:12:01 <kritixilithos> int-e: https://codegolf.stackexchange.com/a/75326 ties yours
10:15:12 <int-e> kritixilithos: I love being second... :P
10:17:37 <int-e> kritixilithos: But I wasn't aware of that post. I stumbled across this problem near the end of last year because somebody posted https://github.com/olligobber/DivisibilityRegex which isn't quite optimal. Not sure where that happened; ##math is my guess.
10:17:51 <int-e> But it could also have been here; the logs could tell :P
10:19:57 <int-e> I did bring it up here, but I still think it started on ##math. https://esolangs.org/logs/2019-11-02.html#lle
10:23:52 <b_jonas> int-e: nice
10:24:56 <b_jonas> kritixilithos: oh! so it's already on golf.se. I'll definitely link that then
10:25:41 <b_jonas> and yes, that shows the short PCRE solution using the recursion extension
10:26:07 <int-e> I wonder whether that method for converting FAs to regular expressions is published. It's rather obvious (I think) so I'm not surprised that somebody else is using it too.
10:27:14 <kritixilithos> int-e: https://codegolf.stackexchange.com/a/75326 ties yours
10:27:23 <int-e> kritixilithos: deja vu
10:27:47 <kritixilithos> whoops that was accidental
10:28:23 <int-e> b_jonas: "recursion extension", is that what it's called?
10:29:17 <int-e> hmm, should ask a search engine... leaning towards "no".
10:29:19 <b_jonas> int-e: I don't know, I'd have to look at old versions of perl's manpages to know the canonical name, but it allows you to describe context-free grammars using recusions, which was I think the original goal, like describing nested parenthesis
10:30:20 <b_jonas> the strange thing is, David Madore's post isn't even from like 1997, preceding the whole SE, it's only older by a few months than the Golf SE post
10:30:24 <b_jonas> weird
10:31:41 <b_jonas> and in fact, it looks like the Golf SE post is motivated by code on github that is even older than David's post
10:31:41 <int-e> maybe somebody asked several people that question around the time
10:44:59 <kritixilithos> b_jonas: okay, posted it as a comment
10:49:31 <b_jonas> kritixilithos: we cross-posted then
10:49:35 <b_jonas> oh well
10:56:35 <b_jonas> `pbflist https://pbfcomics.com/comics/lucky-day/
10:56:37 <HackEso> pbflist https://pbfcomics.com/comics/lucky-day/: shachaf Sgeo quintopia ion b_jonas Cale
11:05:03 -!- kritixilithos has quit (Ping timeout: 240 seconds).
11:12:42 <Sinthorion> Has anyone ever formalised some definition of "IO complete"/"perfect IO", ie. the ability of a machine to read and print any given string, with the output depending on the input?
11:16:45 <cpressey> I think people are generally satisfied with the idea that any given string can be mapped to a natural number, and that there exist functions that take natural numbers to natural numbers, and some of those functions can be computed by Turing machine
11:22:32 <b_jonas> Sinthorion: interactive or non-interactive?
11:23:34 <Sinthorion> non-interactive is enough
11:24:01 <Sinthorion> we talked about this a bit on the esolangs discord server
11:25:51 -!- kritixilithos has joined.
11:26:46 -!- spruit11 has quit (Quit: Lost terminal).
11:37:03 -!- cpressey has quit (Quit: WeeChat 1.9.1).
11:51:23 -!- kritixilithos has quit (Ping timeout: 240 seconds).
12:17:35 -!- spruit11 has joined.
12:28:57 -!- kritixilithos has joined.
12:29:58 -!- Sinthorion has quit (Remote host closed the connection).
13:06:16 -!- t20kdc has joined.
13:22:29 -!- Arcorann__ has quit (Read error: Connection reset by peer).
13:22:55 -!- Arcorann__ has joined.
13:28:35 <arseniiv> I wonder how mostrous would be an esolang which uses a generalized Minsky machine operating on Haskell-like strings, as there would be a end-of-string constructor and a constructor *for each Unicode codepoint*, and the primitive recursion operator takes such many arguments. Of course one could cheat and make so that it takes only several explicit arguments and all others are taken to be (λx1 … xn. "") but as I said that’s not the s
13:28:36 <arseniiv> pirit at all
13:28:36 <arseniiv> wait, I mixed GMM with generalized recursive functions. They are almost one and the same, in GMM instead of recursion operator we’d have a destructor which takes one input register and a hell of output registers, one for each constructor, and also the same number of continuation states. We can cheat the same way here, specifying a “default” continuation state and a “default” output register, and again I would be against doing
13:28:36 <arseniiv> that :P the tarpit should remain a tarpit
13:30:01 <spruit11> Heh, there's always one more tiny thing to do before I declare the interpreter beta.
13:37:55 -!- hendursaga has quit (Quit: hendursaga).
13:38:16 -!- hendursaga has joined.
14:04:43 <b_jonas> spruit11: what does declaring it beta actually mean?
14:05:11 <b_jonas> for the egel interpreter that is
14:17:09 -!- cpressey has joined.
14:26:18 <spruit11> That I feel confident about the core functionality of the rewriter, and that the interpreter is in a good enough stage. Basically, that I wouldn't expect any show stoppers anymore.
14:26:21 -!- Arcorann__ has quit (Read error: Connection reset by peer).
14:31:05 <int-e> . o O ( beta is where software goes to die )
14:31:44 <spruit11> It's barely alive anyway!
14:32:05 <b_jonas> undead software!
14:48:03 -!- Mirage48 has joined.
14:48:08 <Mirage48> Hi
14:58:43 -!- Sgeo has joined.
15:05:42 <b_jonas> `olist 1213
15:05:44 <HackEso> olist https://www.giantitp.com/comics/oots1213.html: shachaf oerjan Sgeo FireFly boily nortti b_jonas
15:13:57 <Mirage48> here's something i made o a whim
15:13:58 <Mirage48> MowrMowr is ran on an infinte 2-dimensional lawn that is not mown (all 1s) . Wile the mower is on, moving over unmown grass will mow it (turn it into a 0).If there is any input, the bits of the input are formed into an-odd length square centered around the mower in reading order. Extra cells are unmowed (1)Note that the main chore (program) loops
15:13:59 <Mirage48> until you have a break. After all, it is an infinite lawn.Mowr supports the following commands.` - Pushes the mower forward.LR - Turns the mower left/right.! - Switches the mower on/off (default off)? - Turns the mower left if the mower is on mown grass, otherwise turns right.O - outputs the bit the mower is on. If on the initial cell, finish
15:13:59 <Mirage48> mowing the lawn (halt without outputting.).() - Delimits a subchore (loop) Escaped the same way as the main chore.
15:15:18 <spruit11> Really nice!
15:15:21 <spruit11> Link?
15:16:44 <arseniiv> <b_jonas> undead software! => but maybe that’s only after gamma
15:17:42 <Mirage48> i haven't made anything yet
15:17:46 <Mirage48> spruit11
15:18:00 <Mirage48> just putting down ideas
15:18:15 <b_jonas> Mirage48: that... might work, I dunno. the loop condition seems suspicious. but I don't understand why you flavor this as mowing, since there are no stones or other obstacles.
15:19:27 <Mirage48> just an idea that popped into my head
15:19:43 <Mirage48> The inital cell is where the ch\ore was stated, just to clarify
15:19:48 <Mirage48> *chore
15:22:10 <b_jonas> what? but that's even worse!
15:22:28 <Mirage48> yeah i know
15:22:42 <arseniiv> maybe what we need is actually a Clifford-algebraic language. Like, you take an algebra of dimension the same as input length, and generator vectors having squares ±1 depending on the corresponding bit of the input. Now, a program can’t be a term of a fixed size as that won’t be able to process arbitrary-length input. Instead, one can write something like a convolution kernel. Hm but how exactly…
15:23:12 <Mirage48> what?
15:23:25 <arseniiv> exactly!
15:23:44 <arseniiv> Clifford algebras are the absolute best in the world
15:24:33 <arseniiv> sorry, sorry, but this half-idea may be promising
15:25:07 -!- tchibo has joined.
15:25:15 <arseniiv> and also a horror to implrment. The algebra for N generators has dimension 2^N
15:25:41 <arseniiv> so it one uses it sufficiently fully, the implementor couldn’t cheat
15:25:50 <tchibo> hi people
15:26:02 <arseniiv> `relcome tchibo
15:26:06 <HackEso> tchibo: Welcome to the international hub for esoteric programming language design and deployment! For more information, check out our wiki: <https://esolangs.org/>. (For the other kind of esoterica, try #esoteric on EFnet or DALnet.)
15:27:37 <tchibo> thx, not a mistake
15:29:23 <cpressey> How about an esolang that uses naive datetimes and requires somehow that they ambiguously reference UTC times. So that programs only have meaning if they are run during that hour in the autumn before the clocks are set back.
15:30:34 <tchibo> I just registered on the wiki to introduce my first language, not very esoteric, was curious if there is life on the chat
15:30:56 <b_jonas> cpressey: is that like 2014?
15:31:58 <cpressey> b_jonas: yes, it's exacly like 2014, for some value of 2014
15:33:04 -!- egelbot has joined.
15:33:53 <spruit11> egelbot: 9-5 # because of b_jonas I reversed a decision and implemented normal monadic min behavior again.
15:33:53 <egelbot> 4
15:34:44 <b_jonas> egelobt: 9+5
15:34:51 <b_jonas> [ 9+5
15:34:52 <j-bot> b_jonas: 14
15:34:59 <b_jonas> egelbot: 9+5
15:34:59 <egelbot> 14
15:36:13 <spruit11> egelbot: -1
15:36:14 <egelbot> -1
15:37:08 <arseniiv> tchibo: there is. Though it’s highly irregular. May be a day or two in silence, only esowiki dumping page modifications
15:37:40 <tchibo> ic
15:39:25 <tchibo> my kingdom for a charger
15:40:49 <arseniiv> I think I’m ready to dump my Clifford algebra idea on the wiki but I don’t want to analyze what computational complexity it will give
15:44:11 <b_jonas> what kind of charger?
15:44:34 <b_jonas> and what kingdom?
16:05:51 -!- cpressey has quit (Quit: WeeChat 1.9.1).
16:11:26 <esowiki> [[Cyclifford]] N https://esolangs.org/w/index.php?oldid=77178 * Arseniiv * (+1491) Created page with "'''Cyclifford''' is a silly idea of a language by [[User:arseniiv]], based on [[wikipedia:Clifford algebra|Clifford algebra]]s. The program is an expression consisting of int..."
16:12:27 <arseniiv> of int-e no less
16:12:43 <arseniiv> no one will know for sure until reads the article mwhahahah
16:16:13 <esowiki> [[User:Arseniiv]] M https://esolangs.org/w/index.php?diff=77179&oldid=74975 * Arseniiv * (+90) book-keeping
16:23:48 -!- adu has joined.
16:33:25 -!- Mirage48 has quit (Ping timeout: 245 seconds).
16:49:50 -!- Lord_of_Life_ has joined.
16:51:45 -!- Lord_of_Life has quit (Ping timeout: 240 seconds).
16:51:45 -!- Lord_of_Life_ has changed nick to Lord_of_Life.
17:17:39 -!- egelbot has quit (Remote host closed the connection).
17:19:03 -!- kritixilithos has quit (Ping timeout: 240 seconds).
17:21:38 -!- egelbot has joined.
17:21:43 <spruit11> egelbot: val myglobal = ref 0;; setref myglobal [X->X]; getref myglobal "hello all" #no language is feature complete without global variables
17:21:43 <egelbot> "hello all"
17:29:27 -!- LKoen has joined.
17:38:18 <esowiki> [[User:SunnyMoon]] M https://esolangs.org/w/index.php?diff=77180&oldid=77169 * SunnyMoon * (+49) School update.
17:39:46 <esowiki> [[User:SunnyMoon]] M https://esolangs.org/w/index.php?diff=77181&oldid=77180 * SunnyMoon * (+0) Grammatical Wiki error.
17:40:55 <b_jonas> spruit11: oh, arbitrary mutable references?
17:41:02 <b_jonas> that makes this MUCH more powerful
17:42:51 <esowiki> [[Anyfix]] M https://esolangs.org/w/index.php?diff=77182&oldid=67569 * SunnyMoon * (-1) What are you doing here, paranthesis?
17:50:38 -!- tchibo has quit (Remote host closed the connection).
17:50:45 -!- kritixilithos has joined.
17:52:01 -!- adu has quit (Quit: adu).
17:57:32 -!- adu has joined.
18:24:13 -!- adu has quit (Ping timeout: 258 seconds).
18:26:21 -!- kritixilithos has quit (Remote host closed the connection).
18:26:43 -!- kritixilithos has joined.
18:26:53 -!- adu has joined.
19:03:56 -!- adu has quit (Ping timeout: 265 seconds).
19:11:12 -!- kritixilithos has quit (Quit: quit).
19:11:31 -!- adu has joined.
19:20:41 -!- adu has quit (Ping timeout: 246 seconds).
19:28:34 -!- LKoen has quit (Remote host closed the connection).
19:34:45 <spruit11> Right, power is what I crave.
19:35:18 <b_jonas> ref, setref, getref? I might try that
19:39:36 <spruit11> Yah. No cycles though.
19:39:51 <b_jonas> how is it no cycles?
19:40:00 <spruit11> But I am confident you can work around that.
19:40:21 <b_jonas> egelbot: [R -> setref R R] (ref 0)
19:40:21 <egelbot> <System:reference>
19:40:23 <spruit11> Oh, you can do cycles. But then the structures won't gc.
19:40:35 <b_jonas> ah ok, that makes more sense
19:41:17 <spruit11> I might try a stress test locally and see how fast egel can leak.
19:41:39 <spruit11> Maybe a bit of abuse isn't that bad.
19:52:53 <spruit11> Not sure what I expected except that you don't really notice for small shortlived scripts. And that egel is slow.
19:52:56 <spruit11> Ah well.
19:56:38 <spruit11> Pffrt, how do you measure how much memory a process consumed on linux. Something simpler than valgrind.
19:56:43 <spruit11> ?
19:58:10 <Sgeo> What language is this?
19:58:18 <spruit11> Egel.
19:58:23 <spruit11> egelbot: agitprop
19:58:23 <egelbot> visit https://egel-lang.github.io/
20:40:57 -!- sprocklem has joined.
21:13:24 <b_jonas> egelbot: def listrev_a = [ S nil -> S| S (cons A D) -> listrev_a (cons A S) D ];; def listrev = listrev_a {};; listrev {8,2,13,59,75}
21:13:25 <egelbot> {75, 59, 13, 2, 8}
21:18:14 <spruit11> Ah. I tried to analyze your script and didn't get any further that you like accumulators.
21:19:43 <spruit11> If you want a challenge: read it and weep https://github.com/egel-lang/egel/blob/master/examples/bintrees.eg
21:19:56 <b_jonas> spruit11: well it's an eager pure functional language. at least it was, until you added this new mutability feature. I have to program it like an eager functional programming language.
21:20:01 <b_jonas> egelbot: data mcons;; data mnil;; data mhdr;; def mempty = [N -> ref (mhdr N N)] (ref mnil);; def mpush = [A H -> [(mhdr F T) U -> setref T (mcons A U); setref H (mhdr F U) | _ _ -> throw "error mpush"] (getref H) (ref mnil) ];; def munlist = [H -> [(mhdr F _) -> listrev ([R N -> R R {} N] [R P mnil -> A | R P (cons A D) -> R R (cons A P) (getref D) -> | _ _ _ -> error "munlist" ] (getref F)) ] ]
21:20:01 <egelbot> internal:1:346:syntactical:] expected
21:20:07 <b_jonas> (getref H) ];; "ok"
21:20:19 <b_jonas> egelbot: data mcons;; data mnil;; data mhdr;; def mempty = [N -> ref (mhdr N N)] (ref mnil);; def mpush = [A H -> [(mhdr F T) U -> setref T (mcons A U); setref H (mhdr F U) | _ _ -> throw "error mpush"] (getref H) (ref mnil) ];; "ok"
21:20:19 <egelbot> "ok"
21:22:15 <b_jonas> egelbot: def munlist = [H -> [(mhdr F _) -> [R N -> listrev (R R {} N)] [R P mnil -> A | R P (cons A D) -> R R (cons A P) (getref D) -> | _ _ _ -> error "munlist" ] (getref F) | _ -> throw "munlist h" ] (getref H) ];; "ok"
21:22:16 <egelbot> internal:1:126:syntactical:] expected
21:22:51 <b_jonas> egelbot: def munlist = [H -> [(mhdr F _) -> [R N -> listrev (R R {} N)] [R P mnil -> A | R P (cons A D) -> R R (cons A P) (getref D) | _ _ _ -> error "munlist" ] (getref F) | _ -> throw "munlist h" ] (getref H) ];; "ok"
21:22:51 <egelbot> internal:1:78:semantical:undeclared A
21:22:59 <b_jonas> egelbot: def munlist = [H -> [(mhdr F _) -> [R N -> listrev (R R {} N)] [R P mnil -> P | R P (cons A D) -> R R (cons A P) (getref D) | _ _ _ -> error "munlist" ] (getref F) | _ -> throw "munlist h" ] (getref H) ];; "ok"
21:22:59 <egelbot> internal:1:137:semantical:undeclared error
21:23:08 <b_jonas> egelbot: def munlist = [H -> [(mhdr F _) -> [R N -> listrev (R R {} N)] [R P mnil -> P | R P (cons A D) -> R R (cons A P) (getref D) | _ _ _ -> throw "munlist" ] (getref F) | _ -> throw "munlist h" ] (getref H) ];; "ok"
21:23:08 <egelbot> "ok"
21:23:26 <b_jonas> egelbot: mempty
21:23:26 <egelbot> <System:reference>
21:23:29 <b_jonas> egelbot: getref mempty
21:23:29 <egelbot> (mhdr <System:reference> <System:reference>)
21:24:28 <b_jonas> egelbot: [M -> mpush 8 M; mpush 22 M; mpush 13 M; mpush 59 M; mpush 75 M; munlist M] mempty
21:24:28 <egelbot> exception("munlist")
21:25:13 <b_jonas> egelbot: def munlist = [H -> [(mhdr F _) -> [R N -> listrev (R R {} N)] [R P mnil -> P | R P (cons A D) -> R R (cons A P) (getref D) | _ NN PP -> throw ("munlist",NN,PP) ] (getref F) | _ -> throw "munlist h" ] (getref H) ];; "ok"
21:25:13 <egelbot> "ok"
21:25:17 <b_jonas> egelbot: [M -> mpush 8 M; mpush 22 M; mpush 13 M; mpush 59 M; mpush 75 M; munlist M] mempty
21:25:17 <egelbot> exception(("munlist", {}, (mcons 8 <System:reference>)))
21:25:26 <b_jonas> mcons, right
21:25:38 <b_jonas> egelbot: def munlist = [H -> [(mhdr F _) -> [R N -> listrev (R R {} N)] [R P mnil -> P | R P (mcons A D) -> R R (cons A P) (getref D) | _ NN PP -> throw ("munlist",NN,PP) ] (getref F) | _ -> throw "munlist h" ] (getref H) ];; "ok"
21:25:38 <egelbot> "ok"
21:25:42 <b_jonas> egelbot: [M -> mpush 8 M; mpush 22 M; mpush 13 M; mpush 59 M; mpush 75 M; munlist M] mempty
21:25:42 <egelbot> {8, 22, 13, 59, 75}
21:25:45 <b_jonas> YES
21:27:41 <spruit11> Nice.
21:27:59 <b_jonas> egelbot: def mextend = [nil H -> nop | (cons A D) H -> mpush A H; mextend D H | _ _-> throw "mextend" ];; mlist = [M L -> mextend L M; M] mempty
21:27:59 <egelbot> internal:1:105:syntactical:= unexpected
21:28:05 <b_jonas> egelbot: def mextend = [nil H -> nop | (cons A D) H -> mpush A H; mextend D H | _ _-> throw "mextend" ];; def mlist = [M L -> mextend L M; M] mempty
21:28:18 <b_jonas> egelbot: munlist mlist {8,22,13,59,75}
21:28:18 <egelbot> exception("System:getref bad arguments")
21:28:32 <b_jonas> egelbot: mlist {8,22,13,59,75}
21:28:32 <egelbot> <System:reference>
21:28:38 <b_jonas> egelbot: getref (mlist {8,22,13,59,75})
21:28:38 <egelbot> (mhdr <System:reference> <System:reference>)
21:28:50 <b_jonas> egelbot: [F T -> (getref F, getref T)] getref (mlist {8,22,13,59,75})
21:28:51 <egelbot> exception("System:getref bad arguments")
21:28:58 <b_jonas> egelbot: [(mhdr F T) -> (getref F, getref T)] getref (mlist {8,22,13,59,75})
21:28:58 <egelbot> (Local:Dummy170 System:getref <System:reference>)
21:29:20 <b_jonas> egelbot: [(mhdr F T) -> (getref F, getref T)] (getref (mlist {8,22,13,59,75}))
21:29:20 <egelbot> ((mcons 8 <System:reference>), mnil)
21:29:20 <spruit11> I am not sure you gain much by using an accumulator. I have the feeling it just changes the order of calculations. Need to check that once.
21:29:32 <spruit11> But watching a movie and profiling.
21:29:43 <b_jonas> spruit11: I wouldn't gain much *now* when I could just use mutability everywhere
21:30:01 <b_jonas> I don't need to use pure structures anymore, so it's possible to dispense with accumulators
21:30:14 <b_jonas> but I wrote that program when it was a pure language
21:30:17 <b_jonas> please consider that
21:30:27 <b_jonas> and you even said you don't really want to add mutability
21:30:32 <spruit11> Yah, sure. I was thinking about that program.
21:31:08 <spruit11> I should matter in memory consumption but not much in performance, I have the feeling now.
21:31:11 <b_jonas> if it's an eager pure functional language, you hvae to use accumulators
21:31:20 <spruit11> *ut
21:31:38 <spruit11> Oh gawd. I am going back to watching this movie.
21:31:56 <b_jonas> egelbot: [(mhdr F T) -> (getref F, getref T)] (getref (mlist {8,22,13,59,75}))
21:31:56 <egelbot> ((mcons 8 <System:reference>), mnil)
21:33:47 <b_jonas> egelbot: [MA, MD, (mhdr F T) -> MA F] [N -> [(mcons A D)->D] (getref N)] [N -> [(mcons A D)->A] (getref N)] (getref (mlist {8,22,13,59,75}))
21:33:47 <egelbot> internal:1:5:syntactical:-> expected
21:34:08 <b_jonas> egelbot: [MA MD (mhdr F T) -> MA F] [N -> [(mcons A D)->D] (getref N)] [N -> [(mcons A D)->A] (getref N)] (getref (mlist {8,22,13,59,75}))
21:34:08 <egelbot> <System:reference>
21:34:14 <b_jonas> what?
21:34:30 <b_jonas> egelbot: [MD MA (mhdr F T) -> MA F] [N -> [(mcons A D)->D] (getref N)] [N -> [(mcons A D)->A] (getref N)] (getref (mlist {8,22,13,59,75}))
21:34:30 <egelbot> 8
21:34:33 <b_jonas> better
21:34:36 <b_jonas> egelbot: [MD MA (mhdr F T) -> MA MD F] [N -> [(mcons A D)->D] (getref N)] [N -> [(mcons A D)->A] (getref N)] (getref (mlist {8,22,13,59,75}))
21:34:36 <egelbot> exception("System:getref bad arguments")
21:34:41 <b_jonas> egelbot: [MD MA (mhdr F T) -> MD F] [N -> [(mcons A D)->D] (getref N)] [N -> [(mcons A D)->A] (getref N)] (getref (mlist {8,22,13,59,75}))
21:34:41 <egelbot> <System:reference>
21:34:48 <b_jonas> egelbot: [MD MA (mhdr F T) -> getref (MD F)] [N -> [(mcons A D)->D] (getref N)] [N -> [(mcons A D)->A] (getref N)] (getref (mlist {8,22,13,59,75}))
21:34:48 <egelbot> (mcons 22 <System:reference>)
21:34:52 <b_jonas> egelbot: [MD MA (mhdr F T) -> MA (MD F)] [N -> [(mcons A D)->D] (getref N)] [N -> [(mcons A D)->A] (getref N)] (getref (mlist {8,22,13,59,75}))
21:34:52 <egelbot> 22
21:34:56 <b_jonas> egelbot: [MD MA (mhdr F T) -> MD (MD F)] [N -> [(mcons A D)->D] (getref N)] [N -> [(mcons A D)->A] (getref N)] (getref (mlist {8,22,13,59,75}))
21:34:56 <egelbot> <System:reference>
21:35:04 <b_jonas> egelbot: [MD MA (mhdr F T) -> getref (MD (MD F))] [N -> [(mcons A D)->D] (getref N)] [N -> [(mcons A D)->A] (getref N)] (getref (mlist {8,22,13,59,75}))
21:35:04 <egelbot> (mcons 13 <System:reference>)
21:35:09 <b_jonas> egelbot: [MD MA (mhdr F T) -> getref (MD (MD (MD F)))] [N -> [(mcons A D)->D] (getref N)] [N -> [(mcons A D)->A] (getref N)] (getref (mlist {8,22,13,59,75}))
21:35:09 <egelbot> (mcons 59 <System:reference>)
21:35:15 <b_jonas> egelbot: [MD MA (mhdr F T) -> getref (MD (MD (MD (MD F))))] [N -> [(mcons A D)->D] (getref N)] [N -> [(mcons A D)->A] (getref N)] (getref (mlist {8,22,13,59,75}))
21:35:15 <egelbot> (mcons 75 <System:reference>)
21:35:22 <b_jonas> egelbot: [MD MA (mhdr F T) -> getref (MD (MD (MD (MD (MD F)))))] [N -> [(mcons A D)->D] (getref N)] [N -> [(mcons A D)->A] (getref N)] (getref (mlist {8,22,13,59,75}))
21:35:22 <egelbot> mnil
21:35:27 <b_jonas> then what's the problem?
21:35:46 <b_jonas> egelbot: munlist (mlist {8,22,13,59,75})
21:35:46 <egelbot> {8, 22, 13, 59, 75}
21:35:56 <b_jonas> why wasn't that working before?
21:36:19 <b_jonas> ah
21:36:22 <b_jonas> I was missing the paren
21:36:25 <b_jonas> darn
21:50:04 -!- imode has joined.
21:55:50 -!- LKoen has joined.
21:58:59 -!- olsner has quit (Ping timeout: 240 seconds).
21:59:53 -!- myname has quit (*.net *.split).
21:59:59 -!- myname has joined.
22:03:35 -!- olsner has joined.
22:40:43 -!- LKoen has quit (Remote host closed the connection).
22:55:14 -!- tromp_ has joined.
22:58:26 -!- tromp has quit (Ping timeout: 240 seconds).
23:04:21 <b_jonas> egelbot: mprime_i = [C M->[R(mhdr F _)->R R (getref F)] [R (mcons A D)-> [true _->true| _ true->false| _ _->R R (getref D) ] (0==(C%A)) (C<A*A) | _ _->throw"error mprime_i"] M];; "ok"
23:04:22 <egelbot> internal:1:11:syntactical:= unexpected
23:04:25 <b_jonas> egelbot: def mprime_i = [C M->[R(mhdr F _)->R R (getref F)] [R (mcons A D)-> [true _->true| _ true->false| _ _->R R (getref D) ] (0==(C%A)) (C<A*A) | _ _->throw"error mprime_i"] M];; "ok"
23:04:26 <egelbot> "ok"
23:04:53 <b_jonas> egelbot: mprime_i 12 (mlist{2,3,5,7,11})
23:04:53 <egelbot> (Local:mprime_i0 (Local:mprime_i2 12) <System:reference>)
23:06:00 <b_jonas> egelbot: def mprime_i = [C M->[R(mhdr F _)->R R (getref F)|_ _->throw"error mprime_i h"] [R (mcons A D)-> [true _->true| _ true->false| _ _->R R (getref D) ] (0==(C%A)) (C<A*A) | _ _->throw"error mprime_i"] M];; "ok"
23:06:00 <egelbot> "ok"
23:06:04 <b_jonas> egelbot: mprime_i 12 (mlist{2,3,5,7,11})
23:06:04 <egelbot> exception("error mprime_i h")
23:07:07 <b_jonas> oh
23:07:42 <b_jonas> no, I don't get it
23:08:15 <b_jonas> egelbot: def mprime_i = [C M->[R(mhdr F _)->R R (getref F)|_ _->throw("error mprime_i h",] [R (mcons A D)-> [true _->true| _ true->false| _ _->R R (getref D) ] (0==(C%A)) (C<A*A) | _ _->throw"error mprime_i"](getref M)];; "ok"
23:08:15 <egelbot> internal:1:82:syntactical:primary expression expected
23:08:40 <b_jonas> egelbot: def mprime_i = [C M->[R(mhdr F _)->R R (getref F)|_ _->throw"error mprime_i h"] [R (mcons A D)-> [true _->true| _ true->false| _ _->R R (getref D) ] (0==(C%A)) (C<A*A) | _ _->throw"error mprime_i"] (getref M)];; "ok"
23:08:40 <egelbot> "ok"
23:08:46 <b_jonas> egelbot: mprime_i 12 (mlist{2,3,5,7,11})
23:08:46 <egelbot> System:true
23:08:49 <b_jonas> egelbot: mprime_i 13 (mlist{2,3,5,7,11})
23:08:49 <egelbot> System:false
23:08:51 <b_jonas> egelbot: mprime_i 14 (mlist{2,3,5,7,11})
23:08:51 <egelbot> System:true
23:08:54 <b_jonas> egelbot: mprime_i 15 (mlist{2,3,5,7,11})
23:08:54 <egelbot> System:true
23:08:58 <b_jonas> egelbot: mprime_i 17 (mlist{2,3,5,7,11})
23:08:58 <egelbot> System:false
23:09:02 <b_jonas> egelbot: mprime_i 19 (mlist{2,3,5,7,11})
23:09:02 <egelbot> System:false
23:09:04 <b_jonas> egelbot: mprime_i 21 (mlist{2,3,5,7,11})
23:09:04 <egelbot> System:true
23:09:11 <b_jonas> ok, so
23:15:56 <b_jonas> egelbot: mprime = [M B->[R->R R 3] [R F-> [true-> [true->mpush F M| _->nop] (mprime_i F M); R R (1+F) |_->munlist M] (F<B) ] ](mlist 2)
23:15:56 <egelbot> internal:1:9:syntactical:= unexpected
23:16:12 <b_jonas> egelbot: def mprime = [M B->[R->R R 3] [R F-> [true-> [true->mpush F M| _->nop] (mprime_i F M); R R (1+F) |_->munlist M] (F<B) ] ](mlist 2); mprime 30
23:16:28 <b_jonas> egelbot: "are you ok?"
23:16:28 <egelbot> "are you ok?"
23:16:33 <b_jonas> hmm
23:16:56 <b_jonas> egelbot: def mprime = [M B->[R->R R 3] [R F-> [true-> [true->mpush F M| _->"irrelevant"] (mprime_i F M); R R (1+F) |_->munlist M] (F<B) ] ](mlist 2); mprime 30
23:17:06 <spruit11> You missed a semicolon?
23:17:09 <b_jonas> ah
23:17:26 <b_jonas> egelbot: def mprime = [M B->[R->R R 3] [R F-> [true-> [true->mpush F M| _->"?"] (mprime_i F M); R R (1+F) |_->munlist M] (F<B) ] ](mlist 2);; mprime 30
23:17:26 <egelbot> exception("mextend")
23:17:36 <b_jonas> egelbot: def mprime = [M B->[R->R R 3] [R F-> [true-> [true->mpush F M| _->"?"] (mprime_i F M); R R (1+F) |_->munlist M] (F<B) ] ](mlist{2});; mprime 30
23:17:36 <egelbot> {2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28}
23:17:39 <b_jonas> er no
23:17:45 <b_jonas> egelbot: def mprime = [M B->[R->R R 3] [R F-> [true-> [false->mpush F M| _->"?"] (mprime_i F M); R R (1+F) |_->munlist M] (F<B) ] ](mlist{2});; mprime 30
23:17:45 <egelbot> {2, 3, 5, 7, 11, 13, 17, 19, 23, 29}
23:17:48 <b_jonas> better
23:17:56 <b_jonas> egelbot: mprime 149
23:17:56 <egelbot> {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, 103, 107, 109, 113, 127, 131, 137, 139}
23:18:09 <b_jonas> [ s=: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, 103, 107, 109, 113, 127, 131, 137, 139
23:18:09 <j-bot> b_jonas: |ok
23:18:16 <b_jonas> [ p:i.#s
23:18:16 <j-bot> b_jonas: 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 103 107 109 113 127 131 137 139
23:18:19 <b_jonas> [ s-:p:i.#s
23:18:20 <j-bot> b_jonas: 1
23:18:21 <b_jonas> good
23:20:32 <b_jonas> def listdrop = [N S -> [ true M->M| _ nil->nil| _ (cons A D)->listdrop (-1+N)D| _ _->throw "error listdrop list" ] (N<=0) S ]
23:20:42 <b_jonas> egelbot: def listdrop = [N S -> [ true M->M| _ nil->nil| _ (cons A D)->listdrop (-1+N)D| _ _->throw "error listdrop list" ] (N<=0) S ];; ok
23:20:42 <egelbot> internal:1:130:semantical:undeclared ok
23:20:45 <b_jonas> egelbot: def listdrop = [N S -> [ true M->M| _ nil->nil| _ (cons A D)->listdrop (-1+N)D| _ _->throw "error listdrop list" ] (N<=0) S ];; "ok"
23:20:45 <egelbot> "ok"
23:20:56 <b_jonas> egelbot: ping
23:20:56 <egelbot> internal:1:2:semantical:undeclared ping
23:21:06 <b_jonas> egelbot: data pong;; def ping = pong;; ping
23:21:06 <egelbot> pong
23:21:08 <b_jonas> egelbot: ping
23:21:08 <egelbot> pong
23:21:14 <b_jonas> egelbot: ping "hello"
23:21:14 <egelbot> (pong "hello")
23:22:02 <b_jonas> egelbot: def listlen_a = [P nil->P| P (cons A D)->listlen(1+P)D| _->throw"error listlen" ];; def listlen = listlen_a 0;; "ok"
23:22:02 <egelbot> internal:1:43:semantical:undeclared listlen
23:22:32 <b_jonas> egelbot: def listlen_a = [P nil->P| P (cons A D)->listlen_a(1+P)D| _->throw"error listlen" ];; def listlen = listlen_a 0;; "ok"
23:22:32 <egelbot> "ok"
23:23:10 <b_jonas> egelbot: [L-> listdrop (-40+(listlen L)) L] (mprime 1000)
23:23:11 <egelbot> {727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997}
23:23:22 <b_jonas> egelbot: [L-> listdrop (-40+(listlen L)) L] (mprime (1<<16))
23:24:01 <egelbot> {65099, 65101, 65111, 65119, 65123, 65129, 65141, 65147, 65167, 65171, 65173, 65179, 65183, 65203, 65213, 65239, 65257, 65267, 65269, 65287, 65293, 65309, 65323, 65327, 65353, 65357, 65371, 65381, 65393, 65407, 65413, 65419, 65423, 65437, 65447, 65449, 65479, 65497, 65519, 65521}
23:24:58 <b_jonas> [ p:(_40+i.40)+ (p:^_1) 65536
23:24:58 <j-bot> b_jonas: |domain error
23:24:58 <j-bot> b_jonas: | p:(_40+i.40)+( p:^_1)65536
23:25:15 <b_jonas> [ (p:^_1) 65536
23:25:16 <j-bot> b_jonas: |domain error
23:25:16 <j-bot> b_jonas: | ( p:^_1)65536
23:25:28 <b_jonas> [ (p:) 6000
23:25:29 <j-bot> b_jonas: 59369
23:25:36 <b_jonas> [ p:(_40+i.40)+ (p:^:_1) 65536
23:25:36 <j-bot> b_jonas: 65099 65101 65111 65119 65123 65129 65141 65147 65167 65171 65173 65179 65183 65203 65213 65239 65257 65267 65269 65287 65293 65309 65323 65327 65353 65357 65371 65381 65393 65407 65413 65419 65423 65437 65447 65449 65479 65497 65519 65521
23:26:01 <b_jonas> [ s=: 65099, 65101, 65111, 65119, 65123, 65129, 65141, 65147, 65167, 65171, 65173, 65179, 65183, 65203, 65213, 65239, 65257, 65267, 65269, 65287, 65293, 65309, 65323, 65327, 65353, 65357, 65371, 65381, 65393, 65407, 65413, 65419, 65423, 65437, 65447, 65449, 65479, 65497, 65519, 65521
23:26:02 <j-bot> b_jonas: |ok
23:26:06 <b_jonas> [ s-: p:(_40+i.40)+ (p:^:_1) 65536
23:26:07 <j-bot> b_jonas: 1
23:26:08 <b_jonas> good
23:26:20 <b_jonas> spruit11: mutabile boxes seem to work
23:27:06 <spruit11> There are not a lot I could do wrong there. But thanks for testing it. Helps a lot.
23:27:26 <spruit11> What do you think? Slow but correct?
23:27:55 <b_jonas> spruit11: well it certainly seems to work
23:28:41 <spruit11> Yah. I'll move it to beta next. I think. Which doesn't mean a lot except that I'll change some texts on websites.
23:31:21 <b_jonas> spruit11: what are your future plans? mutable vectors? a list sorting primitive function in the library implemented in C++, plus a few helper wrapper data constructors that have funny comparison rules (at least one that compares backwards)? proper format (sprintf) functions so we can print numbers in ways other than the default format? I'm asking these because these are much easier to implement as
23:31:21 <b_jonas> built-ins than trying to write them in egel
23:32:27 <b_jonas> spruit11: oh and also, do you have more integer primitives? like wrapping addition and subtraction, unsigned less and lessequal, wrapping multiplication, unsigned high multiplication, signed high multiplication, index of first bit?
23:33:03 <b_jonas> those too fall in the category of things that are much easier to write in C++ than in egel.
23:33:15 <b_jonas> or maybe egel-bot improvements?
23:33:31 <spruit11> FFI through templates.
23:33:59 <b_jonas> like, more protection so you can't easily flood the channel with a [R->R R][R->print"spam";R R]
23:34:00 <spruit11> Even if I have a sluggish interpreter I want it to be easy to bind to C/C++.
23:34:10 <b_jonas> well that's interesting too
23:34:35 <spruit11> No, won't work on the bot. The bot is mostly there to show you can embed egel in a C++ application.
23:34:53 -!- LKoen has joined.
23:35:02 <b_jonas> I see
23:35:53 <spruit11> The idea is to have something as an alternative to building your own DSL. Just use Egel and toss in some combinators.
23:36:17 <spruit11> Not entirely unique, of course. Lisp/Python is good at that too.
23:36:32 <spruit11> But those are not Egel!
23:38:46 <spruit11> I have a start of that here: https://github.com/egel-lang/egel/tree/master/contrib/ffi
←2020-09-01 2020-09-02 2020-09-03→ ↑2020 ↑all