←2020-02-04 2020-02-05 2020-02-06→ ↑2020 ↑all
00:00:20 <b_jonas> the second one iterates on the characters, where X goes from 0.5 to -2.0 in steps of 0.1
00:00:45 <esowiki> [[Talk:LSCEF]] https://esolangs.org/w/index.php?diff=69603&oldid=69575 * IFcoltransG * (+630) /* ? */
00:00:58 <b_jonas> then there's a loop of only two steps, to get two pixels in one character of the output, that's the (P Y)(P(Y+ 0.1)) part
00:01:13 <b_jonas> and those two outputs are turned to one character with the lookup table [0 0->" "|0 1->"."|1 0->"'"|1 1->":"]
00:01:34 <spruit11> I'll save your explanation to a text file and think about it tomorrow.
00:02:11 <b_jonas> and there's the inner loop, in which X and Y are constant, representing a complex number (X,Y), and we iterate for 11 steps, S is the step counter, and (U,V) is the complex number that changes
00:02:25 <b_jonas> in each step, I square the complex number and add (X,Y) to it, which is the normal Mandelbrot loop
00:03:20 <b_jonas> at the end of the inner loop, I extract a result from the final value of (U,V) with [true->1|_->0]((abs U)+(abs V)<2.0)
00:03:34 <b_jonas> that result is 1 if the point is in the Mandelbrot set, or 0 if it isn't
00:03:50 <b_jonas> I use 0 and 1 instead of true and false only to make the lookup table shorter to write
00:04:08 <b_jonas> the second loop also concatenates the result characters
00:04:19 <b_jonas> and the string that we get for that line is printed with the say function
00:04:24 <b_jonas> that's about all there is to it
00:04:53 <b_jonas> to choose the grid of X and Y samples, I stole the numbers from the J snippets
00:10:01 <spruit11> Right, I am putting it into the examples dir.
00:10:11 <spruit11> B. Jonas fine as a reference?
00:10:41 <b_jonas> no, that's a messed up username that I ended up with after migration from the older wiki. please use b_jonas instead.
00:11:07 <b_jonas> the older wiki was of a sort that wanted CamelCase pagenames, then those got converted to Camel Case
00:11:25 <b_jonas> when they copied the content to a mediawiki
00:11:57 <spruit11> Excellent.
00:13:08 <spruit11> You want a link to a page you have. Only thing I got now is "b_jonas (freenode)". Not really descriptive.
00:13:17 <spruit11> Unless you prefer anonymity.
00:14:23 <spruit11> Okay, I am going with what I have now.
00:16:05 <spruit11> https://github.com/egel-lang/egel/blob/master/examples/mandelbrot.eg
00:30:11 -!- Lord_of_Life_ has joined.
00:32:50 -!- Lord_of_Life has quit (Ping timeout: 240 seconds).
00:32:59 -!- Lord_of_Life_ has changed nick to Lord_of_Life.
00:33:55 <arseniiv> the mandelbrot was really cool
00:36:45 -!- salpynx has joined.
00:39:48 <salpynx> agree, watching the live coding / language investigation unfold in the logs, the quine, and ending with the neat fractal code was very entertaining!
00:53:21 -!- arseniiv has quit (Ping timeout: 268 seconds).
00:57:14 <salpynx> @metar nzwn
00:57:16 <lambdabot> NZWN 050030Z AUTO 17011KT 9999 FEW019/// SCT026/// 17/11 Q1016 NOSIG
01:01:31 <salpynx> Someone mentioned around NYE that there was no one from New Zealand in the channel. I was away from keyboards at that time so couldn't provide advance reports from 2020, but that's where I'm based.
01:02:31 <salpynx> Awkward timezone explains why I tend to miss the interesting chats.
01:02:53 <salpynx> @fungot what's new?
01:02:54 <fungot> salpynx: what's a python editor?
01:02:54 <lambdabot> Unknown command, try @list
01:03:58 <salpynx> @fungot A person who edits other people's python? I did some of that today.
01:03:59 <lambdabot> Unknown command, try @list
01:03:59 <fungot> salpynx: what could be an omgrofl command i guess)
01:05:47 <salpynx> That's a common reaction.
01:06:49 <salpynx> @list
01:06:50 <lambdabot> What module? Try @listmodules for some ideas.
01:07:39 <salpynx> lambdabot: fungot is more ... fun to talk to, sorry.
01:07:39 <fungot> salpynx: an unspecified value." is the term " reference nets" in petri nets, and petri couldn't give a better answer, but in parts slightly outdated or implementation specific?
01:18:32 -!- FreeFull has quit.
01:47:34 <zzo38> Now I made loading PK fonts and it can render individual glyphs (typesetting paragraphs is not yet implemented).
01:48:50 <zzo38> For typesetting text, will need to support ligatures, kerning, accented characters, multi-layer characters, paragraph line breaking, and what else should be needed? I may have missed some, although there is probably some things which is not needed.
02:12:41 <salpynx> RTL / LTR text?
02:24:19 -!- imode has joined.
02:32:36 <zzo38> I think in TeXnicard, there isn't a need to mix different text directions in the same paragraph (I also think even when used in other documents, it doesn't work so well, either). But still I should think it would be good to support different text directions, even if only one text direction per paragraph.
02:48:44 <zzo38> Since it is specifically for typesetting text on a card (e.g. Magic: the Gathering), that may tell what features are more important to want.
02:56:11 <zzo38> Also, due to having custom separations, if you want to render a page with custom separations into RGBA, there will need to be some way to define how to convert it. (There will also need to be the way to transmit the separations individually (in CMYK mode), when you want to print out the custom separations on a printer that supports separations.)
03:02:32 <zzo38> Due to limitations in the Ghostscript display device, the maximum number of custom separations is four (these four are in addition to the CMYK process colours, so there are eight separations in total). Do you expect this to be sufficient? You should tell me if you think you will need more separations for some reason, and if you know what reason.
03:17:51 <salpynx> where is the latest TeXnicard source? I found repo.or.cz but that is 7 years old. Interested because I am currently working on a number of esolang things involving .svg graphics, and have been using TeX for another, but mainly for maths typesetting.
03:18:42 <zzo38> salpynx: It is available at the following Fossil repository: http://zzo38computer.org/fossil/texnicard.ui
03:20:06 <zzo38> TeX is good for typesetting many kind of books whether or not you are using much mathematics. For doing vector graphics, PostScript works better; however, SVG is not an available output format in Ghostscript.
03:20:25 <salpynx> TeX doesn't seem to be able to do arbitrary, nested, text scaling (which makes sense because that's not a practical typsetting problem), so svg seemed better for some of the things I was trying to do, but there might be something I could learn from.
03:22:05 <zzo38> TeX is able to specify the scaling of fonts. For other effects, you can modify the METAFONT code for the fonts.
03:23:35 <zzo38> What exactly are you trying to do anyways?
03:27:37 <zzo38> Maybe then, we can see what to do about it.
03:28:52 <salpynx> The scaling problem was to for a 2D text substitution to replace say one character with a block of typeset text at a scaled to occupy the area of the original character, theoretically recursive to any level
03:31:42 <zzo38> O, OK. It should be possible to do that with TeX, I think (as long as the aspect ratio of the glyphs is maintained), although such a thing probably isn't going to work so well. TeX doesn't support arbitrary precision, but neither does PostScript, and I don't know if SVG does or not.
03:32:24 <salpynx> each of these text areas would have a position in its parent reference, but would itself potentially be a 'page' with its own layout. Effectively every symbol would be a character AND (potentially) a page
03:34:45 <salpynx> svg seems to be able to do arbitrary level nesting or scaling, which is why it seemed a better choice for extreme scaling.
03:34:47 <zzo38> TeX supports adding "specials" which you could use to represent whatever you want it to represent, such as links to other pages. PostScript doesn't, although I thought that they should add specials into level 4 PostScript, since it might be of use for some applications.
03:36:19 <salpynx> For the 2D replacement, something like TeX would be nicer for the concept, even if there is a limit to the nesting level I'd try to use it.
03:37:37 <zzo38> As I said, you could define a special for that purpose, and then use a specialized DVI viewer to use the page links to use arbitrary nesting/scaling.
03:38:33 -!- Sgeo__ has joined.
03:41:59 -!- Sgeo_ has quit (Ping timeout: 265 seconds).
03:42:11 <salpynx> One of the things I've not fully completed or written up properly uses svgs with user defined units in Planck lengths to represent the source code. I haven't found a render that displays the objects properly with visible lines, but all the control points are in the correct places, and are converted to cm correctly. They validate as compliant svg.
03:42:56 -!- Frater_EST has quit (Read error: Connection reset by peer).
03:45:13 <zzo38> (And anyways, TeXnicard only produces raster output anyways, so is not suitable for what you are describing. But if you want to make up cards for games such as Magic: the Gathering or a card game you invent by yourself, and/or if you want to make the database of the cards too (and will want statistics and so on), and/or if you have used Magic Set Editor but want something better, then you should consider TeXnicard.)
03:47:08 <salpynx> I thought maybe the dc syntax would let arbitrary shapes and symbols be drawn on the cards (which is similar to another thing I was playing with), but from reading the docs, that looks like that has been completely replaced in the latest version
03:49:22 <zzo38> You can still do that using PostScript, which is still stack based programming. But neither version allows nesting to arbitrary levels.
03:50:32 <zzo38> (TeXnicard now uses a combination of PostScript and SQL, and also has something called EVALUATE code for some things (currently only gradients for pictures, but in future may do other stuff too).)
03:52:49 <salpynx> thanks for the 'special' tip I'll look into that. That looks like a way to get some basic output support using TeX, but still allowing for 'invisible' content to be present
03:53:23 <zzo38> Do you know any PostScript programming? PostScript can draw arbitrary shapes/symbols on the cards better than the old dc syntax could, although there are also many additional features specific to TeXnicard (such as PK font rendering, alpha transparency, etc). All PostScript commands which can draw graphics on the page still work.
03:54:16 <tswett[m]> Hey, anyone familiar with combinatorial game theory?
03:54:22 <salpynx> I'm not a Magic: the Gathering fan, but I like the idea of custom card games, and games in general
03:55:22 <tswett[m]> I'm wondering about a thing. Consider the game G = { Z | Z } — that is, either player may move to any integer.
03:55:31 <tswett[m]> Is G + G + 1 = 0?
03:56:16 <tswett[m]> Oh, I figured out the answer to my question in the process of typing it. The answer is no, it's equal to 1 and not 0.
03:56:22 <zzo38> salpynx: Well, TeXnicard isn't only for Magic: the Gathering. However, it is meant for card games (maybe someone can find a use for something else too, but I do not know of any).
03:56:26 <salpynx> No PostScript experience. I've only recently been teaching myself how to use LaTeX/TeX, which I like the idea of. PostScript doesn't excite me in the same way
03:57:00 <salpynx> tswett[m]: glad we could help!
03:57:19 <tswett[m]> Thanks. :D
03:58:22 <zzo38> tswett[m]: I have read about surreal numbers and how it is work with the game theory. By the rule of addition, I suppose, can figure out the answer of such question.
03:59:31 <tswett[m]> There's a simple proof that it can't be 0: if G + G + 1 were 0, that would mean that G + G = -1, but G + G is symmetrical about 0, so it can't be -1.
04:00:00 <tswett[m]> I think that in fact, G + G = 0 and so G + G + 1 = 1.
04:30:36 <zzo38> If a keyword action is added in Magic: the Gathering which applies to an object or player but successfully does nothing to that object or player (although things can trigger on it), what would such a keyword action be called?
05:09:43 -!- MDude has quit (Quit: Going offline, see ya! (www.adiirc.com)).
05:17:30 -!- Cale has quit (Remote host closed the connection).
05:18:09 -!- Cale has joined.
05:48:55 -!- Cale has quit (Remote host closed the connection).
05:49:30 -!- Cale has joined.
05:53:11 <salpynx> zzo38: I just made some progress with \parboxes inside \scaleboxes (from the graphicx package) to get nested scaled text which gives me the basic output I need. I've tried 3 levels of nesting and it seems to work like I wanted.
05:53:51 <salpynx> Not sure how well this shares, but https://latexbase.com/d/af902ebe-99ac-411b-8d02-a8a4c4be4d9f is an example
06:26:09 -!- xkapastel has joined.
06:26:37 -!- Cale has quit (Remote host closed the connection).
06:31:54 -!- Sgeo_ has joined.
06:31:58 -!- Cale has joined.
06:32:48 -!- moony has quit (Ping timeout: 245 seconds).
06:32:58 -!- Bowserinator has quit (Ping timeout: 258 seconds).
06:33:53 -!- iovoid has quit (Ping timeout: 265 seconds).
06:33:59 -!- wlp1s1 has quit (Ping timeout: 246 seconds).
06:35:36 -!- Sgeo__ has quit (Ping timeout: 268 seconds).
06:37:56 -!- Cale has quit (Remote host closed the connection).
06:50:31 -!- Bowserinator has joined.
06:52:04 -!- wlp1s1 has joined.
06:52:22 -!- iovoid has joined.
06:52:32 -!- moony has joined.
06:54:24 -!- wlp1s1 has changed nick to iczero.
07:47:19 -!- imode has quit (Ping timeout: 268 seconds).
08:32:33 -!- cpressey has joined.
08:35:57 -!- xkapastel has quit (Quit: Connection closed for inactivity).
09:01:21 -!- xkapastel has joined.
09:23:32 <b_jonas> zzo38: does "target" count?
09:23:49 <b_jonas> if not, how about "choose a"
09:24:55 -!- Cale has joined.
10:17:59 -!- b_jonas has quit (Quit: leaving).
10:30:33 -!- sprocklem has quit (Ping timeout: 268 seconds).
10:30:58 -!- sprocklem has joined.
11:17:04 -!- xelxebar has quit (Write error: Connection reset by peer).
11:18:15 -!- xelxebar has joined.
11:18:29 -!- wib_jonas has joined.
11:19:38 <wib_jonas> spruit11: question. how do you define a function in egel that is sometimes unevaluated depending on its arguments, but where I can't easily write the condition when it's evaluated as a pattern?
11:20:09 <wib_jonas> spruit11: for example, I want to define a function f so that if X is an even integer then (f X) evaluates to (X/2) but if X is an odd integer then (f X) remains unevaluated?
11:23:17 <wib_jonas> egelbot: [F -> (F String:length, F List:length)][F -> (F 7, F "7", F {7})]
11:23:17 <egelbot> (System:tuple (System:tuple (String:length 7) 1 (String:length (System:cons 7 System:nil))) (System:tuple (List:length 7) (List:length "7") 1))
11:24:29 -!- xelxebar has quit (Excess Flood).
11:25:01 -!- xelxebar has joined.
11:25:43 -!- salpynx has quit (Remote host closed the connection).
11:26:41 <myname> egel is horrible to search for if you are german because google will give you pages about the length of leeches
11:35:35 <wib_jonas> egelbot: [D -> (D (String:length "7"), D (String:length {7}), D (List:length "7"), D (List:length {7}))][(String:length _) -> "SL" | (List:length _) -> "LL" | (_ _) -> "A1" | V -> ("O", V)]
11:35:36 <egelbot> (System:tuple (System:tuple "O" 1) "SL" "LL" (System:tuple "O" 1))
11:36:01 <wib_jonas> egelbot: (7/2, 10/3, (-10)/3)
11:36:02 <egelbot> (System:tuple 3 3 -3)
11:37:03 <wib_jonas> egelbot: [_ -> ] 0
11:37:04 <egelbot> internal:1:8:syntactical:primary expression expected
11:44:18 <spruit11> wib_jonas: You can't.
11:46:14 <spruit11> It either rewrites a pattern, or not. I guess it could if I introduced guards but that turned out to be non-trivial.
11:46:36 <spruit11> For more or less exactly that reason, I estimate.
11:47:05 <spruit11> It needs to inspect something and then return on failure, that's non-trivial to implement.
11:47:59 <wib_jonas> ok, so even though builtin functions can do this, egel functions can't. if they want to return unevaluated, they should return some other unevaluated data.
11:48:09 <wib_jonas> egelbot: throw
11:48:10 <egelbot> internal:1:7:syntactical:primary expression expected
11:48:12 <wib_jonas> egelbot: throw 1
11:48:13 <egelbot> exception(1)
11:48:50 <spruit11> egelbot: try 1 + throw "hi" catch [ X -> say X ]
11:48:50 <egelbot> hi
11:49:06 <spruit11> ^syntax for try/catch and throw.
11:50:06 <wib_jonas> spruit: is there a nice way to test if a value is an integer (a float, a character, a string), or do I have to rely on things like whether String:length X is unevaluated like I tried above?
11:50:21 <wib_jonas> also, is there a nice way to test if something is an application, if I don't know the arity?
11:50:28 <wib_jonas> like a =.. function
11:50:53 <spruit11> The former I need to check, the latter, no. I could introduce combinators for that, though.
11:51:28 <spruit11> egelbot: [ X:int -> "yes" ] 1
11:51:28 <egelbot> internal:1:4:semantical:undeclared int
11:51:38 <spruit11> Hmm, did I remove that?
11:51:58 <wib_jonas> there was some builtin called int
11:52:01 <wib_jonas> egelbot: int
11:52:01 <egelbot> System:int
11:52:16 <wib_jonas> egelbot: [ int X -> "i" | "n" ] 2
11:52:17 <egelbot> internal:1:23:syntactical:-> expected
11:52:25 <wib_jonas> egelbot: [ int _ -> "i" | _ -> "n" ] 2
11:52:26 <egelbot> "n"
11:52:31 <wib_jonas> egelbot: [ int _ _ -> "i" | _ -> "n" ] 2
11:52:32 <egelbot> "n"
11:52:36 <wib_jonas> egelbot: [ int -> "i" | _ -> "n" ] 2
11:52:37 <egelbot> "n"
11:55:17 <spruit11> egelbot: [ X::int -> "yes" ] 1
11:55:18 <egelbot> "yes"
11:55:46 <spruit11> Needed to check in the source. For some reason I changed it to a double colon.
11:56:41 <spruit11> egelbot: [ X::int -> "an int" | X::float -> "a float" ] 1.0
11:56:41 <egelbot> "a float"
11:57:43 <spruit11> Allowing for an application is a good idea, btw. I'll see whether I can add that.
11:58:07 * spruit11 scribbles in his notes.
11:58:34 <spruit11> *testing on application.
12:09:05 <spruit11> Right, I'll add checks like [g::app -> .. | f::comb -> ..] and some extra introspection combinators.
12:09:51 <wib_jonas> egelbot: [T -> (T true, T {}, T {1}, T nop, T 7, T 7.0, T 'a', T "a", T (2 3))] [true->"b", false->"b", _::int->"i", _::float->"f", _::char->"c", _::string->"s", _->"o"]
12:09:51 <egelbot> internal:1:83:syntactical:] expected
12:10:19 <wib_jonas> egelbot: [T -> (T true, T {}, T {1}, T nop, T 7, T 7.0, T 'a', T "a", T (2 3))] [true->"b"| false->"b"| _::int->"i"| _::float->"f"| _::char->"c"| _::string->"s"| _->"o"]
12:10:19 <egelbot> internal:1:142:semantical:undeclared string
12:10:25 <wib_jonas> egelbot: [T -> (T true, T {}, T {1}, T nop, T 7, T 7.0, T 'a', T "a", T (2 3))] [true->"b"| false->"b"| _::int->"i"| _::float->"f"| _::char->"c"| _::str->"s"| _->"o"]
12:10:26 <egelbot> internal:1:142:semantical:undeclared str
12:10:33 <wib_jonas> egelbot: [T -> (T true, T {}, T {1}, T nop, T 7, T 7.0, T 'a', T "a", T (2 3))] [true->"b"| false->"b"| _::int->"i"| _::float->"f"| _::char->"c"| _->"o"]
12:10:34 <egelbot> (System:tuple "b" "o" "o" "o" "i" "f" "c" "o" "i")
12:10:59 <wib_jonas> spruit11: what was the typename for strings?
12:11:14 <wib_jonas> egelbot: {1|2}
12:11:14 <egelbot> internal:1:4:syntactical:} expected
12:11:28 <wib_jonas> no improper list input syntax :-)
12:15:12 <spruit11> text?
12:15:29 <spruit11> egelbot: [ X::text -> "text" ] "hello"
12:15:29 <egelbot> "text"
12:15:56 <spruit11> egelbot: [ X::text -> "text" | X::char -> "char" ] 'a'
12:15:56 <egelbot> "char"
12:16:01 <spruit11> Right.
12:16:11 <wib_jonas> egelbot: [T -> (T true, T {}, T {1}, T nop, T 7, T 7.0, T 'a', T "a", T (2 3))] [true->"b"| false->"b"| _::int->"i"| _::float->"f"| _::char->"c"| _::text->"s"| (cons _ _)->"l"| (nil _)->"l"| _->"o"]
12:16:11 <egelbot> (System:tuple "b" "o" "l" "o" "i" "f" "c" "s" "i")
12:16:25 <wib_jonas> egelbot: {}
12:16:25 <egelbot> System:nil
12:16:30 <wib_jonas> egelbot: [T -> (T true, T {}, T {1}, T nop, T 7, T 7.0, T 'a', T "a", T (2 3))] [true->"b"| false->"b"| _::int->"i"| _::float->"f"| _::char->"c"| _::text->"s"| (cons _ _)->"l"| nil->"l"| _->"o"]
12:16:31 <egelbot> (System:tuple "b" "l" "l" "o" "i" "f" "c" "s" "i")
12:16:45 <wib_jonas> wait
12:17:01 <wib_jonas> egelbot: [X::int -> ("i", X)] (2 3)
12:17:02 <egelbot> (System:tuple "i" (2 3))
12:17:16 <wib_jonas> egelbot: [X::tuple -> ("t", X)] (2,3)
12:17:16 <egelbot> (System:tuple "t" (System:tuple 2 3))
12:17:22 <wib_jonas> ooh
12:17:32 <wib_jonas> egelbot: [X::tuple -> ("t", X)] (2,3,4,5)
12:17:33 <egelbot> (System:tuple "t" (System:tuple 2 3 4 5))
12:17:42 <wib_jonas> so this lets you recognize the head?
12:17:48 <wib_jonas> egelbot: [X::tuple -> ("t", X)] tuple
12:17:48 <spruit11> Oh, god. RIght.
12:17:48 <egelbot> (System:tuple "t" System:tuple)
12:17:57 <wib_jonas> egelbot: [X::tuple -> ("t", X)] {}
12:17:57 <spruit11> I forgot what it does that.
12:17:58 <egelbot> (Dummy48DOT0 System:nil)
12:18:01 <wib_jonas> egelbot: [X::tuple -> ("t", X)] 0
12:18:01 <egelbot> (Dummy49DOT0 0)
12:18:12 <wib_jonas> egelbot: [X::int -> ("t", X)] (int "foo")
12:18:13 <egelbot> (System:tuple "t" (System:int "foo"))
12:18:18 <wib_jonas> egelbot: (int "foo")
12:18:19 <spruit11> Need to think it over whether I can change it then. Should be possible.
12:18:19 <egelbot> (System:int "foo")
12:18:31 <spruit11> Unsure why I made that decision.
12:18:40 <wib_jonas> recognizing the head can be useful. it's halfway to a =.. introspection that breaks down any application
12:18:51 <wib_jonas> lets you recognize arbitrary tuples and all that
12:19:21 <wib_jonas> egelbot: [A@(B,C) -> (A,B,C)] (3,0)
12:19:22 <egelbot> internal:1:4:syntactical:-> expected
12:19:27 <wib_jonas> (had to try that)
12:19:30 <spruit11> I think it's because I am worried about unary tuples like (1).
12:19:59 <spruit11> So, I programmed defensively to just return the type of the head.
12:20:57 <spruit11> I don't know whether unary tuples are ever introduced. I don't think so, but that would need testing.
12:21:33 <wib_jonas> egelbot: (1,) # the parser doesn't recognize them,
12:21:33 <egelbot> internal:1:5:syntactical:primary expression expected
12:21:43 <wib_jonas> egelbot: tuple 1 # but you can make them explicitly
12:21:44 <egelbot> (System:tuple 1)
12:21:57 <wib_jonas> I don't see what that has to do with this though
12:22:03 <spruit11> Oh, right. Sorry, not tuples. Compositions.
12:22:22 <spruit11> Or arrays, internally.
12:22:28 <spruit11> egelbot: (1 2)
12:22:28 <egelbot> (1 2)
12:22:34 <spruit11> Stuff like that.
12:22:41 <spruit11> egelbot: (1)
12:22:42 <egelbot> 1
12:23:05 <spruit11> Right, there's something I didn't have time to think a lot about. What to do with (1)?
12:23:21 <wib_jonas> (1) is just 1
12:23:23 <spruit11> Is it a unary composition/array, or just a constant?
12:23:46 <wib_jonas> it's not a composition
12:23:50 <wib_jonas> it's just a different way to write 1
12:23:54 <spruit11> Right, but I have to absolutely certain it never introduces a unary composition in the runtime.
12:24:00 <spruit11> *to be
12:24:15 <wib_jonas> you may have unary compositions, but (1) isn't one
12:24:41 <spruit11> So, I programmed defensively around it, and just hoped that would turn out fine.
12:25:10 <spruit11> There are examples in the implementation (bytecode operators) I wasn't very certain.
12:25:12 <wib_jonas> egelbot: [_::1->"o"] 1
12:25:12 <egelbot> internal:1:6:syntactical:lowercase expected
12:25:22 <wib_jonas> egelbot: [_::(1)->"o"] 1
12:25:23 <egelbot> internal:1:6:syntactical:lowercase expected
12:25:42 <wib_jonas> egelbot: [_::_->"o"] 1
12:25:43 <egelbot> internal:1:6:semantical:undeclared _
12:26:05 <wib_jonas> egelbot: [_::tuple->"t"] tuple
12:26:05 <egelbot> "t"
12:26:12 <wib_jonas> egelbot: [_::tuple->"t"] (2,0)
12:26:12 <egelbot> "t"
12:26:20 <wib_jonas> egelbot: [_::tuple->"t"] {tuple,2}
12:26:21 <egelbot> (Dummy58DOT0 (System:cons System:tuple (System:cons 2 System:nil)))
12:27:08 <spruit11> egelbot: [ _::cons -> "cons" ] {1,2}
12:27:08 <egelbot> "cons"
12:31:35 -!- Lord_of_Life has quit (Ping timeout: 260 seconds).
12:31:45 -!- Lord_of_Life_ has joined.
12:33:06 -!- Lord_of_Life_ has changed nick to Lord_of_Life.
12:56:22 <spruit11> Right, if (1 2 3) and (1 2) are compositions then why not (1)?
12:56:55 <spruit11> This is a case where the written syntax forces one to disambiguate.
12:56:59 <wib_jonas> spruit11: because this is a curried language, ((x y) z) is the same as (x y z)
12:57:40 <spruit11> Unfortunately, for the runtime model, that would mean checking loads of invariants to make sure a unary composition is never introduced.
12:58:31 <wib_jonas> you can introduce unary composition if you want, it's just that (1) shouldn't be one, because you want to use parenthesis to override precedence
12:59:14 <spruit11> Sure, but the point is that (1) shows you where the runtime model might disagree. Unary composition exists.
12:59:31 <spruit11> I.e., your syntax and ast might differ.
12:59:51 <wib_jonas> egelbot: 1 (2 3)
12:59:51 <spruit11> If the syntax would be unambiguous, I wouldn't have a problem.
12:59:51 <egelbot> (1 (2 3))
13:00:12 <spruit11> Be back in an hour, shopping.
13:00:46 <wib_jonas> you can add custom syntax if you want to print or input unary compositions. the easiest is to add a custom builtin function for it, so (unary 1) is a unary composition, and ((unary 1 2) 3) is a binary composition (as opposed to ((1 2) 3) which is ternary)
13:03:38 <wib_jonas> so eg. [X Y->(X,Y)] ((unary 1 2) 3) would return ((1,2), 3) whereas [X Y->(X,Y)] (1 2 3) is unevaluated
13:03:46 <wib_jonas> no wait
13:03:56 <wib_jonas> [(X Y)->(X,Y)] ((unary 1 2) 3) would return ((1,2), 3) whereas [(X Y)->(X,Y)] (1 2 3) is unevaluated
13:05:00 <wib_jonas> and [(unary X) -> (0,X)] (unary 7) would return (0,7), but [(unary X) -> (0,X)] 7 is unevaluated, and so is [(unary X) -> (0,X)] (6 7)
13:05:35 <wib_jonas> only you represent it in memory as a function composition with one element, and add custom input and ouput syntax, just like how you have custom input syntax for tuples and lists, and should have custom output syntax for tuples and lists
13:05:57 -!- xkapastel has quit (Quit: Connection closed for inactivity).
13:08:52 -!- arseniiv has joined.
13:16:10 <wib_jonas> fizzie: can you install the libicu-dev package so that I can try to build this egel interpreter https://github.com/egel-lang/egel/archive/master.zip on HackEso?
13:53:14 -!- sprocklem has quit (Ping timeout: 240 seconds).
14:10:34 <spruit11> Back.
14:11:05 <spruit11> I don't think it's worth it. It's just a thing which pops up because Egel is untyped and the syntax is ambiguous.
14:13:26 -!- rain1 has joined.
14:26:21 <wib_jonas> fungot, please turn down the sun a bit
14:26:22 <fungot> wib_jonas: this is perhaps not abrupt enough. jumped off a bridge
14:29:03 <rain1> yo
14:32:57 <cpressey> hi rain1
14:34:03 -!- Cale has quit (Ping timeout: 245 seconds).
14:37:09 <rain1> hello cpressey nice to see you
14:55:28 -!- Cale has joined.
14:56:51 -!- glowcoil has quit.
14:57:16 -!- glowcoil has joined.
15:04:35 -!- sprocklem has joined.
15:31:38 -!- wib_jonas has quit (Remote host closed the connection).
15:37:35 -!- ocharles has quit.
15:37:52 -!- ocharles has joined.
15:49:41 -!- Melvar has quit (Quit: WeeChat 2.4).
15:54:29 -!- sprocklem has quit (Ping timeout: 268 seconds).
15:57:32 -!- Melvar has joined.
16:04:49 -!- sprocklem has joined.
16:19:53 -!- dingwat has quit.
16:20:16 -!- dingwat has joined.
16:26:17 -!- MDude has joined.
16:51:53 -!- sprocklem has quit (Ping timeout: 260 seconds).
16:59:15 -!- cpressey has quit (Quit: A la prochaine.).
17:16:11 <rain1> what's up
17:30:23 -!- LKoen has joined.
17:52:07 <kmc> hello
17:54:37 <LKoen> hi
18:09:36 -!- LKoen has quit (Remote host closed the connection).
18:10:49 -!- LKoen has joined.
18:14:48 -!- FreeFull has joined.
18:28:24 -!- Phantom_Hoover has joined.
18:29:53 <esowiki> [[User:Sxakalo]] https://esolangs.org/w/index.php?diff=69604&oldid=69462 * Sxakalo * (+83) /* Implemented */
18:31:26 <esowiki> [[1.1]] https://esolangs.org/w/index.php?diff=69605&oldid=66908 * Sxakalo * (+162)
18:33:55 -!- Sgeo__ has joined.
18:36:59 -!- Sgeo_ has quit (Ping timeout: 260 seconds).
19:04:18 -!- Phantom_Hoover has quit (Ping timeout: 260 seconds).
19:13:28 <rain1> hows it going kmc and LKoen
19:15:36 <LKoen> slowly and depressingly
19:20:29 -!- LKoen has quit (Remote host closed the connection).
19:20:44 -!- LKoen has joined.
19:20:50 -!- mich181189 has quit.
19:21:06 -!- mich181189 has joined.
19:22:32 <kmc> goes fine
19:25:33 -!- LKoen has quit (Remote host closed the connection).
19:25:51 -!- LKoen has joined.
19:29:34 -!- LKoen has quit (Remote host closed the connection).
19:30:03 -!- xelxebar has quit (Remote host closed the connection).
19:30:23 -!- xelxebar has joined.
19:30:34 -!- LKoen has joined.
19:31:18 -!- sprocklem has joined.
19:35:33 <rain1> any new discoveries?
19:35:46 <rain1> or what is new to you ?
19:38:20 -!- ocharles has quit (Ping timeout: 252 seconds).
19:38:44 -!- dingwat has quit (Ping timeout: 248 seconds).
19:38:44 -!- glowcoil has quit (Ping timeout: 248 seconds).
19:40:29 -!- mich181189 has quit (Ping timeout: 272 seconds).
20:01:59 -!- 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.”).
20:05:20 <kmc> about to do some mushroom cultivation work
20:05:28 <kmc> grain->grain and grain->agar transfers
20:06:17 <rain1> wow that's such a cool thing to do
20:07:23 -!- b_jonas has joined.
20:07:45 <kmc> yeah! it's fun
20:10:43 <kmc> the main failure mode of mushroom cultivation is contamination
20:11:02 <kmc> any substrate which is good for growing mushrooms is also good for growing bacteria and mold
20:11:25 <kmc> so sterile technique is key
20:12:26 <kmc> i'm doing the transfers inside a still air box, which is just a transparent box with two holes cut in one side so you can reach your arms in
20:12:29 <kmc> like a glovebox without the gloves
20:12:46 <kmc> as the name implies the intent is to keep the air inside motionless so it will not carry contamination from one point to another
20:13:03 <b_jonas> so it has like curtains on the holes, but it's not vacuum sealed?
20:13:18 <kmc> mine doesn't even have that
20:13:24 <kmc> there are various levels of sophistication
20:13:49 <kmc> what i really want is a laminar flow hood/box
20:14:17 <kmc> in which you have a continuous sheet of HEPA-filtered air blowing smoothly (laminar) over the work surface
20:14:48 <kmc> and you position things so that the less clean cultures are downwind
20:14:55 <kmc> and you are selectively transfering the desired organism upwind
20:15:19 <kmc> but you can do fine work on a hobby scale with just a still air box
20:15:32 <b_jonas> a pressure gradient, like into a clean room or nuclear reactor.
20:15:43 <kmc> similar idea, yeah
20:24:57 <arseniiv> mushrooms! interesting!
20:29:08 -!- kspalaiologos has joined.
20:29:32 <kspalaiologos> greets
20:29:38 <kspalaiologos> any ideas on golfing this C program: http://kspalaiologos.baselinux.net/doc/golf.c ?
20:40:06 <b_jonas> egelbot: [F->{F 0,F 1,F 2}][X->if 0<X then [Y->X+Y] else [Y->10*X]]
20:40:07 <egelbot> (System:cons (Dummy61DOT2 0) (System:cons (Dummy61DOT1 1) (System:cons (Dummy61DOT1 2) System:nil)))
20:40:43 <b_jonas> egelbot: [F->{F 0,F 1,F 2}][X->if 0<X then [Y->X+Y] else [Y->10*Y]]
20:40:44 <egelbot> (System:cons Dummy62DOT2 (System:cons (Dummy62DOT1 1) (System:cons (Dummy62DOT1 2) System:nil)))
20:40:59 <b_jonas> egelbot: List:map [F->F 7] ([F->{F 0,F 1,F 2}][X->if 0<X then [Y->X+Y] else [Y->10*Y]])
20:40:59 <egelbot> (System:cons 70 (System:cons 8 (System:cons 9 System:nil)))
20:41:29 <b_jonas> egelbot: List:map [F->F 7] ([F->{F 0,F 1,F 2}][X->if 0<X then [Y->X+Y] else "zero"])
20:41:29 <egelbot> (System:cons ("zero" 7) (System:cons 8 (System:cons 9 System:nil)))
20:41:37 <b_jonas> egelbot: ([F->{F 0,F 1,F 2}][X->if 0<X then [Y->X+Y] else "zero"])
20:41:37 <egelbot> (System:cons "zero" (System:cons (Dummy65DOT1 1) (System:cons (Dummy65DOT1 2) System:nil)))
20:42:21 <b_jonas> egelbot: ([F->{F 0,F 1,F 2}][X->if 0<X then "add" [Y->X+Y] else "zero" [Y->10*Y]])
20:42:21 <egelbot> (System:cons ("zero" Dummy66DOT2) (System:cons ("add" (Dummy66DOT1 1)) (System:cons ("add" (Dummy66DOT1 2)) System:nil)))
20:42:35 <b_jonas> egelbot: ([F->{F 0,F 1,F 2}][X->if 0<X then [Y->X+Y] else [Y->10*Y]])
20:42:35 <egelbot> (System:cons Dummy67DOT2 (System:cons (Dummy67DOT1 1) (System:cons (Dummy67DOT1 2) System:nil)))
20:43:22 <b_jonas> egelbot: List:map [S::text F->(S,F 7)] ([F->{F 0,F 1,F 2}][X->if 0<X then "add" [Y->X+Y] else "zero" [Y->10*Y]])
20:43:22 <egelbot> (System:cons (Dummy68DOT0 ("zero" Dummy68DOT3)) (System:cons (Dummy68DOT0 ("add" (Dummy68DOT2 1))) (System:cons (Dummy68DOT0 ("add" (Dummy68DOT2 2))) System:nil)))
20:43:41 <b_jonas> egelbot: List:map [(S::text F)->(S,F 7)] ([F->{F 0,F 1,F 2}][X->if 0<X then "add" [Y->X+Y] else "zero" [Y->10*Y]])
20:43:42 <egelbot> (System:cons (System:tuple "zero" 70) (System:cons (System:tuple "add" 8) (System:cons (System:tuple "add" 9) System:nil)))
20:43:51 <b_jonas> ok
20:47:37 -!- kspalaiologos has quit (Quit: Leaving).
20:53:17 -!- Phantom_Hoover has joined.
21:06:51 -!- kspalaiologos has joined.
21:10:26 -!- atslash has quit (Ping timeout: 240 seconds).
21:10:41 -!- atslash has joined.
21:14:32 -!- rain1 has quit (Quit: Lost terminal).
21:14:44 <b_jonas> egelbot: 40644>>3
21:14:45 <egelbot> 5080
21:15:04 <b_jonas> egelbot: (-1)>>1
21:15:05 <egelbot> -1
21:16:04 <kspalaiologos> ^?
21:16:08 <kspalaiologos> It's wrong
21:16:32 <b_jonas> no it's not, it's a proper signed right shift
21:16:45 <b_jonas> I wanted to see if it was a signed shift or an unsigned shift
21:25:57 <kspalaiologos> But the signs bit
21:26:08 <kspalaiologos> It should be 0x7F(FF)n
21:33:23 <kmc> whee, two jars of grain + 6 petris inoculated
22:03:23 -!- Sgeo_ has joined.
22:06:26 -!- Sgeo__ has quit (Ping timeout: 240 seconds).
22:57:57 -!- glowcoil has joined.
22:58:35 -!- ocharles has joined.
23:01:18 -!- mich181189 has joined.
23:01:54 -!- dingwat has joined.
23:16:41 -!- LKoen has joined.
23:26:18 -!- 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.”).
23:47:19 -!- Phantom_Hoover has quit (Ping timeout: 260 seconds).
←2020-02-04 2020-02-05 2020-02-06→ ↑2020 ↑all