libera/commonlisp - IRC Chatlog

22:53:45 phantomics For all who are interested: I will be hosting a webinar on the April APL compiler (compiles APL into Common Lisp) tomorrow at 16:00 UTC. You can see the webinar at https://zoom.us/j/858532665, the passcode is 391680 It may be early for American viewers; that's 8am on the US west coast

22:54:43 phantomics This webinar is hosted by the British APL Association, so it'll offer a look at April from the perspective of APL users, as opposed to my last presentation which was directed at Lisp users

22:56:24 phoe nice! will there be a recording? (I won't be able to attend)

0:34:29 samps Hi folks. I've been working on some pet projects in Common Lisp. I'm using SBCL and Iḿ having trouble trying to understand a compilation error. Would anyone be able to help me out? https://gist.github.com/lsmag/ebb517a8702f454c4bbf624d7c44b182 ... I tried typing out roughly the same faulty line on the REPL and it seems to work

0:34:50 samps changing the line just to (merge-pathnames (first argument)) also spawns the same error

0:35:16 samps but, say, (merge-pathnames (first '("foo" "bar" "baz"))) on the REPL doesn't

0:35:48 EdLangley[m] Just a note, errors are "signaled" in lisp

0:36:53 samps I've read about it but haven't dipped my toes into condition signalling yet, though I have found quite a few while playing with the adopt library

0:37:06 EdLangley[m] Anyways, that's not an error it's a warning because write-line expects a string and it's getting a pathname

0:37:19 EdLangley[m] clhs write-line

0:37:19 specbot http://www.lispworks.com/reference/HyperSpec/Body/f_wr_stg.htm

0:37:50 EdLangley[m] you should do something like (write-line (namestring target-dir))

0:39:00 EdLangley[m] samps: yeah, I'm just mentioning that because using the expected terminology helps people understand the problem :)

0:39:48 samps damn, I was caught off guard. The signal message actually starts with `IN (WRITE-LINE ...)`. Thanks, folks :)

0:39:59 samps and what would this "in hairy form" be?

0:41:27 EdLangley[m] I'm not sure, my guess is that just means sbcl able to print the form that's triggering the error for some reason

0:41:38 EdLangley[m] that is, sbcl isn't able to print...

0:54:50 molson_ ** NICK molson

1:21:35 White_Flame is it typical for implementations to close I/O streams when garbage collected?

1:22:27 Xach White_Flame: i seem to remember sbcl putting a finalizer on closing the fd on a fd-stream, but I'd have to double-check. I don't know if that would make it "typical" or not.

1:50:21 Bike so thanks to mfiano nerd sniping me, i now know that sbcl actually does maintain backpointers from arrays to arrays displaced to them (sb-kernel:%array-displaced-from). however the general form of the with-array-data macro does still do a loop to get at the simple vector backing

1:50:21 Bike (https://github.com/sbcl/sbcl/blob/master/src/compiler/array-tran.lisp#L1629-L1661). so does sbcl not actually collapse displacements despite going through some effort to maintain the backpointers?

1:51:56 mfiano Bike: I submitted the patch to sbcl-devel

1:52:10 mfiano It is roughly 2x as fast and eliminates consing

1:52:30 mfiano Still not adequate for my use case, but a nice change regardless

1:53:44 EdLangley[m] Is there any way to promise to the compiler that an argument to a function is const?

1:54:28 Bike meaning, a promise that the function will not mutate that value? no.

1:54:55 EdLangley[m] e.g. if I have (defun mapping (fn) (lambda (list) (mapcar fn list))) It'd be nice if I could convince the compiler that it doesn't need a closure

1:55:36 Bike how would it not need a closure?

1:56:44 EdLangley[m] Hmm, maybe I'm wrong

1:57:30 EdLangley[m] What I'm trying to figure out if there's anyway to use functions like this without blocking optimizations of things like (compose (mapping #'1+) (mapping #'1+))

1:58:35 EdLangley[m] If the compiler assumes FN never changes, I'd think you could do some sort of inlining trick to avoid extra indirection.

1:59:27 mfiano You're still looking it up in the global environment at runtime.

2:01:19 EdLangley[m] It should be able to replace (mapping #'1+) with (lambda (list) (mapcar #'1+ list))

2:01:26 EdLangley[m] I guess I could do this with a compiler macro

2:01:40 Bike if it's willing to believe that MAPPING will never be redefined, yeah. you could just proclaim it inline.

2:02:06 EdLangley[m] Hmm, I didn't think of that

2:02:25 Bike but MAPPING as a function itself can't behave as though its argument is unchanging, because it doesn't know what its argument is until it's called.

2:03:51 EdLangley[m] It can't know that the value named by FN isn't mutated, but it can know that FN is never re-bound

2:04:17 Bike it knows that already, since it's what binds FN.

2:05:04 EdLangley[m] So, when compiling the lambda, couldn't it eliminate the outer binding?

2:05:32 EdLangley[m] I guess it has to store the argument value somewhere

2:06:14 Bike right. it's stored in the closure.

2:06:28 mfiano How would it eliminate it if calling thing function is the only way to bind it to a value?

2:06:52 mfiano s/thing/the/

2:07:19 EdLangley[m] I think what I'm really interested in is whether something like (compose (mapping ...) (mapping ...)) can be optimized at all

2:07:31 mfiano Make mapping a macro

2:07:37 Bike yeah, it can be optimized.

2:07:40 EdLangley[m] That changes the utility

2:07:50 Bike if you're using alexandria:compose, a compiler macro on COMPOSE will kick in

2:07:52 mfiano Make it a compiler macro then.

2:08:01 mfiano Oh, automatically, cool.

2:08:41 Bike so (compose (mapping #'1+) (mapping #'1+)) will end up as something like (let ((m1 (mapping #'1+)) (m2 (mapping #'1+))) (lambda (&rest args) (funcall m1 (apply m2 args))))

2:09:04 Bike then after inlining each (mapping #'1+) ends up as (let ((fn #'1+)) (lambda (list) (mapcar fn list)))

2:09:16 Bike the compiler can be smart enough to inline _that_ into the body of the compose lambda

2:09:56 Bike and then maybe it inlines mapcar into a loop

2:10:21 Bike that said, it will probably not be smart enough to avoid consing an intermediate list, due to side effect restrictions

2:10:30 EdLangley[m] cool, I think that answers my question

2:11:01 qhong Soviet Refal is able to eliminate that list automatically in 1970s

2:11:18 EdLangley[m] I've always wondered how much of an optimization barrier passing LAMBDAs around is

2:11:54 EdLangley[m] And it sounds like compilers can, in theory at least, be smart enough to inline them like any other function

2:12:13 qhong if everything is mutable, compiler just commit breinded

2:12:24 qhong but srsly I think this whole thing is totally broken

2:12:36 qhong we have dependence maintenence protocol in MOP

2:12:41 Bike clasp can do it, so i figure a better compiler like sbcl can as well

2:13:19 qhong why not do the same for compiler, assume the best scenario, and update dependent if the assumption is broken

2:13:47 qhong Bike: I don't think it can get around ubiquitous mutability

2:13:59 Bike i meant clasp can do the inlining

2:14:40 Bike for avoiding consing up the intermediate list, i think what the compiler would have to do is observe that the first mapcar's result is only ever used by the second mapcar, so the storage can be reused

2:14:48 qhong When lambda get passed around, most of the case that means they are stored in mutable variables that confuses compiler

2:14:49 Bike I don't think any implementations actually do this, though

2:15:11 Bike i mean, sure, but in this case the variables aren't actually mutable, so it's pretty easy to see how it goes.

2:15:25 qhong Bike: there's systematic western adhoc method called stream fusion, and chad Soviet method called super-compilation

2:15:28 Bike the variables aren't actually mutated* i mean.

2:16:23 Bike this is what, futamura projection stuff?

2:16:34 qhong Bike: yes I think the above cases the only problem is global functions getting redefined

2:16:47 sm2n supercompilation reduces your program to a normal form

2:16:48 qhong Bike: it's much stronger than western school of partial evaluation

2:17:26 sm2n but more or less any nontrivial language does not necessarily reach a normal form in finite time

2:17:31 sm2n does not even have to exist

2:17:46 qhong sm2n: supercompilation doesn't reduce your program to normal form

2:18:19 Bike "I have interpreted the major steps in biological and cultural evolution, including the emergence of the thinking human being, as nothing else but metasystem transitions on a large scale. Even though my Ph.D. was in theoretical physics, I" and i'm out.

2:18:20 sm2n with supercompilation you can get bit-identical compiler output for all programs with the same denotational semantics

2:18:37 sm2n qhong: oh?

2:18:44 sm2n Bike: where is that from?

2:19:09 Bike some paper by the refal guy.

2:19:21 qhong sm2n: are we talking about the same thing? there're two totally different thing supercompilation and superoptimization which has confusing name

2:19:53 pillton Bike: Have you seen work which allows users to perform optimisations of compositions (H X) <=> (G (F X)) without relying on compiler macros / inlining? I was thinking something like (LET ((GRAPH (G (F (LAZILY X))))) (OPTIMIZE-GRAPH GRAPH)) <=> (LAMBDA (X) (H X)).

2:20:53 sm2n qhong: oh, yes I see, I did mix them up I think

2:21:09 Bike seen some of that in the haskellverse, i think, though i don't think i understand your example.

2:25:01 qhong Bike: chad 20th century physicist

2:25:24 qhong Bike: physicist nowadays: I only know how to solve eigen value using matlab

2:30:52 pillton Bike: Assume that the evaluation of (G (F X)) is equivalent to the evaluation of (H X). I could extend both F and G to support being able to "record" their operations in a graph structure when given an "lazy" object. A "lazy" object allows F to inspect the object to obtain its type but does not perform the operation. The function F returns another "lazy" object which allows G to record its operation in the same graph as F and

2:30:52 pillton importantly, preserves the knowledge that it relies on the output of F.

2:32:08 pillton Bike: The function OPTIMIZE-GRAPH takes the full graph and identifies that #'H can be used instead of (compose #'G #'F) and returns the "optimized" graph as a closure.

2:35:20 Bike okay, sure. seems pretty simple phrased like that. your graph is something like <input> -> F -> G -> <output>, your optimizer replaces F -> G with H.

2:37:24 qhong pillton: you want to do it at runtime?

2:40:26 pillton qhong: Yes.

2:41:13 pillton Sorry, I think realistically, the output of OPTIMIZE-GRAPH would be (LAMBDA () (H X)).

2:42:59 pillton ... to handle situations like (defun user-function (X Y) (OP (F X) (G (F Y)))).

3:27:15 yottabyte if I'm reading lines from a file, and I see "^M" in my repl, that means newline, right? how do I check for equality for that? as in, how do I check the line is a newline?

3:27:32 yottabyte (i'm doing (print line))

3:27:41 pillton yottabyte: It means carriage return. #\Return

3:28:33 pillton There is carriage return (#\Return) and new line (#\NewLine).

3:29:07 pillton clhs 13.1.7

3:29:08 specbot Character Names: http://www.lispworks.com/reference/HyperSpec/Body/13_ag.htm

3:29:18 yottabyte thanks

3:30:05 pillton It is used to tell the cursor to go to the beginning of the current line.

3:30:07 yottabyte what will Newline and Linefeed show up as if Return shows up as ^M?

3:30:27 pillton ^N I think.

3:30:45 pillton Normally editors render the new line as a new line.

3:31:13 pillton Carriage return makes little sense in an editor.

3:32:11 pillton Carriage return is important for terminals.

3:33:50 yottabyte gotcha

3:36:43 White_Flame CR = 13 = ^M, LF = 10 = ^J. "Newline" technically is LF, but in practice the output encoder will render it as whatever's default for the platform

3:37:31 White_Flame well, ASCII calls LF Newline as well, afaik. I guess #\Newline is independent of that

3:56:03 remexre are displaced vectors expensive to have as temporaries? wondering why e.g. find has :start, instead of there being a convenient (slice vec 3 nil) or something to make displaced vectors, and the common pattern being to use them

3:58:53 pillton remexre: (slice vec 3 nil) requires consing the displaced array where (find ... :start 3) does not.

3:59:56 remexre shouldn't a really basic escape analysis be able to determine that the one created by (find x (slice vec 3 nil)) has dynamic extent though?

4:00:14 beach Good morning everyone!

4:00:23 remexre good morning

4:00:41 remexre (well, evening here lol)

4:01:03 pillton remexre: You shouldn't return values with dynamic extent.

4:02:15 remexre pillton: this wouldn't be something declared on slice, it'd be something the compiler could recognize after inlining it

4:02:31 beach minion: Please tell remexre about universal greeting time.

4:02:31 minion remexre: look at universal greeting time: It is always morning when a person enters a channel, and late night when they leave. You may want to read http://www.total-knowledge.com/~ilya/mips/ugt.html for further information

4:04:06 remexre beach: hah, sure

4:05:41 pillton remexre: Sure, but it wouldn't catch every case where (find vec :start 3) is trivial to define, doesn't cons, interacts easily with :from-end, and doesn't require a "sufficiently smart" compiler.

4:09:08 remexre I guess, though I think the sufficiently-smart isn't too very smart

4:14:20 Guest43 Does the esrap parser library provide strong error reporting for parse failures?