←2019-06-07 2019-06-08 2019-06-09→ ↑2019 ↑all
00:08:00 -!- adu has joined.
00:12:11 -!- iconmaster has quit (Ping timeout: 248 seconds).
00:19:15 -!- iconmaster has joined.
00:20:54 -!- ais523 has joined.
00:39:23 -!- iconmaster has quit (Ping timeout: 248 seconds).
01:01:40 -!- iconmaster has joined.
01:02:03 -!- tswett[m] has quit (Changing host).
01:02:03 -!- tswett[m] has joined.
01:02:03 -!- tswett[m] has quit (Changing host).
01:02:03 -!- tswett[m] has joined.
01:03:01 -!- iconmaster has quit (Client Quit).
01:09:20 -!- Phantom_Hoover has quit (Ping timeout: 248 seconds).
01:39:27 <Sgeo__> WebAssembly reminds me of NewSpeak: Immutable modules that need to have functions passed into them
01:49:57 <ski> passed, how ?
02:04:56 <Sgeo__> When you instantiate a WebAssembly module, you give it an object of imports. When the WebAssembly code wants to import something, it comes from that object. There's no other way for WebAssembly code to access host functionality
02:09:52 <ski> so you link imports to it, externally then ?
02:10:10 <ski> i assume Gilad Bracha might like that
02:11:24 <shachaf> Is that different from an ELF file or whatever the regular computer equivalent is?
02:11:31 <zzo38> I think thiat is good. But, I think there should be a implementation to use in C, rather than only JavaScript
02:12:17 -!- Lord_of_Life has quit (Ping timeout: 268 seconds).
02:13:12 <shachaf> I wrote some webassembly code by hand: http://slbkbs.org/tmp/webasm-by-hand.html
02:13:37 <shachaf> I'll probably emit some at one point.
02:13:39 -!- Lord_of_Life has joined.
02:18:15 * ski . o O ( "A Ban on Imports" by Gilad Bracha in 2009-06-30 at <https://gbracha.blogspot.com/2009/06/ban-on-imports.html> )
02:26:22 <zzo38> Another way is you can import, but only the interface can be imported, and then you can substitute other implementations. In C you can use a #include command to load a header file, but the implementations of function in other file which is not part of the first one, and then link it together afterward. You can also modify the header file in case some macros may be different, too.
02:26:59 <zzo38> However, this requires that it is global for the entire program, rather than having parameters you can do it locally too. But, even in C, you could do dynamic loading, too.
02:29:16 -!- atslash has joined.
02:31:00 <shachaf> whoa, https://gist.github.com/pervognsen/0e1be3b683d62b16fd81381c909bf67e is such a reasonable way to think of multidimensional arrays.
02:32:01 <zzo38> shachaf: I looked at the code. It won't work on the web browser that I have, but it does work on my computer, on Node.js version 8 (I have both version 8 and version 6 installed, because there is a package for version 6 but version 8 I have to install manually)
02:33:34 -!- atslash has quit (Client Quit).
02:59:02 <zzo38> I wrote some more ideas I had about making Magic: the Gathering cards in RDF, and here is another example of a code: [:when [:upkeep :you]; :do [:sacrifice [:and [:not :this], :creature]; :else [:damage 7; :to :you]]]
03:01:08 <zzo38> Do you think this is good?
03:25:50 -!- FreeFull has quit.
03:48:06 -!- S_Gautam has joined.
04:27:47 <esowiki> [[Fm]] https://esolangs.org/w/index.php?diff=63179&oldid=13048 * Salpynx * (+518) So glad I found these archived, the geocities content is not saved anywhere!
04:52:31 <esowiki> [[Subleq]] https://esolangs.org/w/index.php?diff=63180&oldid=54976 * Salpynx * (+112) /* External resources */ add a Ruby interpreter found on github
05:15:52 <esowiki> [[Mouse]] https://esolangs.org/w/index.php?diff=63181&oldid=40936 * Salpynx * (+143) /* External resources */ link to original 1979 article
05:16:27 <esowiki> [[Mouse]] M https://esolangs.org/w/index.php?diff=63182&oldid=63181 * Salpynx * (+4) /* History */ link to a stub for MUSYS
05:25:00 -!- iconmaster has joined.
05:43:28 -!- adu has quit (Quit: adu).
05:54:53 -!- b_jonas has quit (Quit: Lost terminal).
06:21:09 <ski> shachaf : oh, interesting :)
06:24:42 * ski . o O ( "Blitter Hardware / DMA Channels" (in "Amiga Hardware Reference Manual") (see the part about "modulos") at <http://amigadev.elowar.com/read/ADCD_2.1/Hardware_Manual_guide/node011B.html> )
06:26:33 <shachaf> ski: Makes sense.
06:30:06 <zzo38> ski: That was what I thought too (although I have never used Amiga).
06:30:27 <shachaf> zzo38: Do you like this article?
06:30:46 <ski> zzo38 : i suppose you've encountered a similar technique somewhere else ?
06:31:12 <zzo38> shachaf: Yes, I think that is good (for some kind of purposes, at least).
06:31:39 <zzo38> ski: No; I thought of Amiga, because I know a few things about it.
06:31:41 <shachaf> Uh, I mean the one about multidimensional arrays, not about Amiga.
06:31:55 <zzo38> shachaf: Yes, that is what I expected you meant
06:32:47 <shachaf> What kinds of array types should a language have? It seems like there are so many variants.
06:33:03 <shachaf> For example:
06:33:08 <shachaf> * Raw pointer to T.
06:33:20 <shachaf> * Array of N elements, N known statically.
06:33:22 <zzo38> Depend on the programming language, I think. I would just have, you can define your own.
06:33:23 <shachaf> * Array of N elements, N known dynamically.
06:34:00 <shachaf> * Array of N elements with maximum capacity M, N dynamic, M static.
06:34:04 <shachaf> * Array of N elements with maximum capacity M, N and M dynamic.
06:34:11 <shachaf> And some other things.
06:34:58 <shachaf> Some languages might let you define an array type with a size that's either known statically or dynamically, though I'm not sure how you'd do that without the whole thing being a complicated disaster.
06:34:59 <ais523> for high-level languages I rather like the approach where you have something dictionary-like that can be indexed with /anything/, but some helpers for if you happen to use consecutive integers
06:35:33 <shachaf> I mean a low-level language where you're concerned with exact memory layout and ownership.
06:36:18 * ski . o O ( "Single Assignment C" <https://en.wikipedia.org/wiki/SA-C_(programming_language)>,<http://www.cs.colostate.edu/cameron/SACoverview.html> )
06:36:35 <ais523> Rust's approach seems to work fairly well; it supports four of the items on your list as language primitives or really core standard library elements
06:36:51 <ais523> *T, [T; N], [T], (not available), Vec<T>
06:37:03 <zzo38> I think what C does is fine, although I would do that you can define your own type and how it is passed and whatever other details it is
06:37:29 <ais523> arrays are second-class in C
06:37:34 <ski> `M' is an upper bound of `N' ?
06:37:35 <HackEso> ​/srv/hackeso-code/multibot_cmds/lib/limits: line 5: exec: M': not found
06:37:46 <shachaf> That's what I meant.
06:37:51 <ais523> I think it would be an improvement to have them as first-class, like structs are
06:37:56 <shachaf> There are several options I haven't mentioned, such as the one where the array "owns" the memory and where it doesn't.
06:38:15 <ais523> well, dynamic sizing is tied to owning memory
06:38:38 <ais523> if you don't own the memory you typically can't resize it, if you do, the only thing preventing a resize would be pointers into the array from outside
06:38:54 <shachaf> Well, you could have capacity M, size N, and no way to grow the capacity.
06:39:03 <ais523> (in Rust you can't mutate anything which has an outside pointer, so in Rust, the ability to mutate a Vec also lets you resize it)
06:39:32 <shachaf> Only if the vec is allocated with malloc/free.
06:39:48 <ais523> Vec is specifically an array that owns its memory
06:39:55 <ais523> but it's normally used for growable arrays
06:39:57 <shachaf> It might just be statically allocated, or allocated in an arena or something.
06:40:33 <ais523> if it's statically allocated it doesn't own its memory, right? the executable image does
06:40:45 <ais523> I guess resizing an array could move it into or out of an arena
06:41:08 <shachaf> OK, sure. What I mean is that having both capacity and size is distinct from owning the memory.
06:42:06 <ski> zzo38 : it's not clear (to me) what "define your own type and how it is passed and whatever other details it is" would mean, in terms of language design
06:42:07 <shachaf> Possibly it's not very useful in practice, but I suspect it's moderately useful.
06:43:33 <zzo38> ski: What I thought, you can define parameterized types, including with different kinds (like is possible in Haskell, for example, but not Haskell), and then you can define the characteristics for a type, and you can also define your own characteristics, too. Such characteristics can include defining variables, reading, writing, etc, using macros to convert the operations into LLVM codes.
06:44:05 <shachaf> There's a feature related to this that C++ doesn't really support, which is to have something which can either be a compile-time argument or a runtime argument.
06:44:07 -!- sebbu3 has joined.
06:44:07 <ais523> well, from a low-level perspective, capacity is the only thing that really matters; size is just a declaration of intent about how you're using the data
06:44:20 <shachaf> C++ supports the former with templates and the latter with arguments, but it doesn't let you abstract over them.
06:44:30 <ais523> you can plausibly imagine one array having multiple different sizes because it's partially initialized to different extents at multiple different abstraction levels
06:44:56 <shachaf> ais523: Well, sure, but in C I often store the size along with the poitner because I want to operate on only the valid elements.
06:45:12 <ski> it's interesting that you can do `void frob(const size_t M,const size_t N,int (*parr)[M][N]) { ..(*parr)[i][j].. }' (VLA) in C. however, neither `int (*blub(const size_t N))[N] { ... }', nor `struct { const size_t N; int (*parr)[N]; }' works, aiui
06:45:36 <shachaf> In practice storing the size is very common.
06:45:43 <ais523> shachaf: right; it's just that "valid" is a relative concept and storing it in the array seems wrong in a sense because there's no obvious reason to have exactly one of it (besides the capacity)
06:45:53 <shachaf> You also might want bounds checking to check the size rather than the capacity.
06:46:04 <ski> ais523 : by "first-class", i assume that you mean that you can pass them as parameters to, and result from, functions, and assign them ?
06:46:11 <ais523> ski: right
06:46:37 <shachaf> I agree that it would be nicer if C arrays were first-class. The meaning of foo(int x[4]) is silly.
06:46:39 <ais523> the most useful use for it is "number of elements that are validly initialized", meaning that you have to run their destructors when the array dies, can't read past the end of the allocated area (but can write), etc.
06:46:54 <ais523> shachaf: foo(int x[static 4])
06:47:00 <zzo38> Anyways, I don't use foo(int x[4]) in C.
06:47:03 <shachaf> The meaning of that is still silly.
06:47:06 <ais523> admittedly, it still probably doesn't really do what you want, but it's a start
06:47:20 <shachaf> struct T { int x[4]; }; foo(T t); has the more reasonable meaning.
06:47:49 <esowiki> [[MUSYS]] N https://esolangs.org/w/index.php?oldid=63183 * Salpynx * (+1513) I'm still trying to track down the full description of this language...
06:47:50 <ais523> but valid initialisation is a high-level concept
06:48:11 -!- sebbu has quit (Ping timeout: 258 seconds).
06:48:14 <ski> zzo38 : "like is possible in Haskell, for example, but not Haskell" ?
06:48:15 <shachaf> I do use foo(int x[static N]) in C code -- I've never seen anyone else do it -- but only in particular cases like the output of a hash function or something.
06:48:25 <shachaf> ais523: Arrays are also a high-level concept.
06:48:36 <zzo38> Do you want the LLVM type [4 x i32] or whatever to be the type of the argument?
06:48:50 <ais523> zzo38: yes, that's how it would compile in LLVM
06:48:53 <shachaf> If you have a for-each loop, for (T x : a) { ... }, that would presumably use the size.
06:48:58 <zzo38> ski: I mean what I am describing is not Haskell, but it has parameterized types with kinds is similar to how Haskell is doing.
06:49:08 <zzo38> (although not quite, but it is a bit similar)
06:49:15 <ais523> although, hmm, I'm not sure if it should be by-reference or by-value
06:49:30 <ais523> I guess it has to be by-value for consistency, but that would seem /really/ weird to C programmers
06:50:06 <shachaf> Why would it be weird?
06:50:08 <ais523> shachaf: actually that feels wrong too, why would an object necessarily have only one iterator?
06:50:30 <shachaf> That seems like a pretty natural thing to do.
06:50:34 <ski> zzo38 : what does "define the characteristics for a type" and "define your own characteristics" mean, from an abstract programming language perspective, divorced from particular implemention ?
06:50:45 <ais523> C programmers are used to arrays not supporting useful operations like copying them
06:51:02 <ais523> passing a VLA by value seems even weirder
06:51:20 <shachaf> It would be fine for it to be an error.
06:51:22 <ais523> (I think that isn't possible in Rust? I don't think it can pass !Sized things by value)
06:51:27 <shachaf> I think that's better than the current semantics.
06:51:45 <ski> ais523 : "size" (vs "capacity") is about which part of the storage can be assumed to hold data properly initialized to the indicated extent, yes ?
06:51:56 <zzo38> ski: Let me to think how to explain better
06:52:02 <ais523> ski: yes
06:52:05 <ski> (ais523 : oh. i wrote that before seeing your next statement :)
06:52:25 <ais523> hmm, I should sleep
06:52:26 -!- ais523 has quit (Quit: quit).
06:54:05 <zzo38> ski: For example, there may be one characteristic for assignment, one for assignment through a pointer, one for a function call, one for taking the address of a function, one for declaring a global variable, and so on; you can define your own characteristics for your own operations. These may expand them into macros, and the macros may then expand into LLVM codes, or may define other macros or do other things.
06:54:51 <esowiki> [[MUSYS]] M https://esolangs.org/w/index.php?diff=63184&oldid=63183 * Salpynx * (+127) /* External resources */ link to macrogenerator article
06:55:09 <ski> shachaf : yes, however the size sometimes isn't stored directly next to the storage reference (as i'm sure you know). e.g. `exists m,n. int[m][n]'
06:55:43 <zzo38> (System include files would include many macros for converting C types into LLVM types, and for filling in the target datalayout and target triple in the LLVM code)
06:55:59 * ski agrees with ais523's "storing it in the array seems wrong"
06:57:01 <shachaf> Hmm. What would you do instead?
06:57:45 <ski> hmm .. is `void foo(const size_t N,int x[static N]) { ... }' possible, in C ?
06:58:29 <shachaf> I doubt it.
06:58:37 <shachaf> No. What would it mean?
06:59:24 <shachaf> I guess it could have some meaning.
07:00:43 <ski> zzo38 : "like is possible in Haskell, for example, but not Haskell" sounded self-contradictory, to me
07:01:52 -!- AnotherTest has joined.
07:01:56 <ski> zzo38 : i'm still not really understanding what you're talking about, in your descriptions about user-declared "characteristics" for data types. perhaps some example(s) would help elucidate ?
07:03:47 <ski> shachaf : "What would you do instead?" -- i'm not arguing that having the effect of "storing it in the array" should be avoided. i'm just saying that, at least in a more desugared/primitive view, "storing it in the array" should be seen as an extra wrapping, around "the array"
07:03:54 <zzo38> One example would be the sizeof operator in C. If you use the system macros then this characteristic is automatically defined for you, but if you don't, then you must either define it yourself or else the type does not have a size.
07:05:30 <ski> zzo38 : are you saying that `sizeof T', for some type `T' (in scope), may not work, unless appropriate header files defining macros have been included ?
07:05:50 <shachaf> I've been trying to describe how you'd write some of these array types in C++ but I'm not sure C++ can even express it.
07:05:53 <zzo38> Also some parameterized types may require certain characteristics (an example is that an ordinary pointer type requires a size of the type pointed to if you will make pointer arithmetic, allocations, etc)
07:06:23 <ski> <shachaf> There's a feature related to this that C++ doesn't really support, which is to have something which can either be a compile-time argument or a runtime argument.
07:06:26 <ski> <shachaf> C++ supports the former with templates and the latter with arguments, but it doesn't let you abstract over them.
07:06:38 <ski> from one POV, this is a matter of partial evaluation
07:07:16 <ski> (at least the first message)
07:07:33 <zzo38> ski: That is the case, although not exactly what I meant. What I meant is that if you use a macro to define a type (for example, the "struct" macro) then it may define the "sizeof" characteristic of that type too, but if you use the primitive operations to define a type then you must define all of its characteristics by yourself (and if they are incorrect, then your program probably will not work).
07:08:02 <ski> i suppose if you want to generalize over variables ranging over phases, that could be more involved
07:08:31 <shachaf> ski: I don't think that point of view makes things simpler, rather than more complicated.
07:08:36 <zzo38> (The characteristics are optional, but some operations, and some parameterized types, may require certain characteristics; if it is specified to require it and it doesn't have it, then it is a compiler error.)
07:09:27 <ski> zzo38 : i'm not convinced it's useful to think of a "pointer" as "potentially pointing to a sequence of values of the requisite type"
07:10:07 <shachaf> Man, C is subtle.
07:10:25 <shachaf> The way it conflates arrays and pointers in some places and not others is tricky.
07:12:28 <ski> zzo38 : hm, what is this `struct' macro you're talking about ? or maybe you don't mean "macro" in the sense of CPP, but rather in terms of implementation, like how you can describe "`struct's" in assembler, via symbols bound to appropriate offset/size values ?
07:12:40 * ski nods to shachaf re partial evaluation
07:13:13 <shachaf> Ignoring that particular subtlety for a moment, you can imagine writing in C++:
07:13:34 <shachaf> template<typename T, int size> struct StaticArray { T *ptr; };
07:13:47 <shachaf> template<typename T> struct DynamicArray; { T *ptr; int size; };
07:14:08 <shachaf> And most of the code for those two types would be almost identical.
07:14:39 <zzo38> ski: Well, it is more powerful than C macros. But you can enter the code directly without using macros, which would just be LLVM codes (with the proper wrapping needed by the compiler).
07:15:33 <zzo38> (You could perform any kind of computations in these more powerful macros, and also affect other macros with it, and other stuff)
07:16:21 <ski> template<typename T> struct DynamicArray; { int size; struct StaticArray<T,size> arr; };
07:17:01 <shachaf> ski: How would that work? size isn't known at compile-time.
07:18:02 <shachaf> There's the separate and important issue that an array isn't really a pointer so this isn't right anyway.
07:18:21 <shachaf> You want sizeof StaticArray to be the size of the elements, not the size of a pointer.
07:19:07 -!- iconmaster has quit (Read error: Connection reset by peer).
07:20:36 <ski> i'm pondering a situation where we could pass a skolem `size', as opposed to only a literal, to `StaticArray'
07:20:49 -!- iconmaster has joined.
07:20:59 <ski> (perhaps it shouldn't be called `StaticArray', though)
07:21:18 <shachaf> I think I gave a bad example anyway.
07:21:33 <shachaf> StaticArray and DynamicArray should actually be quite different.
07:21:46 <ski> yea, iiuc, you want to change `T *ptr' to `T arr[size]', yes ?
07:21:59 <shachaf> I think so.
07:22:06 -!- iconmaster has quit (Read error: Connection reset by peer).
07:22:24 <shachaf> Or maybe to char mem[sizeof (T) * size]; or something.
07:22:55 <ski> zzo38 : well, i want (reasonably) high-level ways to reason about these "macros". specifically, i want to be able to reason about them in a way that isn't merely in terms of what an implementation happens to do
07:24:14 -!- iconmaster has joined.
07:24:35 <shachaf> But now I'm not really sure what DynamicArray should be.
07:25:00 <ski> template<size_t size,typename T> struct StaticArray { T arr[size]; };
07:25:05 <ski> template<typename T> struct DynamicArray { size_t size; T ptr[size]; };
07:25:09 <ski> is that closer ?
07:25:31 <zzo38> Because it is macros, they can be defined differently and therefore can do differently. The compiler would just expand the definition and use that to do such things as perform computations, emit LLVM codes, affect other macros, and insert stuff into the AST of the source code where the macro is placed; but, you can still use them for high-level purposes, and like if you use FILE* in C you don't have to know exactly how FILE is defined, it is same
07:26:09 <shachaf> ski: OK, this has clarified things a bit for me.
07:26:28 <ski> zzo38 : cut off near ".., and like if you use FILE* in C you don't have to know exactly how FILE is defined, it is same" ?
07:26:47 <zzo38> ..., and like if you use FILE* in C you don't have to know exactly how FILE is defined, it is same kind of thing here.
07:27:07 <shachaf> When I pass someone a pointer to some memory, the array size isn't going to be next to the data.
07:27:17 <shachaf> In C, I'd pass them a pointer and a size separately.
07:27:24 <ski> anyway, consier the difference between
07:27:52 <shachaf> So this DynamicArray type really should be struct { size_t size; T *ptr; };
07:27:55 <ski> template<typename T> struct DynamicArray { size_t size; struct StaticArray<size,T> arr; };
07:28:04 <ski> template<typename T> struct DynamicArrayPtr { size_t size; struct StaticArray<size,T> *parr; };
07:28:11 <shachaf> Or maybe struct { size_t size; StaticArray<T, size> *arr; };
07:28:11 <zzo38> (To do many of the things I mentioned, may need a more Lisp like syntax, although maybe with syntactic sugar for some operations.)
07:28:19 <ski> and of course
07:28:57 <ski> template<size_t M,typename T> struct DynamicArrayArr { size_t N; struct StaticArray<N,T> arr[M]; };
07:29:00 <ski> and so on
07:29:19 <ski> (naming is probably not that good, there)
07:29:30 <shachaf> Let's just figure out the N version without getting M involve.
07:29:33 <shachaf> d
07:29:42 <shachaf> It sounds like we were getting at the same thing here.
07:30:38 <shachaf> Wait, I'm confused about the third version. Is it an array of arrays?
07:30:57 <zzo38> ski: Now do you understand how I mean? Probably I am still confusing
07:31:04 <ski> my point is merely that in general you may want `exists { size_t N; Foo<StaticArray<N,T>> foo; }', for various choices of `Foo'
07:31:19 <shachaf> Aha.
07:31:39 <ski> shachaf : "OK, this has clarified things a bit for me." -- oh, i'm a bit surprised to hear that
07:31:43 <shachaf> I see your point now. You might want to pass a bunch of arrays of the same size, and only pass the size once.
07:31:47 * ski feels rather confused here
07:31:53 <ski> exactly
07:32:03 <shachaf> ski: Just imagine how confused I must've been beforehand!
07:32:35 <shachaf> ski: I feel like fitting every use case of that form into the type system may be a fool's errand.
07:33:18 <shachaf> Although... I would like to be able to write things like "void memcpy(Str<N> dst, Str<N> src);"
07:34:45 <ski> zzo38 : to be able to use such macros sensible, without needing to hold in head all the complications of an implementation (all the optimizations, &c.), one would need some kind of abstract API (or ABI ?) for such macros, how they're (abstractly) intended to be used, so that one has a reasonable chance of statically verifying (e.g. in head) correct usage, without TIAS
07:35:29 <ski> zzo38 : e.g. sexp macros are reasonably divorced from internals of implementations
07:35:32 <zzo38> I like to be able to pass partial arrays without so much difficulty like you can in C by the use of pointer arithmetic; it seems less efficient in other programming languages
07:36:15 <zzo38> ski: What does "TIAS" means? But, yes, the macros can be used without the internals of the implementation, although so far I have not described it because it is not actually invented yet
07:36:36 <ski> shachaf : "I'd pass them a pointer and a size separately." -- is the key part i was trying to communicate, yes
07:37:19 -!- iconmaster has quit (Read error: Connection reset by peer).
07:37:56 <ski> "Is it an array of arrays?" -- yes. you could have an array of pointers to arrays (or a pointer to such an array of pointers), if you'd prefer
07:38:22 <ski> zzo38 : "Now do you understand how I mean? Probably I am still confusing" -- perhaps somewhat
07:39:02 <ski> shachaf : "fitting every use case of that form into the type system may be a fool's errand" -- fitting in which sense ?
07:39:11 -!- iconmaster has joined.
07:39:15 <shachaf> ski: Anyway: I don't think the first DynamicArray you give is very useful. There's no real reason to store the size with the data.
07:40:54 <ski> (hmm .. do you mean `void memcpy(Str<N> *dst,Str<N> *src,size_t N);' or some such ?)
07:41:54 <ski> zzo38 : "Try It And See"
07:42:12 <shachaf> I'm not quite sure where N should come from.
07:42:28 <shachaf> I guess it depends on what Str is.
07:42:51 <ski> <candide> "Try It And See" may work in other languages, but not in C due to the nature of undefined behavior/unportable code. Such coding-by-experimentation often leads to situations such as "But it worked fine earlier!" and/or "But it worked on my machine!". https://goo.gl/jPWRA9
07:44:22 <ski> hmm .. i wonder what's an interesting example of mutually-dependent existentials/structs
07:46:05 <shachaf> The point is not to make an interesting type system but a simple one.
07:46:32 <ski> perhaps it should be `template<typename T> memcpy(T *dst,T *src,size_t<T> size);', where `size_t<T>' is a singleton ?
07:47:05 <ski> (yea, the mutually-dependent thing was an aside)
07:47:13 <ski> (as was the partial evaluation thing)
07:47:53 <shachaf> Why does size_t<T> being a singleton help compared to size_t?
07:48:22 <ski> we statically know it's the size of `*src' and `*dst'
07:48:38 <shachaf> How do we know that?
07:48:46 <ski> because it uses the same `T'
07:48:54 <shachaf> Oh, T is an array type or something, not the element type.
07:49:12 <ski> `T' is any type, `int' or `int[4]' or whatever
07:49:12 <HackEso> ​/srv/hackeso-code/multibot_cmds/lib/limits: line 5: exec: T': not found
07:49:45 <shachaf> Aha, I see.
07:49:50 <ski> <ski> zzo38 : i'm not convinced it's useful to think of a "pointer" as "potentially pointing to a sequence of values of the requisite type"
07:50:40 <ski> (if you were doing it in C++, you could use by-reference parameters, instead of by-value, then the types of `src' and `dst' would be `T', rather than `T *')
07:51:24 <shachaf> We should probably abandon C++ notation here anyway.
07:51:33 <shachaf> I'd like a much simpler language.
07:51:52 <ski> yes, of course
07:52:14 <ski> but it may perhaps be useful to cannibalize some notions (properly construed) from e.g. C++
07:52:20 -!- iconmaster has quit (Read error: Connection reset by peer).
07:52:22 <shachaf> Sure.
07:52:51 <shachaf> I think the point about separating size from array in some cases is a good one.
07:53:09 <ski> i think there may be a nice language where one can express moves and perfect forwarding, hidden inside C++, yearning to be freed
07:54:14 <shachaf> The goal is maybe just to take the common C idiom "void f(Thing *x, size_t n);" and make it more convenient.
07:54:25 <ski> shachaf : it's basically the same argument as to why (at least last i checked) Rust doesn't have true existentials, since you can express `exists a. C a *> a', but not `exists a. C a *> F a'. at least, that was the take-home i got, when i asked about it
07:55:09 <shachaf> Right.
07:55:28 <shachaf> (This is also true of C++ vtables, of course.)
07:55:39 -!- iconmaster has joined.
07:55:44 <ski> (yes, and interfaces in Java)
07:56:13 <shachaf> Oh, that's probably the biggest difference between type classes and interfaces.
07:57:51 <ski> OO usage of existentials tends to bundle the operations/methods with the instance/value state. while otoh ADT usage of existentials separates them. the latter can support "binary method" operations like "merge" and "compare" readily, while attempting to express such things in the former is much more clumsy and problematic
07:58:10 <shachaf> Yes.
07:58:22 <shachaf> And the same thing happens with memcpy.
07:58:50 <ski> (but then there's also the view that OO is about closures. related to the former view via `a -> b = exists x. (# x,(# x,a #) #-> b #)')
07:59:10 <ski> @where on-understanding-revisited
07:59:10 <lambdabot> "On Understanding Data Abstraction, Revisited" by William R. Cook in 2009-10 at <http://www.cs.utexas.edu/~wcook/Drafts/2009/essay.pdf>
07:59:46 <ski> elaborate on your last remark ?
08:00:00 <zzo38> I suppose the characteristics of types that I described is a bit like interface methods, but instead of methods like in object oriented programming, they have interface macros.
08:01:00 <shachaf> I mean, you can imagine having an "array" type, struct Array<T> { size_t size; T *ptr; };, representing a pointer to size elements.
08:01:21 <shachaf> Then you could write memcpy(Arr<T> dst, Arr<T> src);, and it could e.g. fail at runtime if the sizes aren't equal.
08:01:56 <shachaf> This is similar to "Ord compare(Comparable x, Comparable y);" failing at runtime when the types aren't equal.
08:02:12 <ski> yes .. and perhaps it can be useful to have some kind of more surface sugar for this notion of "bundled array"
08:02:29 <ski> ah, yes
08:02:36 <zzo38> shachaf: I think what is done in Haskell is better, you can specify the types must be the same or else it will fail at compile time.
08:03:29 <ski> `forall x. (P x -> Q x)' entails `(exists x. P x) -> (exists x. Q x)' (and also entails `(forall x. P x) -> (forall x. Q x)'), but not vice versa
08:03:30 <HackEso> ​/srv/hackeso-code/multibot_cmds/lib/limits: line 5: exec: forall: not found
08:03:43 <shachaf> The latter two are quite weak.
08:03:48 <ski> right
08:04:07 <shachaf> Or possibly unreasonably strong.
08:04:26 <shachaf> Before Java had generics, people would do things like that a lot.
08:04:38 <ski> the first is sortof the ADT way. the next one the OO way
08:04:42 <shachaf> You could write "Object id(Object arg);", which is like "(exists x. x) -> (exists x. x)"
08:05:27 <shachaf> Object is at the top of the type lattice. I don't think Java has something corresponding to the bottom of the type lattice, but if it did, you could write something equivalent to "(forall x. x) -> (forall x. x)"
08:05:43 <ski> (hm, i suppose that closure thing should be something something CoYoneda ?)
08:06:24 -!- mniip has quit (Ping timeout: 604 seconds).
08:06:38 <shachaf> Which, the unboxed tuple/function thing?
08:06:38 <ski> zzo38 : *nod*. the trick is how to be able to describe the interfaces. preferably in a static, and formal, way
08:06:49 <shachaf> I guess so.
08:06:58 <ski> yes (unboxedness is just a low-level thing, which you can ignore)
08:07:16 <shachaf> Hmm, maybe not quite.
08:07:17 <ski> (well, not the "unboxed function", "function pointer" in C)
08:07:21 -!- iconmaster has quit (Read error: Connection reset by peer).
08:07:35 <shachaf> CoYoneda f a = exists x. (x, f x -> a)
08:07:52 <shachaf> No.
08:07:57 <shachaf> CoYoneda f a = exists x. (f x, x -> a)
08:08:23 -!- mniip has joined.
08:08:37 <shachaf> I don't think that works.
08:09:32 <ski> i suppose we have `exists x. (P x /\ Q x)' entailing `(exists x. P x) /\ (exists x. Q x)' (but not vice versa), and also `forall x. (P x /\ Q x)' entailing `(forall x. P x) /\ (forall x. Q x)' (and vice versa), complementing the above distribution rule (namely for use with multiple parameters, or multiple results)
08:09:52 -!- iconmaster has joined.
08:10:40 * ski nods re `Object',&c.
08:11:42 <ski> a -> b
08:11:56 <ski> = exists x. x * (x -> a -> b)
08:12:00 <ski> = exists x. x * (x * a -> b)
08:12:31 <ski> however, possibly one can do something more exponentialy, here ?
08:12:54 <ski> hm, i suppose `x -> a -> b' really is `x >---> (a -> b)' anyway
08:13:39 <zzo38> In my proposed system, although there are interfaces similar to object oriented programming, they are purely compile-time interfaces, and there aren't any actual objects anywhere.
08:13:53 <ski> (curried continuations seems strange, on some leve)
08:15:26 <ski> fwiw, `exists x. (P x -> Q x)' also entails `(forall x. P x) -> (exists x. Q x)'. and there was also some (classical) variations where `\/' was used (Phoa ?)
08:16:08 <shachaf> I wonder how the linear logic connectives work here.
08:16:21 <ski> good question :)
08:16:27 <shachaf> Though this is quite far from the question of how to represent memory layout.
08:16:31 <ski> yes
08:17:24 <shachaf> I think if the types get too complicated, it's better to return to the C solution of letting people specify sizes manually.
08:17:31 <ski> zzo38 : mhm. i can't say i quite see what you mean there
08:17:44 -!- S_Gautam has quit (Quit: Connection closed for inactivity).
08:19:50 <ski> perhaps. at least if there's static checking that the sizes are correct ?
08:20:10 <ski> <ski> shachaf : "fitting every use case of that form into the type system may be a fool's errand" -- fitting in which sense ?
08:20:35 <shachaf> I'm not sure whether the static checking in arbitrary cases (like an array of arrays that are all the same size) is worth the type system complexity.
08:21:09 <shachaf> I think I meant being able to express the size constraints correctly in the type system in every case.
08:21:20 <ski> okay
08:21:43 <shachaf> This is for a language meant to compete with C.
08:22:22 -!- iconmaster has quit (Read error: Connection reset by peer).
08:22:32 <ski> it at least ought to have (blind) universals and existentials, quantifying tyvars
08:22:34 <shachaf> But maybe it's less complex than I think, in which case it's probably a good idea.
08:22:44 <shachaf> Blind?
08:22:48 * ski . o O ( BitC,Cyclone )
08:23:06 <ski> proof-erasure. no type-info passed at run-time
08:23:37 <shachaf> Oh. Possibly.
08:23:53 <shachaf> But most of the cases we've been discussing do pass a size at runtime.
08:23:54 <ski> (so `size_t<T>' would be an explicit way of storing the size aspect of such run-time type information)
08:24:39 -!- iconmaster has joined.
08:24:43 <ski> yes, but not implicitly, we had `template<typename T> memcpy(T *dst,T *src,size_t<T> size);', not `template<typename T> memcpy(T *dst,T *src);'
08:24:53 -!- aloril_ has quit (Remote host closed the connection).
08:24:56 <ski> `template' here is a universal, a `forall'
08:24:56 <HackEso> ​/srv/hackeso-code/multibot_cmds/lib/limits: line 5: exec: template': not found
08:25:56 <ski> (otoh, in `template<typename T> struct Foo { ..T.. };', `template' is not a universal over types, but rather over declarations)
08:26:12 <shachaf> I see.
08:27:26 <ski> (i suppose in the former case, we can also see it as being over a declaration. but we can translate to a `forall' over a type. but in the latter case, we get a type lambda, which is something else)
08:28:24 <ski> one could possibly also have non-blind quantifiers (e.g. for size of types), in such a language, if we wanted to sometimes avoid the verbosity of manually passing size
08:28:45 -!- aloril has joined.
08:29:26 <ski> or, you could have `size_t' parameters of your types, which you sometimes might want to quantify blindly over, and sometimes non-blindly
08:30:45 <shachaf> Huh, I never thought of that. template on structs means something different from functions, sort of.
08:30:56 <shachaf> (But if the struct has a method, it's back to meaning forall?)
08:31:30 <shachaf> That's not really true, they're kind of the same thing.
08:31:49 <ski> `type ReadS a = String -> [(a,String)]' conceptually is `forall a. type ReadS a = String -> [(a,String)]'. which is `type ReadS = \a. String -> [(a,String)]'
08:31:49 <HackEso> ​/srv/hackeso-code/multibot_cmds/lib/limits: line 5: exec: type: not found
08:31:59 <shachaf> Right.
08:32:43 <ski> while `length :: [a] -> Int' conceptually is `forall a. (length :: [a] -> Int)', which corresponds to `length :: forall a. ([a] -> Int)' (or `length :: (exists a. [a]) -> Int')
08:33:08 <ski> and `forall a. tau[a]' is very different from `\a. tau[a]'
08:33:30 <shachaf> Yes.
08:33:43 <shachaf> (Though I heard Typed Racket somehow conflates them?)
08:33:44 <ski> (i once attempted to untangle such a conflation of those two things, of someone i chatted with)
08:34:14 <ski> (hm, i don't recall. i probably haven't checked Typed Racket in detail enough ?)
08:34:40 <shachaf> I think that was the language. Someone mentioned it once and I thought it was very odd.
08:34:52 <ski> could well be the case
08:35:18 <ski> (iirc, the one i was talking to at the time may have been gio123 ?)
08:35:41 <shachaf> Oh, maybe it conflated type application with forall, or something.
08:37:24 <shachaf> Man, put me in the ski fan club.
08:37:33 <shachaf> ski has all sorts of clear thinking about all sorts of things.
08:37:37 * ski twitches
08:37:53 -!- iconmaster has quit (Read error: Connection reset by peer).
08:38:40 -!- iconmaster has joined.
08:39:16 <ski> anyway .. before this whole conversation started (just before i posted the blitter link), i composed the following (one) message :
08:39:26 <ski> one can of course think of `i * n + j' not in terms of nested/curried arrays, but in terms of structured indices (so "uncurried arrays")
08:40:09 <ski> (this was partly in relation to someone in #haskell asking about arrays, such as curried ones)
08:40:11 <shachaf> Yes, I think that's probably better.
08:40:33 <ski> if you care about it, i could perhaps go on a little about what i had in mind here
08:41:05 <shachaf> I'm happy to hear it.
08:41:46 <ski> well, consider finite types, considered as prefixes of the natural numbers (with the arithmetic/additive ordering)
08:42:05 <shachaf> By the way, did you see my unrelated language proposal to make all functions take one argument, but not curried, and to have very convenient struct literals? I think it would be better than the usual system but I don't know of any language that does it.
08:42:48 <ski> types `Fin n' in Agda, conceptually having as values `0',..,`n-1' (so they're basically finite ordinals, or finite well-orderings (i think) corresponding to such "abstractly")
08:43:17 <ski> i did not see any such proposal. in which channel ?
08:43:54 <shachaf> It might not have been in any channel you were in. Probably only half-heartedly in any channel at all. I could say more later.
08:44:44 <ski> (btw, i think Datalog is missing records, or at least named parameters. for large relations, you don't want to have to refer to attributes/parameters by position)
08:45:00 <ski> okay
08:45:10 <ski> (perhaps you could remind me later)
08:46:54 <ski> so. let's write typing judgements like `0 :< n',...,`n-1 :< n' for the "indices" in such an "finite (natural) index type" `n'
08:49:08 <ski> now, consider
08:49:14 <ski> 012345
08:49:19 <ski> 0 ******
08:49:24 <ski> 1 ******
08:49:28 <ski> 2 ******
08:49:31 <ski> 3 **+...
08:49:33 <ski> 4 ......
08:51:04 <ski> and assume a row-major total (well-)ordering, so that we count first row as `0',`1',`2',`3',`4',`5', second as `6',`7',`8',`9',`10',`11', and so on, with last "cell" being numbered `5*6 - 1'
08:52:38 -!- iconmaster has quit (Read error: Connection reset by peer).
08:52:39 <ski> (`5 * 6' being "five times six"/"six, five times", with `5' being the multiplier (the "counter") and `6' the multiplicand (the duplicated thing), so that we have `5 * 6' being `6 + 6 + 6 + 6 + 6', not `5 + 5 + 5 + 5 + 5 + 5')
08:52:59 <ski> now, we have an inference rule
08:53:39 -!- iconmaster has joined.
08:54:06 <ski> i :< m j :< n
08:54:11 <ski> ------------------ *
08:54:18 <ski> i * n + j :< m * n
08:54:44 <ski> (so `i' counts rows, and `j' counts columns / elements into a row)
08:55:30 <ski> and the index marked `+' would correspond to selecting `i' as `3' and `j' as `2', getting `3 * 6 + 2' as the element of `5 * 6'
08:55:52 <ski> of course, we have something similar for sums
08:56:35 <ski> 01234 012345
08:56:38 <ski> ***+. ......
08:56:40 <ski> or
08:56:43 <ski> 01234 012345
08:56:52 <ski> ***** *+....
08:57:04 <ski> with inference rules
09:00:34 <ski> i :< m j :< n
09:00:44 <ski> ---------- +0 -------------- +1
09:00:51 <ski> i :< m + n m + j :< m + n
09:01:37 <ski> so, in the first `+' example, we have `3 :< 5 + 6'; while in the second, we have `5 + 1 :< 5 + 6'
09:02:01 <shachaf> Tangentially, have you seen this post? https://blog.nelhage.com/2015/08/indices-point-between-elements/
09:02:36 <ski> you may think of `i * n + j',`i',`m + j' as data constructors, having `i',`j', respectively either `i' or `j' as parameters. the data constructor in the `i :< m + n' case is not notated explicitly
09:04:08 <ski> i haven't. ty for the suggestion
09:06:12 <ski> anyway, before taking the next step here, i want to introduce a dependent version of the product
09:07:51 -!- iconmaster has quit (Read error: Connection reset by peer).
09:08:35 <ski> example
09:08:39 <ski> 012345
09:08:41 -!- iconmaster has joined.
09:08:46 <ski> 0 ******
09:08:51 <ski> 1 *****
09:08:54 <ski> 2 ****
09:08:58 <ski> 3 *+.
09:08:59 <ski> 4 ..
09:11:40 <shachaf> This is a dependent sum, I guess? Like a sigma?
09:13:59 <ski> so, here i in general have a type `sum_{0 =< i < m} n_i', which i'll notate as `m (>: i) * n_i'. so in this particular case, this would be `5 (>: i) * (6 - i)', where `6 - i' is valid because `i :< 5', and `5-1 =< 6' (that is perhaps not so nice a condition. let's ignore issues such as this subtraction, for now)
09:14:14 <ski> yes. this is a "ragged index type"
09:15:36 <shachaf> For an array of arrays where each subarray has a different size, but they're all packed in memory together.
09:17:11 <ski> yes, this could be used as index type for such an array (but i'm only really considering these "index types" themselves (cf. "parameter types" in "Grammatical Framework", Aarne Ranta), not, currently at least, how they could actually be used with arrays, though obviously that would hopefully be a useful application)
09:19:24 <shachaf> Presumably you'd want efficient rank/select support as well for actual indexing use.
09:21:05 <ski> (in GF, parameter types are like algebraic types, but more restricted (can't be recursive), they are used as indices of "tables", which are some sort of record or (total) finite map construction)
09:21:21 <ski> i :< m j :< n_i (i :< m)
09:21:26 <ski> -------------------------------------- *
09:21:29 <ski> i (>: i') * n_i' + j :< m (>: i) * n_i
09:22:19 <ski> here we make use of that i' :< i and also i :< m and therefore i' :< m and thus n_i' makes sense
09:22:51 <ski> we count i initial full rows, and then we count j into the `i'th row
09:23:06 <ski> makes sense ?
09:23:07 -!- iconmaster has quit (Read error: Connection reset by peer).
09:23:52 -!- iconmaster has joined.
09:24:13 <shachaf> Makes sense.
09:24:18 <ski> okay
09:29:31 <shachaf> (Is there more?)
09:30:02 <ski> yes
09:31:54 <ski> hm, i was pondering a (partly) tangent, whether it fit in here or not. i think it may fit after the next part
09:36:52 <ski> ok, example
09:37:30 <ski> 0 01234 1 01234 2 01234 3 01234 4 01234
09:37:34 <ski> 0 ***** ***** ***** ..... .....
09:37:42 <ski> 1 ***** ***** ***** ..... .....
09:37:47 <ski> 2 ***** ***** ***+. ..... .....
09:37:53 <ski> 3 ***** ***** ..... ..... .....
09:37:55 <ski> 4 ***** ***** ..... ..... .....
09:38:08 -!- iconmaster has quit (Read error: Connection reset by peer).
09:38:15 <ski> this is considering `5 ^ 3'
09:38:42 -!- iconmaster has joined.
09:43:47 <ski> inference rule
09:43:59 <ski> j_i :< n (i :< m)
09:44:02 <ski> ----------------------------- ^
09:44:05 <ski> m (>: i) * n^i * j_i :< n ^ m
09:45:49 <ski> think of `i' as counting down from `m-1' to `0'. in the above example, we have `3 (>: i) * 5^i * j_i :< 5 ^ 3', where `j_0 = 2',`j_1 = 2',`j_2 = 3'
09:46:55 <ski> er, sorry, that should be `j_2 = 2',`j_1 = 2',`j_0 = 3'
09:47:05 <ski> we could think of `3 (>: i) * 5^i * j_i' as `5^2 * 2 + 5^1 * 2 + 5^0 * 3'
09:48:00 <ski> it's also possible to formulate a dependent version, iow `n_i ^ (i :<) m', aka `product_{0 =< i < m} n_i', but i think i'll skip (rederiving) it, now
09:49:34 <ski> btw, one nice consequence of this is that if we regard `m * n' as meaning `m (>: _) * n', then if we define `C(n,k)' (where we might suppose `k :< n+2', so that the following subtraction is a natural number) as `(n - i) ^ (i :<) k'
09:51:51 <ski> then e.g. `C(3,6)' (where `6 :< 3+2' does *not* hold) would be `(3 - i) ^ (i :<) 6', which with an expansion could mean `(3 - 0) * (3 - 1) * (3 - 2) * (3 - 3) * (3 - 4) * (3 - 5)', so it looks like we're referring to negative integers here
09:53:09 -!- iconmaster has quit (Read error: Connection reset by peer).
09:54:44 -!- iconmaster has joined.
09:54:59 -!- atslash has joined.
09:55:42 <ski> however, if we interpret this expression as `(3 - 0) (>: i_0) * (3 - 1) (>: i_1) * (3 - 2) (>: i_2) * (3 - 3) (>: i_3) * (3 - 4) (>: i_4) * (3 - 5) (>: i_5) * 1', we see that since `3 - 3' is `0', `i_3' can't exist, and so we can vacuously show the body `(3 - 4) (>: i_4) * (3 - 5) (>: i_5) * 1' (corresponding to `(3 - 4 - i') ^ (i' :<) 3') is well-formed
09:56:06 <ski> anyway. that's more or less an aside, which i thought was kind of neat
09:56:34 <ski> as you can imagine, this is more or less half-baked ideas, which i've been mulling over, occasionally, for some time
09:56:53 <ski> one could also consider other types like `n!' e.g.
09:57:02 <ski> or facoriadic number representation
09:57:29 <ski> yea, i only discussed finite index types above, but you can also, at least to some extent, consider countable ones
09:57:50 <ski> (and all these have an associated total order, or perhaps it's well-ordering)
09:59:08 <ski> (btw, you may note that there seems to be something "telescopish" going on in the `C(n,k)' example, although of a rather simple sort)
09:59:16 <ski> shachaf : i suppose that's more or less what i wanted to say about this
10:01:25 <ski> shachaf : ty again for the "Multi-dimensional array views for systems programmers" link (i have been pondering some things in a sortof related direction, i think, after hearing a talk about SA-C. but it seems that link you gave gives a much clearer picture of those things, so i'm grateful for that)
10:01:58 <ski> (i'll have to check out the "Indices point between elements" link as well, ty)
10:04:36 <shachaf> ski: Hmm, I think I was expecting this to turn back into array indexing at one point, but in retrospect that was silly.
10:07:35 <shachaf> I see how the 3D version works now.
10:09:03 -!- ski has quit (Ping timeout: 264 seconds).
10:09:52 -!- Phantom_Hoover has joined.
10:24:22 <esowiki> [[Home Row]] M https://esolangs.org/w/index.php?diff=63185&oldid=57019 * TuxCrafting * (-1) off -> of
10:34:02 -!- iconmaster has quit (Quit: Leaving).
10:53:25 -!- AnotherTest has quit (Ping timeout: 252 seconds).
10:55:22 <esowiki> [[Forth]] https://esolangs.org/w/index.php?diff=63186&oldid=43460 * A * (+25)
10:55:30 -!- AnotherTest has joined.
10:57:22 -!- S_Gautam has joined.
10:58:00 <esowiki> [[Forth]] https://esolangs.org/w/index.php?diff=63187&oldid=63186 * A * (+45) /* External resources */
11:13:36 -!- AnotherTest has quit (Ping timeout: 248 seconds).
11:43:21 -!- b_jonas has joined.
11:45:55 -!- sebbu3 has changed nick to sebbu.
12:22:07 <esowiki> [[Adar]] N https://esolangs.org/w/index.php?oldid=63188 * TuxCrafting * (+974) Created page with "Adar is an esoteric "programming language" created by [[User:TuxCrafting]]. = Structure = An Adar program is a list of triplets of integers. Each triplet represent..."
12:23:41 <esowiki> [[Language list]] https://esolangs.org/w/index.php?diff=63189&oldid=63169 * TuxCrafting * (+11)
12:24:10 <esowiki> [[User:TuxCrafting]] https://esolangs.org/w/index.php?diff=63190&oldid=63170 * TuxCrafting * (+11)
12:39:39 <esowiki> [[Adar]] M https://esolangs.org/w/index.php?diff=63191&oldid=63188 * A * (+49) /* Infinite counter */
12:40:25 <esowiki> [[Adar]] M https://esolangs.org/w/index.php?diff=63192&oldid=63191 * A * (+24) /* Examples */ Links
12:40:47 <esowiki> [[Adar]] M https://esolangs.org/w/index.php?diff=63193&oldid=63192 * A * (+0) /* Looping counter */ Oops
12:41:41 <esowiki> [[Adar]] M https://esolangs.org/w/index.php?diff=63194&oldid=63193 * A * (+74) /* Computational class */ Some models
12:46:27 <b_jonas> ais523: yes, rust doesn't allow copying dynamically sized values. there's a proposal to allow it, with limitations, accepted but currently unimplemented: https://github.com/rust-lang/rust/issues/48055
12:49:24 <b_jonas> ais523: basically this would allow you to create a dynamic sized array or trait object and assign it to a fresh local variable, implemented as an alloca, or pass such an object by value as a function argument, implemented as passing a pointer
12:49:41 <b_jonas> as passing a fat pointer I mean
12:49:54 <esowiki> [[Adar]] https://esolangs.org/w/index.php?diff=63195&oldid=63194 * TuxCrafting * (+11) wording
12:50:53 <b_jonas> the first part would be somewhat similar to VLA local variables in C, though with very different syntax
13:10:09 -!- FreeFull has joined.
13:10:31 <esowiki> [[Adar]] https://esolangs.org/w/index.php?diff=63196&oldid=63195 * TuxCrafting * (+698)
13:43:03 <esowiki> [[Adar]] https://esolangs.org/w/index.php?diff=63197&oldid=63196 * TuxCrafting * (-241) simplify the language by removing the trigger value, since it is as powerful as just >= 0
13:44:21 -!- sprocklem has quit (Ping timeout: 244 seconds).
13:52:28 -!- AnotherTest has joined.
14:12:58 -!- AnotherTest has quit (Ping timeout: 245 seconds).
14:13:44 -!- Lord_of_Life has quit (Ping timeout: 272 seconds).
14:14:56 -!- Lord_of_Life has joined.
14:18:33 -!- AnotherTest has joined.
14:25:48 -!- xkapastel has joined.
14:27:03 <esowiki> [[Adar]] M https://esolangs.org/w/index.php?diff=63198&oldid=63197 * A * (+242) /* Computational class */ Sorry, the internet bar closed, so I was inactive for a while.
14:27:31 <esowiki> [[Adar]] https://esolangs.org/w/index.php?diff=63199&oldid=63198 * A * (-242) /* Simulating inequality to 0 */
14:28:11 <esowiki> [[Adar]] M https://esolangs.org/w/index.php?diff=63200&oldid=63199 * A * (+4) /* Adar-= */
14:28:11 -!- AnotherTest has quit (Ping timeout: 258 seconds).
14:32:42 <esowiki> [[Adar]] https://esolangs.org/w/index.php?diff=63201&oldid=63200 * A * (-2) Better wording
14:41:51 <esowiki> [[Adar]] https://esolangs.org/w/index.php?diff=63202&oldid=63201 * A * (+12)
14:53:00 <esowiki> [[Talk:Adar]] N https://esolangs.org/w/index.php?oldid=63203 * A * (+185) Created page with "== Adar Interpreter == Can you describe how the Adar interpreter is supposed to work? I can't get it to work. --~~~~"
14:55:00 <esowiki> [[Adar]] M https://esolangs.org/w/index.php?diff=63204&oldid=63202 * A * (+30) /* Infinite loop */
14:56:32 <esowiki> [[Talk:Adar]] M https://esolangs.org/w/index.php?diff=63205&oldid=63203 * A * (+257)
14:57:20 <esowiki> [[Adar]] M https://esolangs.org/w/index.php?diff=63206&oldid=63204 * A * (+45) /* Computational class */
15:00:33 -!- zzo38 has quit (Ping timeout: 252 seconds).
15:02:23 <esowiki> [[Talk:Adar]] M https://esolangs.org/w/index.php?diff=63207&oldid=63205 * A * (+373)
15:02:26 <esowiki> [[Adar]] M https://esolangs.org/w/index.php?diff=63208&oldid=63206 * TuxCrafting * (-2) no idea where you got that word, but "pair" is correct
15:02:47 <esowiki> [[Talk:Adar]] M https://esolangs.org/w/index.php?diff=63209&oldid=63207 * A * (+62) /* JPDEC + INC is computationally equivalent to JZDEC */
15:03:11 <esowiki> [[Talk:Adar]] M https://esolangs.org/w/index.php?diff=63210&oldid=63209 * A * (+73) /* JPDEC + INC is computationally equivalent to JZDEC */
15:03:56 <esowiki> [[Talk:Adar]] M https://esolangs.org/w/index.php?diff=63211&oldid=63210 * A * (-13) /* Adar Interpreter */
15:04:36 <esowiki> [[Talk:Adar]] M https://esolangs.org/w/index.php?diff=63212&oldid=63211 * A * (+1) grammar is hard
15:05:38 <esowiki> [[Talk:Adar]] https://esolangs.org/w/index.php?diff=63213&oldid=63212 * A * (+102) /* JPDEC + INC is computationally equivalent to JZDEC */
15:06:17 <esowiki> [[Talk:Adar]] M https://esolangs.org/w/index.php?diff=63214&oldid=63213 * A * (+64) /* Adar Interpreter */
15:06:19 -!- zzo38 has joined.
15:06:53 <esowiki> [[Talk:Adar]] https://esolangs.org/w/index.php?diff=63215&oldid=63214 * TuxCrafting * (+277)
15:08:10 <esowiki> [[Talk:Adar]] M https://esolangs.org/w/index.php?diff=63216&oldid=63215 * A * (-111) /* "Turing completeness proof" - invalid due to current update */
15:08:52 <esowiki> [[Talk:Adar]] M https://esolangs.org/w/index.php?diff=63217&oldid=63216 * TuxCrafting * (-275) stop blanking your comments and breaking threads ffs
15:09:24 <esowiki> [[Adar]] M https://esolangs.org/w/index.php?diff=63218&oldid=63208 * A * (-45) /* Computational class */
15:11:43 <esowiki> [[Talk:Adar]] https://esolangs.org/w/index.php?diff=63219&oldid=63217 * TuxCrafting * (+394)
15:14:04 <esowiki> [[Adar]] M https://esolangs.org/w/index.php?diff=63220&oldid=63218 * A * (+241) /* Structure */ It should be noted here
15:17:16 <esowiki> [[Talk:Adar]] M https://esolangs.org/w/index.php?diff=63221&oldid=63219 * A * (+163) /* Adar Interpreter */
15:18:48 <esowiki> [[Talk:Adar]] https://esolangs.org/w/index.php?diff=63222&oldid=63221 * TuxCrafting * (+314)
15:19:23 <esowiki> [[Talk:Adar]] M https://esolangs.org/w/index.php?diff=63223&oldid=63222 * A * (+525)
15:20:54 <esowiki> [[Talk:Adar]] M https://esolangs.org/w/index.php?diff=63224&oldid=63223 * A * (+88) End this thread
15:38:51 -!- AnotherTest has joined.
15:44:55 -!- AnotherTest has quit (Ping timeout: 258 seconds).
15:48:28 <int-e> . o O ( One has to admire writers who manage to wrap up a trilogy in just three books. )
16:03:31 -!- AnotherTest has joined.
16:09:50 -!- AnotherTest has quit (Ping timeout: 258 seconds).
16:11:08 <esowiki> [[Adar]] https://esolangs.org/w/index.php?diff=63225&oldid=63220 * TuxCrafting * (+195) add truth machine
16:17:13 -!- AnotherTest has joined.
16:18:23 <zzo38> Now that JavaScript has bigint I would also want popcount, for example if you use a bigint to store which slots are in use, to find the first unused slot by popcount(x&~(x+1n)). It can be done with emulation, but that would make it slow; a built-in popcount function would improve the speed.
16:35:50 -!- AnotherTest has quit (Ping timeout: 258 seconds).
17:16:08 <zzo38> Has anyone won a game of Magic: the Gathering by taking advantage of rule 718.3?
17:21:26 <b_jonas> zzo38: dunno, you probably need Karn for that
17:24:21 <zzo38> b_jonas: Yes, I would think so; that is the only way to possibly invoke rule 718 anyways, as far as I can tell (rule 718.1 says so).
17:28:50 <b_jonas> it's not the only way technically
17:28:56 <b_jonas> there's Shahrazad too I think
17:29:22 <b_jonas> and maybe also drafting lots of Conspiarcy cards
17:29:55 <b_jonas> I mean Advantageous Proclamation
17:30:24 <b_jonas> hmm, would that work? you'd need seven
17:30:32 <b_jonas> should be possible in theory
17:31:06 <zzo38> Yes, Shahrazad can do that too, although the rule number is different in that case (719.3 rather than 718.3, but those rules are the same).
17:31:07 <b_jonas> I think Shahrazad is why that rule was originally there, even before Karn
17:31:26 <zzo38> Yes, probably
17:31:36 <b_jonas> but of course Shahrazad is banned now, and I for one am glad it is
17:32:52 <b_jonas> I'm looking at the new cards from Modern Horizons that are revealed since I last saw the list. https://scryfall.com/card/mh1/117/alpine-guide is an awesome red spin on those blue scouts that search for a land.
17:34:50 <b_jonas> there are also some nice reprints
17:35:08 <b_jonas> and of course I like Changeling Outcast simply because it's a cheap changeling
17:35:17 <b_jonas> black too, very useful
17:35:55 <b_jonas> I'm not through the whole list yet
17:36:35 <b_jonas> reprinting the better cycling lands can't hurt
17:36:42 <b_jonas> though I think I prefer the old art
17:37:51 -!- atslash has quit (Read error: Connection reset by peer).
17:38:29 -!- atslash has joined.
17:49:37 <b_jonas> I'd seen Defile last week already. That will be a nice addition to black's arsenal of cheap D removal spells, such as Disfigure, Deathmark, Doom Blade
17:54:05 <zzo38> In GURPS game I play my character is Ziveruskex and his friend's name is Strixan, I thought, to make up a Magic: the Gathering cards of it? I also thought of a idea of a keyword ability called "disable". A creature that is tapped, detained, or attacking, cannot use the disable ability; otherwise it is declared when declaring attacking and then the opponent's creature is tapped and detained.
17:54:53 <zzo38> The opponent's creature is unaffected if it is protected or if opponent pays {2}. I thought maybe some other keyword abilities other than protection could also be counted to determine whether or not it could block it, perhaps also flying, reach, and shadow.
17:55:43 <b_jonas> huh? which creature of the opponent is tapped and detained? I don't understand this
17:56:26 <zzo38> The one you are trying to disable. It must be a creature controlled by the defending player (which is always an opponent, although if some variant permits a defending player other than an opponent, you can disable their creatures too)
18:01:08 <b_jonas> and I think I already said that reprinting Snow-Covered Plains is amazing
18:01:37 <b_jonas> and Snow-Covered Swamp
18:13:04 <zzo38> I am not so sure what the cost to defend against disable should be defined as (or if it should be a parameter), and if other keyword abilities should also be checked, and if so which ones (I think perhaps protection, flying, reach, and shadow; at least protection, I think)
18:21:20 -!- zzo38 has quit (Ping timeout: 248 seconds).
18:22:35 <b_jonas> Ephemerate => instead of these fancy variants with flashback or rebound, can we just get a Cloudshift with hybrid {U/W} mana cost? It wouldn't be overpowered, but would be fun.
18:35:26 -!- nfd9001 has joined.
18:37:26 -!- zzo38 has joined.
18:41:32 -!- zzo38 has quit (Disconnected by services).
18:41:36 -!- zzo38 has joined.
18:44:41 <zzo38> Why did the cursor blinking stop in all windows for a few seconds? Other than that it worked; only the cursor blinking stopped. But now the cursor blinking works again.
18:50:17 <zzo38> (The clock also continued to count the seconds even while the cursor blinking was stopped.)
18:52:08 -!- AnotherTest has joined.
18:52:24 <b_jonas> https://scryfall.com/card/mh1/170/llanowar-tribe => now this one is cool
18:53:07 <b_jonas> I'm not saying it obsoletes Joraga Treespeaker or Elvish Archdruid, but it goes to that slot
18:58:19 -!- xkapastel has quit (Quit: Connection closed for inactivity).
19:02:20 -!- AnotherTest has quit (Ping timeout: 258 seconds).
19:04:05 <b_jonas> Putrid Goblin => oh nice, another good small black creature from the set
19:11:33 <b_jonas> hmm, a modified Humble, this will be nice
19:11:42 <b_jonas> https://scryfall.com/card/mh1/23/reprobation I mean
19:21:38 <b_jonas> https://scryfall.com/card/mh1/181/springbloom-druid => this one is nice too, it might work in my elf deck
19:30:54 <b_jonas> https://scryfall.com/card/mh1/235/universal-automaton => oh wow, that's even better! a changeling artifact
19:31:19 <b_jonas> also has a relevant name for #esoteric
19:47:04 -!- AnotherTest has joined.
19:53:47 <b_jonas> and yes, the Spore Frog reprint is good too
20:02:32 -!- atslash has quit (Quit: This computer has gone to sleep).
20:15:31 -!- AnotherTest has quit (Ping timeout: 252 seconds).
20:16:43 -!- S_Gautam has quit (Quit: Connection closed for inactivity).
20:51:53 -!- xkapastel has joined.
21:07:15 <zzo38> Maybe a card could be like: Ziveruskex {?} Legendary Creature - ? (1/3) ;; Flying ;; Disable ;; Banding ;; Partner with Strixan ;; {1U}, {T}: Scry 2. I haven't put the mana cost and subtype(s), and some other details may be altered too. I wanted to try to do so that the color identity of Ziveruskex and Strixan together include all five colors.
21:07:35 -!- int-e has left.
21:09:31 <zzo38> And then maybe: Strixan {?} Legendary Creature - ? (2/3) ;; Flying ;; Disable ;; Flanking ;; Partner with Ziveruskex and then I don't know?
21:10:03 -!- oerjan has joined.
21:10:05 <b_jonas> what? the reminder text for those three abilities on Ziv would be like three cards long
21:10:15 <b_jonas> and isn't he a Homunculus for the creature type?
21:10:49 <b_jonas> no wait, not a homunculus
21:10:51 <b_jonas> a squidfolk
21:11:11 <zzo38> Homunculus? I don't think so? But, I like to omit reminder text anyways
21:12:50 <b_jonas> birdfolk and catfolk are creature typed bird and cat in M:tG, but treefolk aren't typed forest
21:13:02 <zzo38> Squid folk I don't think so either, not for Ziv
21:13:03 <b_jonas> rhinofolk are typed rhino too I think
21:13:15 <zzo38> Also, "Forest" is a subtype for lands, not for creatures
21:13:22 <b_jonas> yeah, that's why they aren't
21:13:33 <b_jonas> for creatures you have Treefolk and Dryad
21:13:43 <b_jonas> oh, and Planmt
21:13:45 <b_jonas> Plant
21:16:13 -!- adu has joined.
21:19:01 <b_jonas> and then there's the Rat Ninja
21:19:47 <oerjan> @messages-loud
21:19:47 <lambdabot> ais523 said 6d 6h 22m 9s ago: counterexamples to the Goldbach conjecture aren't prime anyway (although they can't end in 3, so the example was dubious in another way)
21:19:51 <oerjan> doh
21:23:35 <zzo38> Yes, there is Rat Ninja, and I don't know what other ninjas (I once invented a Wall Ninja card, but of course that is not official)
21:25:30 <zzo38> (For the cards I just wrote, the closest I can think seems to be Bird, although it seem a strange kind of birds even for Magic: the Gathering cards. Of course, it isn't official cards anyways, so maybe it is not matter. New subtypes can also be invented if needed, but maybe it isn't needed.)
21:26:51 <zzo38> (And I don't know if there should be two subtypes; some cards have two. Some even have more than two, but that would be excessive I think.)
21:37:12 <b_jonas> why would they be strange kinds of birds?
21:37:31 <b_jonas> kand yes, they could have two subtypes, eg. Bird Wizard
21:39:07 <zzo38> Ziveruskex and Strixan have feathers and wings and sharp beak, but also five eyes, antennas, scales, etc
21:39:31 <oerjan> <shachaf> oerjan: Wasn't that the joke? I'm very confusil. <-- i agreel
21:40:13 <shachaf> oerjan: Maybe the joke's on me for having expectations.
21:41:29 <shachaf> whoa, int-e scrapped
21:44:51 <b_jonas> zzo38: that might still make them count as a Bird, as opposed to some more odd creature type. or if they're of a species of which there exist more in the setting, then it's possible that the species would get its own creature type.
21:45:05 <b_jonas> they're not Specters, right?
21:45:40 <zzo38> That is correct. Perhaps Bird is best.
21:46:35 <b_jonas> are they also Wizard?
21:46:44 <b_jonas> or some other occupation
21:47:40 <zzo38> Ziveruskex is a mathematician and scholar, but Strixan is fighting with a whip and a crossbow. (Still, Ziv knows a few magics, but not so much as real wizards do)
21:49:12 -!- int-e has joined.
21:55:59 <b_jonas> hmm. maybe Wizard or Artificer or Advisor or something in the first case, and Warrior or Archer in the second, unless Rogue or Soldier or Scout or something matches them
21:57:50 <b_jonas> they're not Barbarian either I think
21:59:46 <zzo38> I don't know why they don't have a Scholar subtype, it seem to me maybe even some existing cards should have had, maybe.
22:00:44 * oerjan resolves to skip the rest of the logs other than his pings
22:00:45 <b_jonas> it's a game where you recruit creatures fighting for you. scholars don't directly show off, except as people who direct the experiments to create the simic mutant creatures and such, in which case your creature is the simic mutant
22:02:43 <b_jonas> the few scholars that appear are Wizards and Artificers
22:05:10 <b_jonas> s/show off/show up/
22:10:04 <b_jonas> look at me, I can turn invisible
22:10:08 <b_jonas> oerjan: now you see me,
22:10:09 <b_jonas> now you don't
22:10:54 <oerjan> OKAY
22:24:34 -!- oerjan has quit (Quit: Nite).
22:32:34 -!- budonyc has joined.
22:49:43 -!- tromp has quit (Remote host closed the connection).
22:57:15 <zzo38> Recruit creatures fighting for you is not the only part of the game, though; it is much more than just that.
23:06:58 <myname> what
23:17:28 -!- tromp has joined.
23:22:08 -!- tromp has quit (Ping timeout: 248 seconds).
23:25:59 -!- Phantom_Hoover has quit (Read error: Connection reset by peer).
23:33:06 -!- Gazatron has joined.
23:34:02 -!- lynn_ has changed nick to lynn.
23:34:17 <Gazatron> looking for help getting started with Unreadable
23:35:07 -!- Gazatron has quit (Client Quit).
23:37:25 <zzo38> I suppose I will use Bird Wizard and Bird Archer, perhaps
23:38:02 -!- john_metcalf has quit (Ping timeout: 272 seconds).
←2019-06-07 2019-06-08 2019-06-09→ ↑2019 ↑all