freenode/#lisp - IRC Chatlog
Search
18:07:00
_death
just to show an example of OUT hackery https://gist.github.com/death/4e273d14e671a3c64f3be10cab2aa1b2
18:17:35
pjb
_death: makomo: it's with the format specifier ~*, which allows you to use the arguments by index, instead of by order, so you can easily use format string in different languages, without changing the program and the order of the arguments. In different languages, the order for formating of various data elements into the language often changes.
18:18:30
_death
instead of comparing to lesser languages, why not compare to a lispy language for solving the localization problem
18:19:44
pjb
(format t (get-localized 'qualified-object-format-string) object color size qualifier) -> "La petite balle bleu" "The small blue ball"
18:22:31
pjb
It is funny, because one of the most advanced localization system, ie. NeXTstep/Openstep/Cocoa's one, isn't even able to do that!
18:25:52
_death
now instead come up with a lispy grammar for describing it.. (:object ball :definite t :adjectives (small blue))
18:30:19
makomo
_death: well, true, it doesn't solve it by itself, but it's much easier for a translator (the actual person doing the translations) to get context about what's being translated
18:32:29
makomo
_death: well, that horror from the article sure doesn't. but consider something like "there are ~a objects in the bag" or something
18:34:24
_death
no, that's the point.. the "use format strings for localization purposes" is just an opportunistic hack.. in lesser languages, it's easy to externalize strings, so they get used and a translator has to work with that
18:35:19
_death
so if you actually want to solve the problem, you find that you need more context and structure
18:44:04
TMA
there is more to localization than simple exchange of strings. -- consider that you need to adjust sizes (an "OK" can be much smaller than "Budiz"); there are other directions for text than ltr-ttb; you might want to adjust colors (because of the connotations) images and icons, ...
18:45:34
russellw
Is there a way to get CCL to exit when a script is finished? wx86cl -Q -b -l test.lisp doesn't do it
18:48:01
Demosthenex
i saw ~?, but was there a way use a variable in the same format string to dynamically change padding?
18:48:46
pjb
_death: of course, you would write(format t (_ "format ~A etc" "The message printed when so and so") …) and (format nil (_ "format ~A etc" "The label of the button to do this and that") …)
18:51:25
Shinmera
"In place of a prefix parameter to a directive, V (or v) can be used. In this case, format takes an argument from args as a parameter to the directive. The argument should be an integer or character. If the arg used by a V parameter is nil, the effect is as if the parameter had been omitted. # can be used in place of a prefix parameter; it represents the number of args remaining to be processed. When used
18:51:27
Shinmera
within a recursive format, in the context of ~? or ~{, the # prefix parameter represents the number of format arguments remaining within the recursive call."
18:52:21
pjb
you can provide or let the translator provide a set of functions to do the exact formating required in strange languages.
18:54:00
_death
pjb: like I said, the format control language is low level and barely extensible via ~/ ~? etc.
18:54:30
pjb
makomo: in CL, we'd write: (loop for i below 3 collect (format nil "There are ~a object~:*~P in the bag." i)) #| --> ("There are 0 objects in the bag." "There are 1 object in the bag." "There are 2 objects in the bag.") |#
18:55:40
_death
pjb: instead you can use the full power of lisp to make things easier to the (since "localization is more than translation" argument was made) localization mechanical turk
18:57:25
Blackbeard
ACTION sent a long message: < https://matrix.org/_matrix/media/v1/download/matrix.org/stZqJlsPlMtsLEZdQxkSDazj >
18:58:18
Blackbeard
is there a way that I can pass just a list '(".jpg" ".png" ".svg") and will apply search to f with every element of the list
19:04:14
pjb
_death: right. :-) (loop for i below 3 collect (format nil "There ~[are~;is~;are~] ~:*~a object~:*~P in the bag." i)) #| --> ("There are 0 objects in the bag." "There is 1 object in the bag." "There are 2 objects in the bag.") |#
19:05:07
_death
pjb: so now you have this "~[are~;is~;are~]" inline.. but it's a useful thing to have named
19:06:03
_death
pjb: and it really shouldn't, since stuffing everything into a string makes things cryptic
19:06:14
pjb
(loop for i below 3 collect (format nil "There ~/english-verb-conjugate/ ~0@*~a object~:*~P in the bag." i "to be"))
19:13:21
TMA
you do not want to rely on format's English support too heavily for localization. ~P works ok-ish for English but not for other languages
19:14:48
_death
it's true that error/etc. are burdened with format.. there's even simple-condition with :format-control and :format-arguments.. I use format here and there and when I don't want to depend on constantia.. but when things get too cryptic, I'll either use OUT or just Lisp with simple primitives
19:19:02
pjb
(loop for i below 3 collect (format nil "You have ~D cop~:*~@P of Emacs ~:(P running~)" i)) #| --> ("You have 0 copies of Emacs P Running" "You have 1 copy of Emacs P Running" "You have 2 copies of Emacs P Running") |#
19:22:56
russellw
I'm about to write a function to return the last element of an array. Obviously this is a very simple function, sufficiently so that it probably already has a common name. The most obvious name is array-last; is that's what it's usually known as?
19:23:57
pjb
russellw: how do you define the last element of #3A((((1 2 3) (4 5 6)) ((1 2 3) (0 0 0))) (((1 2 3) (4 5 6)) ((1 2 3) (0 13 42)))) ?
19:25:26
pjb
russellw: the problem is not that array, it's that you don't know how to define the last element of that array!
19:26:16
pjb
(defun last-element-of-array (a) (row-major-aref a (1- (reduce (function *) (array-dimensions a))))) (last-element-of-array #3A((((1 2 3) (4 5 6)) ((1 2 3) (0 0 0))) (((1 2 3) (4 5 6)) ((1 2 3) (0 13 42))))) #| --> (0 13 42) |#
19:26:40
pjb
russellw: that's beside the point. The point is that you asked for the last element of an array, not the last element of a vector or of a sequence.
19:27:08
pjb
russellw: my point is that if you are able to state clearly your requirements, then the code will generally follow easily.
19:28:00
pjb
russellw: alternatively, you could start speaking in lisp. and ask, How do I (defun last-element (x) (aref x (1- (length x))))? Oops, I answered in the question…
19:28:19
Shinmera
pjb: array-total-size would be a bit shorter and idiomatic than reducing array-dimensions.
19:28:41
pjb
russellw: sometimes, you don't know what english name to give to a function. Just start writting it: (defun foo (…) …) and once it's written you can usually find easily what to call it in english.
19:29:15
pjb
Also, for vectors, you can use length or (array-dimension v 0): you won't get the same result on vectors with fill-pointers.
19:29:29
russellw
pjb, er, if we are going to get snarky about exact wording, take a look at the question I asked, in which I observed that I have no difficulty writing the function; that part is very simple. I merely wanted to know whether it already had a common name. The answer to which was yes, thank you
19:30:30
pjb
russellw: I didn't want to get snarky. In this case, I would have said that obviously, a function to return the last element of an array should be named last-element-of-array.
19:30:56
pjb
Blackbeard: don't mix is- with -p. They're two different conventions for the same thing.
19:31:09
russellw
pjb, ah! Okay, while that's a little verbose for my tastes, it is a perfectly fair answer
19:31:43
pjb
russellw: you can stylistically choose: array-last-element. Or vector-last-element. Or just last-element, notably if that applies to sequences.
19:31:59
pjb
russellw: or you can write it as a generic function and have implementations for all kinds of collections.
19:32:53
russellw
(defun last-elt (s) (elt s (1- (length s)))); one of the things I like about dynamic languages is you get some degree of genericity for free
19:33:22
pjb
Blackbeard: member is nice. I often prefer to use FIND or even POSITION (for the side effect of computing the position if needed).
19:33:51
pjb
Blackbeard: member returns a tail of the searched list, so it may be ugly when printed (but otherwise, perfectly ok for the program).
19:34:35
pjb
Blackbeard: FIND has the advantage of returning the element in the list, as a prototypal form. This can be useful, if you want to normalize them.
19:35:56
pjb
Blackbeard: also, testing for the file type is a bad idea. You could check the meta data (prefixp "image/" (Content-Type file)). Or check the contents. (But this may require more I/O and computation).
19:36:48
pjb
In any cases, be prepared to have non image file names .jpg or something else, and to have png files named .jpg and vice versa.
19:38:34
aeth
russellw: You are probably going to have to inline it to get good performance with it, though. (1) trivial, (2) no reason to redefine it, (3) works on arrays or numbers (here, arrays). So it's a good candidate for inlining.
19:42:52
aeth
_death: Yes, if you wanted it to work on lists instead of 1D arrays (vectors) specifically, the ELT variant is bad. You would probably want an ETYPECASE to split it into two cases, one for lists and one for vectors. The compiler will probably optimize it out if it's inline
19:43:22
russellw
Right, in this case performance is not an issue, but will keep those considerations in mind if it becomes so
19:43:26
aeth
The important thing is that anything that's just a one liner with something like AREF (works on all arrays) or ELT (works on all sequences) or + (works on all numbers) can become a lot more efficient when inline.
19:44:38
_death
aeth: to keep it generic, you can just have (if (listp ...) (car (last ...)) (elt ...)) remember that type sequence is not necessarily type (or list vector)
19:45:52
pjb
That's because in (elt x (1- (length x))), we have to walks of a list. But only 2 O(1) accesses for vectors.
19:48:28
aeth
_death: I'd do it like this: (defun last-elt* (sequence) (etypecase sequence (list (car (last sequence))) (sequence (elt sequence (1- (length sequence))))))
19:49:26
fiddlerwoaroof
Blackbeard: That's a good way to start: assume that everything in the directory is an image and let the user pick one of them then, once you get that working, worry about filtering out non images.
19:50:51
aeth
_death: Numbers also have an efficient inline form that the compiler will generate (probably... obviously stuff like JSCL behave differently) if it has more type information
19:52:17
aeth
_death: e.g. (defun foo () (last-elt* (vector 1 2 3))) is about half the size in disassemble as last-elt* is if you inline last-elt*
19:53:39
aeth
And (defun bar () (last-elt* '(1 2 3))) and (defun baz () (last-elt* #(1 2 3))) are compiled to constantly return 3 in SBCL
19:57:52
fiddlerwoaroof
that would work, you might try this: https://github.com/Shinmera/trivial-mimes
20:35:16
russellw
I want to search a string for the position of the first character that is not a digit. Which function should I be looking at?
21:32:12
phoe
Using usocket, how can I check if a server socket (made using socket-listen) has been closed or not?
21:36:25
phoe
...I assume it no longer has a local port in that case, and errors when I attempt to fetch it.
21:44:32
grobe0ba
thats an easy one. assume all traffic can consist of no more than 1024KB and that the stream is defunct after that much traffic has passed. :P
21:46:42
phoe
A server socket's only role is accepting incoming connections and spawning stream sockets that *have* streams and *can* be used to transmit data.
21:53:13
phoe
I really hate the fact that a socket can close at any moment and because of this, at any moment while handling it, I can get an assortment of very non-portable errors such as sb-bsd-sockets:bad-file-descriptor-error.
21:54:42
_death
I don't understand.. if you have a socket created by socket-listen, it will get closed when you close it.. it is possible that socket-accept will return an error
22:02:04
_death
then you're supposed to define a state machine and handle client shut down as well as errors
22:04:44
_death
well, sockets are similar to threads in that they're usually not a convenient level for an application to do things
22:09:47
_death
usocket defines its own condition types.. and socket-error's description is "Parent error for all socket related errors"
22:22:07
alandipert
is there a way to set the function cell of a symbol locally? ie i have a function that returns a function, and i want to call that returned function in calling code w/out funcall
22:24:51
_death
it doesn't set the symbol's function cell.. if you want that, there's setf (and you can define letf..)
22:29:09
fiddlerwoaroof
alandipert: it took me a while, but I eventually came to appreciate funcall, it eliminates a whole class of errors where a local symbol binding accidentally shadows the function you want to run.
22:29:56
fiddlerwoaroof
One way, though, to avoid using funcall all over the place is to define a bunch of combinators to help build up the function you want and then funcall the resulting lambda
22:30:34
fiddlerwoaroof
(ignore the "lens" part... I started this project with a different plan than what it ended up being :) )
22:32:54
pjb
alandipert: setting the function cell is quite problematic. While you can do that to simulate dynamic binding, for functions it's also global to the image, not local to the current thread. So it can easily break hard.
22:33:21
pjb
alandipert: furthermore, to have good effects, you need to declare that function notinline.
22:46:27
alandipert
i could be braindamaged, https://gist.github.com/alandipert/9d7ff35952f33b3105f90f24a5103e48 is my usecase
22:50:35
_death
alandipert: by the way, you don't need the sentinel.. you can have &optional (item nil item-supplied)
22:52:57
_death
alandipert: without checking the clhs, don't know.. I'm guessing it specifies that it's "true"
22:56:13
specbot
Specifiers for optional parameters: http://www.lispworks.com/reference/HyperSpec/Body/03_dab.htm
23:05:53
pjb
Note that optional parameter will probably be slower than mandatory parameters, so it may be worth it to avoid them in inner (and local) functions.
0:37:25
LdBeth
Doing OOP with literature programming is way more terriable than using a lots of COME FROM
0:49:04
aeth
I fail to really see the difference between come from and goto in most languages. It looks like INTERCAL's come from uses line numbers (a feature of the language?) so "come from 230" will be a complete surprise if you're reading line 230. But most gotos use labels, so come-from in a language like CL would be the same way. So you'd (come-from label) instead of (go label) and you'd basically just trade which line has the label and which has t
0:50:35
aeth
(unless you have a confusing way of permitting multiple come-froms from the same label, but that seems adding to the basic come from)
0:56:08
oni-on-ion
aeth, can i (defun ()) something as well as execute it? like in JS we can do (function n(arg) {})(arg)
0:56:59
mange
oni-on-ion: Does n really escape that? I don't think that defines n in the wider scope.
1:01:36
aeth
oni-on-ion: defun returns the function name, so it would be just like (funcall 'foo 42)
1:02:51
aeth
oni-on-ion: every macro that has to do with iteration (e.g. DO, LOOP) in CL is typically ultimately just a macro over GO contained within the scope of a TAGBODY
1:04:40
no-defun-allowed
if wasm's supposed to compile to SSA, maybe looking at how llvm compilers handle for-loops and the like could help
1:04:58
oni-on-ion
wasm is getting a bunch more stuff i think because its not quite ready for super high level langs
1:05:43
aeth
oni-on-ion: it looks ugly, and it will warn you if you run it more than once (e.g. redefining it)
1:07:43
p_l
no-defun-allowed: interestingly enough, DEC Alpha was fastest processor on market while supporting only 32-bit-extended-to-64, 64bit ints, and few types of floats (of modern importance being only ieee 32 and 64 bit ones)
1:07:54
oni-on-ion
mhm =) not necessarily need the defun trick, but writing prototyping code, it helps to have the options. i almost needed it for how i was testing something out
1:08:54
p_l
the only issue it had was I/O due to lack of byte-sized accesses, which was worked around by intermediate chip... and which in WASM is done by exposing calls to JavaScript (which has a very limited primitive type system as well)
1:10:40
p_l
aeth: and outside of boolean, number and characters can be generalized to float64 and int32, while objects are memory accesses
1:11:19
p_l
no-defun-allowed: today's cpus have a wide variety of different types, even if ultimately they are put in rather limited forms. Legacy of CISC :)
1:14:17
p_l
a variety of ints, packed int vectors, variable-sized arrays, floats, packed float vectors, packed character vectors, encryption primitives, and include instructions which are general-purpose primitives for building things like XML processing engines
1:15:22
aeth
oni-on-ion: Supporting a console would require (1) porting SBCL, (2) replacing everything that touches SDL, (3) replacing everything that touches OpenGL. The Switch has the added challenge of not being x86-64, so it might also require improving SBCL's code generation on AMD64.
1:15:55
p_l
(SPARC is downright pedestrian, being a pretty honest RISC design with addition of supporting custom type systems that use tagged values)
1:17:45
p_l
but keep the base essentially a reiteration of MIPS because that's what the faculty taught ;)
1:19:22
p_l
which is probably why it's the only new design since 1990s to use Cray-style vector unit
1:19:32
aeth
oni-on-ion: Supporting JavaScript and probably even WASM requires writing my own Common Lisp implementation and trying to even get half the speed of what SBCL can get while working on a much higher level target.
1:19:55
aeth
It would also require replacing SDL and OpenGL (but with WebGL instead of a proprietary API). So it would probably actually be harder.
1:20:33
aeth
(Neither ParenScript nor JSCL are complete and the incomplete parts are exactly the parts you'd want for a high-performance CL application.)
1:22:30
oni-on-ion
well yes. parenscript is not meant to be a full blown CL. just a translation to JS being as close to CL as possible under that
1:22:37
aeth
oni-on-ion: But you don't even want a complete, conforming CL implementation. CLISP is one such implementation and it's still entirely unsuitable for the kind of program that my game engine is.
1:23:54
aeth
If you're writing a game, you want type declarations and other optional places where types show up to (1) be respected and (2) actually optimize what you're writing. The only place where SBCL fails here is not respecting :type in defclass at default optimization levels because SBCL primarily uses types for performance, not reliability.
1:25:54
aeth
oni-on-ion: the only things that implementations are required to respect are CHECK-TYPE and (maybe, I'm not sure) TYPEP in an ASSERT... and they don't have to optimize based on that CHECK-TYPE, either.
4:00:27
|3b|
ACTION would guess something like keeping a hash table of locations that need updated after whole thing is READ while READing it, then going back and updating once the actual value is available
4:02:01
White_Flame
if you think about it, the only way to cons up a recursive list is to mutate one of the cells to hook it back
4:05:25
|3b|
https://github.com/robert-strandh/SICL/blob/master/Code/Reader/Simple/macro-functions.lisp#L858 https://github.com/robert-strandh/SICL/blob/master/Code/Reader/Simple/read.lisp#L15 https://github.com/robert-strandh/SICL/blob/master/Code/Reader/Simple/fixup.lisp is the implementation from SICL
4:07:09
LdBeth
thanks, SICL's impl seems make more sense. CCL is restriced to use level-1 constructs.
4:07:18
|3b|
beach: in https://github.com/robert-strandh/SICL/blob/master/Code/Cleavir/Code-utilities/declarations.lisp#L74 does the "we" not include users or implementations?
4:08:54
|3b|
(users who want to introspect the env during macros etc, or cleavir-based implementations trying to use the declarations to modify codegen)
4:12:40
|3b|
beach: also, if i want to have a set of functions that are compiled specially (foreign functions with different calling convention in this case), what's the best way to specify that in cleavir? best i've come up with so far is compiler macro that turns the call into a special form that knows about the extra details
4:12:42
beach
|3b|: I think the idea is that the acceptable declaration can be customized. But Common Lisp also allows declarations that are only valid in some implementations, provided that there is a DECLARATION declaration.
4:13:46
beach
Pretty much every compilation function is a generic function, so it can be customized.
4:15:09
|3b|
possibly i just needed to cut it off higher in class hierarchy and not try to inherit from existing similar classes as much
4:15:56
|3b|
and if not clear, this is selected per function. one calling convention for FFI, and another for 'normal' functions
4:16:20
|3b|
the FFI calls need to do compile-time dispatching on name and argument type/counts, while
4:17:37
beach
The technique is as follows. Your environment must return a different INFO class for that type of function you want. Then you need to define a method on CONVERT-CST that specializes on that class.
4:17:37
|3b|
ideally transparent to user, since the differences are all internal (compile vs runtime dispatch, and hidden arguments)
4:18:06
|3b|
ok, i probably need to upgrade my sicl then, since i think i grabbed it right before you added the CST stuff :)
4:20:01
beach
You need to return a custom INFO object from the environment, and you need to add a method on CONVERT-FORM or CONVERT-CST.
4:20:23
|3b|
i think my custom info was getting converted to a global-function-info somewhere in the middle
4:24:02
|3b|
(and stubs for whatever other methods it complained about when i tried to compile something)
4:28:24
|3b|
possibly i could just have it return a special thing instead of generating a temp and looking up the function, and the code generator for funcall could just look for that thing
4:31:00
|3b|
ACTION wants a CL-like language that generates dalvik bytecode (possibly eventually a full CL, but that is relatively low priority for now)
4:31:49
|3b|
and also learning cleavir to see how well it would apply to my existing compilers with similar goals (cl-like compiler to GLSL, cl-like compiler to spir-v, etc :)
4:34:34
|3b|
but to be minimally useful, it doesn't need to be able to do too much beyond define a subclass of a java API class with a few simple methods, so it could handle events from UI
4:35:55
|3b|
ACTION already wrote a dalvik asm/disasm and some of the file format tools last time i wanted a dalvik compiler, and just mostly finished parsing the API definitions so i should be able to define subclasses and methods, and call methods
4:40:05
beach
I think it would be great to have another client. More problems will be exposed and fixed. More contributions might happen.
4:42:16
|3b|
oni-on-ion: "full" CL as in things like multiple values, conditions, automatic bignums (and ratios + complex types), clos, etc
4:44:02
|3b|
though this one will probably be closer to CL than the glsl/spirv compiler, just due to a more general-purpose target, so might support bignums, multiple values and conditions earlier
4:46:54
|3b|
like my glsl compiler has types defconstant, which doesn't match CL... would have to do separate defconstant + declaim to get a subset
4:47:40
|3b|
aeth: make sure to specify the numeric types properly (or implement full CL numeric tower) :p
4:48:01
|3b|
i guess you could just say a conforming program can't have numeric overflow in your subset
4:49:37
aeth
|3b|: typed defconstant seems pretty easy to resolve: just rename it and make it macroexpand-1 into defconstant + declaim
4:53:25
|3b|
not really something that needs resolved, just an example of how i don't try to make a 100% subset :)
4:54:42
|3b|
and to be a subset, i think that macro would need to be in the user code rather than the implementation code
5:02:01
|3b|
aeth: "any valid program in that language has equivalent semantics and will run directly (with no extralingual pre-processing, and no special compatibility packages) in any conforming implementation of the full language"
5:06:05
|3b|
ACTION supposes i could define it as requiring 'conforming programs' to also be 'conforming CL programs with same semantics', and just anything that uses the stuff that differs is non-conforming :p
5:07:10
|3b|
though 'conforming programs' in that case would be prtty small set, you could do simple math on floats, not sure how much else :p
5:08:19
aeth
I don't think it's useful to write conforming CL on the GPU, anyway. The semantics are too different.
5:09:17
aeth
I would actually intentionally name certain things differently (e.g. a different name for defun) so people don't confuse the two
5:16:28
aeth
oni-on-ion: stuff like that seems like it would be more useful as a CL library on top of a distinct GPU shader language rather than as a feature of a GPU CL
5:16:46
beach
|3b|: I am sorry that I am not extremely helpful right now. Monday mornings are chaotic here under normal circumstances. And now we have house guests as well, so I am even busier than usual.
5:17:07
aeth
oni-on-ion: the latter couldn't be 100% GPU so now you'd have a very unpredictable program where you're always asking: "Is this going to be on the CPU or the GPU?"
5:20:18
|3b|
oni-on-ion: for the specific case of glsl, the execution model is different enough from CL that i wouldn't want much more than i have (something that looks like CL but focused on that specific usage style
5:21:06
|3b|
for general GPGPU, you would probably still at least want a specialized library that generated GPU code rather than trying to translate arbitrary CL code
5:21:30
aeth
oni-on-ion: I mean this. If MAP could be single-threaded, multi-threaded, or on the GPU depending on various characteristics (like the input, which function is being used, whether or not the function is pure, etc.) then I wouldn't know what's going on at all.
5:23:26
|3b|
also moderately expensive to send things to/from GPU, so ideally you'd decide in advance that you were doing a bunch of GPU work with particular data
5:23:29
aeth
(Well, GPU-MAP would be fairly tricky, but I'd rather have it as a library than as part of the language as part of MAP.)
5:24:59
|3b|
so something like "add 10 million floats to these other 10 million floats" is fast on GPU, but if you add "copy these 20 million floats to gpu" and "copy these 20 million floats from gpu", it would have been faster to just add them on cpu
5:30:36
aeth
|3b|: I don't know. Is it possible to extend the type of a function to do things like mark functions as pure? (Or do some other declare of pure.)
5:31:44
aeth
Then a function defined in the same file or defined locally (as a lambda or with flet or with labels) or defined with sb-ext:*derive-function-types* set to T (or equivalents in other implementations if they exist, possibly CMUCL has one) could have at least more guarantees about its behavior
5:32:48
jackdaniel
ecl has "pure" proclamations (it has also "side-effect free" proclamataion, what is slightly else)
5:33:30
aeth
Would be nice to have a portability library here and to fill in the gaps where they exist (at least supporting SBCL, CCL, and ECL)
5:33:32
|3b|
(probably most compilers that want to optimize at all, so you can decide if you can completely skip calls if result isn't used, or rearrange them, or whatever)
5:34:43
jackdaniel
https://gitlab.com/embeddable-common-lisp/ecl/blob/develop/src/cmp/proclamations.lsp ←
5:34:54
aeth
|3b|: hence my qualifications of sb-ext:*derive-function-types* or defined locally to the function or defined in the same file (or compilation-unit) or defined in the locked CL package
5:35:38
aeth
Would be nice if every implementation had something like sb-ext:*derive-function-types* so you could just turn on the super optimizations super type derivations super static checking when you're done developing
5:36:17
|3b|
yeah, that's another reason for not doing full CL for dalvik to start with, easier to get small binaries :)
5:37:15
aeth
(The alternative is to put everything in one file but that breaks people's assumptions with using functions in macros because they don't put eval-when around literally everything)
5:37:47
aeth
(Also it's a bit surprising that C-c C-c could break your program because the compiler assumes C-c C-k)
5:46:56
no-defun-allowed
do you think anyone would complain if i added that to cl-vep's package.lisp?
5:52:11
aeth
no-defun-allowed: It's possible there's a way for you to set it to T, have ASDF compile your files, and then restore it to the original value. I don't know ASDF that well.
5:53:55
aeth
(There are probably some other things that are useful for final builds of a program, in various implementations)
5:56:04
no-defun-allowed
didn't seem to do much, probably since i've annotated functions myself to hell