libera/#commonlisp - IRC Chatlog

0:03:39 antonv Hi. How to ql:quickload a system so that all compiler warnings are printed?

0:03:56 antonv I am trying :verbose t, but warnings are not printed anyway

0:05:08 mfiano By touching the asd file, or modifying a file early in the root module's dependencies

0:05:32 sweatshirt Hello, anyone experienced with hunchentoot for web dev? Needing help with serving an html file per url req

0:05:36 mfiano With :verbose t, or ql:*quickload-verbose* dynamically bound

0:07:22 antonv I did (asdf:clear-system :cl+ssl) and removed all compiled fasls from ~/.cache/common-lisp

0:07:26 antonv still no warnings

0:07:31 antonv just dots are printed

0:09:49 Lord_of_Life_ ** NICK Lord_of_Life

0:14:42 antonv84 sweatshir, especially see create-folder-dispatcher-and-handler

0:17:15 sweatshirt thank you!]

0:31:38 sweatshirt anyone know any good hunchentoot referencs or tutorials haha

0:31:45 sweatshirt would love to see an example

0:32:09 edwlan[m] Its documentation is ok

0:35:08 antonv` which is here: http://edicl.github.io/hunchentoot/

0:35:36 sweatshirt thank you!

0:57:20 sweatshirt ill give it a go tomorrow; too confuseled lol

1:05:30 antonv` I still can't get ql:quickload nor asdf:load-system print warnings

1:06:10 antonv` but I see those warnings in Slime when invoke C-C C-R

1:07:56 antonv` (defun tmp-func ()

1:07:56 antonv` (some-unknown-function 1))

1:07:56 antonv`

1:08:10 antonv` When compiling this, fro example.

1:08:26 antonv` Slime prints a warning and highlight the unknown function invokation

1:08:32 antonv` But nothing in the build output

1:09:31 antonv` I wish to have full warnings and style warnings in by CI buiilds, so that I can spot such errors, or just circular dependencies, when the code invokes a function defined in a file that comes later in the build sequence.

1:14:31 |3b| ACTION gets style warnings from asdf:load-system :verbose t

1:15:05 |3b| and from ql:quickload :verbose t

1:16:09 JonBoone[m] [antonv](https://matrix.to/#/@antonv:libera.chat): are you saying you’re CI won’t print the warnings?

1:16:36 JonBoone[m] * [antonv](antonv): are you saying your CI won’t print the warnings?

1:17:32 JonBoone[m] Are they not sent to standard-output?

1:20:13 Alfr antonv`, are you loading the "correct" system, meaning does (asdf:system-sources-file :foo) show the asd file you'd expect?

1:20:39 Alfr *system-source-file

1:21:01 |3b| seems to go to *error-output*

1:23:07 JonBoone[m] s//`*/, s/?/*`?/

1:26:25 antonv` The example I give above actually prints a warning during build actually.

1:27:24 antonv` But if the some-unknown-function exists, but is defined below the tmp-func, the warning disappears

1:27:24 antonv`

1:27:35 antonv` I thought it should still produce a warning

1:27:36 |3b| if they are in same file, that is expected?

1:27:49 antonv` (defun tmp-func ()

1:27:49 antonv` (some-unknown-function 1))

1:27:49 antonv`

1:27:49 antonv` (defun some-unknown-function (arg) (+ arg 23))

1:27:52 antonv`

1:28:13 mfiano Why would you expect a warning?

1:28:26 mfiano It is not inlined into the caller

1:28:39 antonv` I thought during compilation of the tmp-func the some-unknown-function is absent

1:28:54 mfiano Nope. Without forward references you would be unable to represent a lot of concepts.

1:29:25 antonv` Yes, but I thought CL has this limitation (like in Pascal or C where forward declarations are needed)

1:29:38 mfiano No, this is up to the implementation.

1:29:55 antonv` Up to the implementation, means not guaranteed to work?

1:29:58 mfiano On what a compilation unit is, actually.

1:30:38 antonv` Also, the example above is artificial. I actually was looking at the case when the caller function is in one file and the called function is in enother, later file

1:30:59 antonv` Does ASDF compile everything inside one big with-compilation-unit?

1:31:14 mfiano That would not work without warnings during compilation on some implementations, but no problem at runtime.

1:31:17 antonv` And does with-compilation-unit prevents warnings on forward references?

1:31:49 |3b| ACTION can't find it in the spec, but implementations can defer warnings to end of file (for cases like that where they might be later corrected), and if so, that can be extended to end of compilation unit

1:34:53 Alfr antonv`, are you worried that it may error in some implementation? That's not the case:

1:35:05 Alfr clhs 3.1.2.1.2

1:35:06 specbot Conses as Forms: http://www.lispworks.com/reference/HyperSpec/Body/03_abab.htm

1:35:08 |3b| with-compilation just specifies the bounds of "compilation", it looks like 3.2.5 "Some warnings might be deferred until the end of compilation."

1:35:15 Alfr antonv`, second paragraph.

1:36:16 |3b| and with-compilation-unit mentions the specific example of undefined function warnings

1:36:38 antonv` Alfr: good to know it won't fail

1:37:03 |3b| and asdf does seem to use with-compilation-unit

1:37:04 antonv` I also worry it will prevent some optimizations

1:38:10 |3b| any implementation can call functions that were defined after the caller was compiled though, even if they warned about it at the time

1:38:23 antonv` |3b|: indeed, undefined functions are mentioned

1:38:44 |3b| just can't inline or macroexpand things that haven't been defined

1:40:11 |3b| compiler-macros also must be defined already to take effect, though they can be defined and used before the function with the same name is defined (though compiler can always ignore them completely too)

1:40:37 Alfr antonv`, |3b| if in the same file, implementations actually can, 3.2.2.3: A call within a file to a named function that is defined in the same file refers to that function, unless that function has been declared notinline. The consequences are unspecified if functions are redefined individually at run time or multiply defined in the same file.

1:40:39 edwlan[m] At least for macroexpansion, you should eval-when any functions they call while expanding so they’re visible at the right time

1:41:00 edwlan[m] Or define macros and the functions they call in separate files

1:43:27 |3b| Alfr: true, i meant you shouldn't expect (declaim inline) to work for things appearing before it, but implementations can do some inlining on their own in some cases

1:44:17 Alfr |3b|, understood.

1:45:35 antonv` Alfr: are you sure that quote means possibility of inlining?

1:46:15 |3b| it isn't explicit, but does seem to include it

1:48:29 |3b| a more likely thing to do would be using a special calling convention that calls the function directly without looking it up through the symbol

1:49:32 |3b| or it could optimize for information it knows at a particular call site (like skipping argument checks or keyword processing in the called function), though the called function still needs a "normal" entry point for callers outside that file

1:50:44 antonv` Such optimizations is what I am afraid to miss, when my code has functions defined later than their callers

1:51:23 antonv` Not really "afraid", but I would like to have possibility to see them when building

1:52:56 antonv` As for the 3.2.2.3 quote, it seems to speak about freedom for compiler to ignore redefinitions of a function

1:53:18 antonv` The item right before the Alfr's quote speaks about recursive function

1:53:35 |3b| right, ignoring redefinition is what gives it the freedom to optimize

1:54:05 antonv` if recursive function redefines itself while inside of the recursion, the compiler is free to use the original definition during the wole execution

1:54:17 |3b| normally it must call through the symbol lookup to allow for redefinition, and can't assume anything about the number or types of arguments the caller will accept, or what it will return

1:55:03 |3b| well, people who redefine functions from inside themselves deserve whatever they get anyway :p

1:55:11 antonv` O, good idea about arguments, let me chech arg number mismatch in forward references

1:57:32 |3b| ACTION isn't sure many implementations take much advantage of that option for file optimization by default though, since it is somewhat annoying for developers if you can only recompile whole files at a time during development

1:57:56 |3b| (or if you need to manually C-c C-c every single form in the file instead of loading the whole thing, or declaring everything notinline)

1:58:29 edwlan[m] Weren’t there some relatively recent changes to sbcl to improve block compilation

1:58:34 edwlan[m] Which I think is relevant

1:58:34 |3b| i think cmucl and maybe sbcl (probably others?) have options to do that sort of optimization if specifically requested

1:58:42 |3b| yeah, that

1:59:08 antonv` Yes, indirection is convenient for programmers.

1:59:35 antonv` Argument number mismatch is captured by (ql:quickload :verbose t) on CCL

1:59:39 antonv` (defun tmp-func ()

1:59:39 antonv` (some-unknown-function 1))

1:59:39 antonv`

1:59:39 antonv` (defun some-unknown-function (arg) (+ arg 23))

1:59:44 antonv`

1:59:48 antonv` this works

1:59:51 antonv` (defun tmp-func ()

1:59:54 antonv` (some-unknown-function 1 2))

1:59:58 antonv`

2:00:01 antonv` (defun some-unknown-function (arg) (+ arg 23))

2:00:04 antonv`

2:00:07 antonv` this fails

2:01:05 edwlan[m] https://www.sbcl.org/all-news.html#2.0.2

2:01:13 antonv` "fails" means warning is printed

2:01:23 antonv` Simlarly even for functions in different files

2:01:33 antonv` Thanks to ASDF for taking care of this.

2:10:35 antonv` CCL utilizes the permission to ignore new definition of a recursive function while executing

2:10:39 antonv` (defun test-redef (n)

2:10:39 antonv` (unless (zerop n)

2:10:39 antonv` (format t "old def: ~A~%" n)

2:10:39 antonv` (when (= 3 n)

2:10:43 antonv` (defun test-redef (n)

2:10:46 antonv` (unless (zerop n)

2:10:49 antonv` (format t "new def: ~A~%" n)

2:10:52 antonv` (test-redef (1- n)))))

2:10:54 antonv` (test-redef (1- n))))

2:10:58 antonv`

2:11:04 antonv` (test-redef 5)

2:11:08 antonv` (test-redef 5)

2:11:08 antonv`

2:11:12 antonv` Prints this:

2:11:18 antonv` old def: 5

2:11:21 antonv` old def: 4

2:11:24 antonv` old def: 3

2:11:28 antonv` old def: 2

2:11:31 antonv` old def: 1

2:11:34 antonv` new def: 5

2:11:37 antonv` new def: 4

2:11:40 antonv` new def: 3

2:11:43 antonv` new def: 2

2:11:46 antonv` new def: 1

2:11:49 antonv`

2:13:51 antonv` edwlan[m]: yes, it does seem related

2:14:40 antonv` Not sure it's exacly about function redefinitions, but similar topic 100%

2:14:50 antonv` Unlike CMUCL, SBCL is able to open-code forward-referenced type tests while block compiling. This helps for mutually referential defstructs in particular.

2:16:52 antonv` Block compilation allows calls to global functions defined by defun to be compiled as local calls. The function call can be in a different top-level form than the defun, or even in a different file.

2:16:52 antonv`

2:16:52 antonv` In addition, block compilation allows the declaration of the entry points to the block compiled portion. An entry point is any function that may be called from outside of the block compilation. If a function is not an entry point, then it can be compiled more efficiently, since all calls are known at compile time. In particular, if a function is only called in one place, then it will be let converted. This effectively inline expands the

2:16:52 antonv` function, but without the code duplication that results from defining the function normally and then declaring it inline.

2:16:55 antonv`

2:16:58 antonv`

2:27:08 mfiano antonv`: Please follow proper IRC etiquette.

2:28:25 antonv` mfiano: to large pastes? Sorry

2:28:31 mfiano no pastes on irc

2:29:58 antonv` ok. sorry

3:48:18 contrapunctus edwlan[m]: after _years_ of reading the name "fiddlerwoaroof", I just realized that it means 'fiddler WITHOUT ("w/o") A roof' 🤦‍♀️️

3:49:06 edwlan[m] Yeah, it was a joke I came up with when I was about 18 that’s stuck around

3:49:26 edwlan[m] I played fiddle and didn’t really have a permanent residence at the time

5:52:35 mfiano Does anyone know how Quicklisp registers itself with ASDF? I assume ASDF has some hook that it fires when a system could not be found

5:54:09 mfiano I invoke a simple `#!/usr/bin/env sbcl --script` script (which implies no sysinit or userinit), upon upgrading asdf, reinstalling a fresh source registry without inheritance, rebinding its cache directory, and upon a missing system condition when calling asdf:load-systemit fetches from quicklisp servers still. This is because my attempt at constructing a pristine environment requires me to

5:54:09 mfiano unset SBCL_HOME so that my custom core image with Quicklisp is not used. But if it is, is there a way to un-register Quicklisp from ASDF's missing system hook, wherever that might be?

5:54:51 edwlan[m] If you don’t load setup.lisp, it shouldn’t be registered however it works

5:55:20 mfiano setup.lisp was loaded into the custom core image, before any sysinit or userinit is loaded by SBCL.

5:55:25 mfiano It's baked in the core.

5:56:10 mfiano I am not using it for this application though, and want to use ASDF vanilla, without handling the missing system error automatically somehow

5:56:30 edwlan[m] Misread a recent message

5:57:50 edwlan[m] I don't think there's any hook

5:58:11 edwlan[m] (asdf:load-system :not-downloaded-system) signals an error

5:58:33 edwlan[m] (ql:quickload :not-downloaded-system) works

5:58:47 mfiano Well without using Quicklisp at all, just having it loaded into the image before I upgrade ASDF to the bundled copy in the project next to my script, causes #'asdf:load-system to fetch anything missing in my custom registry from Quicklisp's servers.

5:59:16 edwlan[m] I can't reproduce that

5:59:35 mfiano I can, so long as I don't pass SBCL_HOME='' ./script.lisp

5:59:43 mfiano that fixes it, by using the default core

5:59:50 mfiano (without quicklisp)

6:01:25 mfiano Nowhere in my code am I invoking any quicklisp functionality. Infact, I do #+quicklisp (delete-package :ql) before anything, and it STILL tries to get things from its servers.

6:04:50 edwlan[m] https://plaster.tymoon.eu/view/3754#3754

6:05:36 edwlan[m] One second, that doesn't show what I think it does

6:06:33 mfiano Cannot reproduce with ./script.lisp using #!/usr/bin/env -S sbcl --script

6:08:12 edwlan[m] If I reinstall quicklisp so I don't have any systems downloaded, this doesn't work: sbcl --core with-quicklisp --no-userinit --disable-debugger --eval '(asdf:load-system :data-lens)'

6:09:14 mfiano Define doesn't work. I fear we are talking past each other, becuase that is not how I invoke it.

6:09:41 edwlan[m] All I'm showing is that quicklisp doesn't have a hook

6:10:36 mfiano I wouldn't expect it to. I'm not using it. ASDF must though, or Quicklisp is globally a condition type of ASDF's somehow.

6:11:39 edwlan[m] What is your value of sb-ext:init-hooks

6:11:46 mfiano I invoke ASDF only and I get quicklisp client behavior for missing systems.

6:12:07 edwlan[m] If there was an ASDF hook that command I showed would work

6:12:12 mfiano Let's find out. I only set exit-hooks

6:12:31 edwlan[m] All I did was create an sbcl core with quicklisp and then use sbcl with that core and a system I didn't have downloaded

6:13:16 mfiano NIL

6:14:02 mfiano This is my core image https://github.com/mfiano/lisp-init

6:14:24 edwlan[m] 404

6:14:41 mfiano probably hidden, sec

6:15:09 mfiano there

6:19:25 mfiano This might only be triggered through direct or indirect dependency resolution

6:19:35 mfiano That is the only thing I can think of looking at your example

6:25:19 mfiano I guess also --script as a toplevel option like I'm using adds --noinform and --no-sysinit to your flags.

6:26:06 edwlan[m] But, if quicklisp had this sort of integration with ASDF, it wouldn't matter

6:26:51 mfiano Yeah I've been at this all day. I think I need a break.

6:26:55 mfiano Thanks, night!

6:30:50 mfiano aha

6:31:42 mfiano even after upgrading asdf, clearing the registry and installing my own asdf:*central-registry* is pointing to a list with only quicklisp's path.

6:31:43 mfiano how odd

6:31:48 mfiano Anyway, I need sleep :)

8:51:54 beach` ** NICK beach