phoe changed the topic of #lisp to: Common Lisp, the #1=(programmable . #1#) programming language | <http://cliki.net/> <https://irclog.tymoon.eu/freenode/%23lisp> <https://irclog.whitequark.org/lisp> <http://ccl.clozure.com/irc-logs/lisp/> | SBCL 1.4.16, CMUCL 21b, ECL 16.1.3, CCL 1.11.5, ABCL 1.5.0
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
lavaflow has joined #lisp
rumbler31 has quit [Ping timeout: 244 seconds]
wxie has joined #lisp
<LdBeth> Good morning
Achylles has quit [Ping timeout: 258 seconds]
shifty has joined #lisp
<no-defun-allowed> morning LdBeth
lemoinem has quit [Ping timeout: 258 seconds]
lemoinem has joined #lisp
lemoinem has quit [Quit: Reconnecting]
oni-on-ion has quit [Remote host closed the connection]
oni-on-ion has joined #lisp
techquila has quit [Remote host closed the connection]
lemoinem has joined #lisp
libertyprime has joined #lisp
techquila has joined #lisp
orivej has joined #lisp
cranes has quit [Ping timeout: 245 seconds]
<gaze___> hey, super basic question, but how do I fundamentally identify operations that cons? I understand what a cons cell is, where the name comes from... I'm trying to understand what people mean when they talk about "careless consing"
<gaze___> I'm also interested in what's involved in writing GC-less lisps
<no-defun-allowed> "consing" would be just allocating memory
<gaze___> ah okay
<no-defun-allowed> writing a GC-less lisp involves not writing a lisp because it is trivial to create circularity with closures, conses and other data structures
t58 has quit [Quit: Night]
<no-defun-allowed> or, since the CL standard technically doesn't require a garbage collector, it involves wasting all your memory very quickly
<gaze___> ah well fair enough.
<gaze___> well there is this notion of a linearly typed lisp
<gaze___> right?
<no-defun-allowed> seems like a very sad lisp to me
<no-defun-allowed> this abomination? https://github.com/austral/austral
<aeth> gaze___: You can detect consing pretty easily in SBCL through lots of different ways. e.g. you can disassemble and the consing is commented in SBCL. I think the only exception is when it's done in a function call, but the non-inline function calls are also commented.
<aeth> You can also sb-profile:profile some functions and then sb-profile:report to see if they allocate anything. Unlike the previous method, this will give you consing even for functions that are called by the function being profiled, unless the function that is being called is also being profiled iirc.
<gaze___> there's also things like this, right? https://github.com/carp-lang/Carp
lavaflow has quit [Ping timeout: 268 seconds]
<no-defun-allowed> piss off
<aeth> gaze___: ironically, I think SBCL with carefully used GC will probably provide better real-time performance than that because SBCL is very mature
* no-defun-allowed thinks of a way to put her opinion towards lisps minus the lisp parts politely
<gaze___> ah I'm just goofing off with a cortex-M3 microcontroller
<gaze___> I don't imagine it has enough memory to run sbcl
<no-defun-allowed> how much memory does it have?
<aeth> gaze___: Real-time programming in CL is not about avoiding the GC altogether, it's about controlling when it happens, which means you avoid doing it within the hot loops, but don't avoid allocations altogether. You probably pre-allocate it before the loops begin. Not really good for stuff like microcontrollers, though, because you probably wind up using *more* memory this way.
<gaze___> 20 kbytes of sram
<no-defun-allowed> maybe ulisp <ulisp.com> would work
keep_learning_M has quit [Quit: This computer has gone to sleep]
<gaze___> ulisp is really cool. I'm particularly interested in a tethered compiler where you run a compiler on the host system and shoot code over to the microcontroller as you write functions... but it still maintains enough interactivity that you can peek and poke registers and experiment with drivers
keep_learning_M has joined #lisp
<no-defun-allowed> can't really guess what board is closest, but it suggests pause times of around 1-3ms usually
<oni-on-ion> most langs/runtimes/plats have sexp, its a short hop from that to having custom actual lisp
<no-defun-allowed> dunno how the GC is set up, but it would be useful and interesting to use incremental mark-sweep or some other "real-time" GC
<no-defun-allowed> oni-on-ion: except for dynamic typing, macros, late binding, etc
<oni-on-ion> oh true. also tail calls
<oni-on-ion> but for a little DSL say a protocol or command language, its nice =)
<no-defun-allowed> CL doesn't have tail calls but they're nice to have
<aeth> gaze___: This is how I deal with avoiding garbage collection pauses in my real-time CL application (at least in SBCL), but it won't really apply to very weak platforms... e.g. one of the points is to only use 64-bit implementations because then fewer things are heap-allocated. https://gitlab.com/zombie-raptor/zombie-raptor/blob/41e9e6553a83015d67e14aad5b46f60dcf40b862/CONTRIBUTING.md#consing-heap-allocations
<aeth> I'm surprised that that didn't get cut off.
<oni-on-ion> always forget CL has no tail calls; but i've a feeling its not too tricky with some macro magic
<oni-on-ion> (for hobby-level, not industrial)
<no-defun-allowed> you can use a trampoline system to do tail calls, provided you have some loop that consumes them outside your tail calling functions
<aeth> oni-on-ion: It's "easy"... you just return a thunk and call the thunks in a loop. This is called a trampoline.
<oni-on-ion> aha =) yep makes sense
<aeth> I benchmarked it against SBCL's actual TCO (which isn't enabled on all optimization levels) and it doesn't seem to noticably impact performance. I think it might make multiple return values more complicated, though.
<aeth> But it's definitely more doable for a mini-language than for adding it on top of CL because you'd probably need to do something like run a code walker if you wanted it to work on arbitrary CL
<no-defun-allowed> sorry i got cranky gaze___, people calling things lisps that aren't (and i'm very lenient on that; dynamic typing, late binding, macros and conses are basically all i want) annoys me
<gaze___> no worries! Just excited to see where I can fit lisp in my projects
<oni-on-ion> code walker
<oni-on-ion> neat, Carp is written in HS i did not know that. also reminded of how ugly HS can get! =)
<no-defun-allowed> i would say "maybe this is more relevant for ##lisp" but maybe this is more relevant for #haskell at this rate
<gaze___> I feel like HS can be as readable or as opaque as the author feels like making it... much like lisp
<oni-on-ion> aeth, mini-language do you mean using CL for bootstrapping ?
* no-defun-allowed sighs
<no-defun-allowed> i'll be back in a bit, prolly should have breakfast/lunch and not work myself up
ym555_ has joined #lisp
ym555_ has quit [Client Quit]
ym555 has quit [Ping timeout: 245 seconds]
lavaflow has joined #lisp
lavaflow has quit [Ping timeout: 272 seconds]
oni-on-ion has quit [Remote host closed the connection]
oni-on-ion has joined #lisp
lavaflow has joined #lisp
wxie has quit [Quit: wxie]
wxie has joined #lisp
<LdBeth> Where’s the spec for indenting CL code come from?
lavaflow has quit [Ping timeout: 248 seconds]
linli has joined #lisp
libertyprime has quit [Ping timeout: 245 seconds]
nirved_ has joined #lisp
<LdBeth> Thank you, aeth
<White_Flame> is there a an actual (non-code) spec?
<White_Flame> afaik, the behavior of slime defines the accepted style
nirved has quit [Ping timeout: 252 seconds]
<aeth> White_Flame: afaik, all of the old standards were basically superseded by SLIME and any other programs should be a reliable clone of that file
<aeth> now, of course, that could probably push the question to where SLIME got its exact behavior
<aeth> Someone could also write a spec from that file, which would probably be useful
<White_Flame> it is kind of annoying, though, that the only control over indentation that seems to exist is &body vs &rest
<aeth> Without modifying emacs, yes. You do need to be able to if you e.g. want something that indents like FLET
<White_Flame> for full DSL sublanguages, where the entire structure is handled as a single list, there's no real way to declare houw it should indent
<LdBeth> In LispM Zmacs accepts a special declare form which specifies the indentation
linli has quit [Remote host closed the connection]
libertyprime has joined #lisp
jeosol has quit [Quit: Page closed]
juliusdeane has joined #lisp
<juliusdeane> I have a decent knowledge of functional programming and don't really like clojure. Which flavor of lisp do you think would be most practical for someone like me to learn?
<beach> Good morning everyone!
<beach> Hello juliusdeane.
<beach> juliusdeane: This channel is dedicated to Common Lisp, so we are biased in favor of Common Lisp.
<beach> juliusdeane: The functional programming style is used in Common Lisp mainly in macro expanders. Modern application code written in Common Lisp uses object-oriented programming (using CLOS generic functions) a lot.
eabarbosa has joined #lisp
<juliusdeane> Sounds cool! Would you recommend any specific compiler for CL?
<beach> Depends on your needs. Most people here probably use SBCL. Other popular choices are CCL and ECL.
<juliusdeane> Which has the best emacs integration?
<beach> They can all use SLIME with Emacs.
<oni-on-ion> White_Flame, hmm using lang modes in certain blocks? if slime/emacs were extendable in this way i am not sure. but it works great and automagically in org-mode files which mix different languages source code blocks
<eabarbosa> beach: or SLY with Emacs :D
<beach> Fair enough.
<Josh_2> Mornin
<beach> Hello Josh_2.
rumbler31 has joined #lisp
john2x has joined #lisp
eabarbosa has quit [Remote host closed the connection]
<aeth> juliusdeane: In case you're wondering, ##lisp is the Lisp family channel. Most of the other major Lisps are Scheme, so #scheme might also be relevant, if you want to consider your options. As beach said, this is the Common Lisp channel, so we are biased.
<aeth> (With Scheme the line between dialect and implementation is a bit blurred, unlike with Common Lisp, where almost all code is portable.)
gabbiel has joined #lisp
<aeth> juliusdeane: SBCL is the most popular and CCL is the second most popular. SBCL usually produces the fastest code. On the other hand, CCL's compiler is faster (as in, lower compilation times) and it has some macOS integration. ECL is "Embeddable Common Lisp", designed to be embedded in other applications. e.g. it has libecl.so, which could make interfacing with it easier.
<gabbiel> hey guys. I have a macro "synonymize-function" which basically defines a new function which does the same as an existing function
<aeth> juliusdeane: Most other implementations fill some niche, e.g. ABCL runs on the JVM.
<gabbiel> I can safely do that with fdefinition
<gabbiel> but I also want the new definition to inherit setfability
<beach> gabbiel: There you go again. You need to define "setfability".
<gabbiel> beach: think car, car is setfable too
<gabbiel> I can do (car list), and I can also do (setf (car list) some-value)
<beach> gabbiel: Functions don't have any such ability. When you see something that works with SETF, it is either because it is a separate function named (SETF <symbol>) or because that something has a SETF expander.
<beach> gabbiel: So there is no such intrinsic ability with any functions.
<gabbiel> I tried setfing the fdefinition of (setf new-definition) to the fdefinition of the existing function, but that only works with functions that have "setftability"
<beach> gabbiel: They are 2 different functions, as I said. No function has such an ability.
<gabbiel> beach: I understand, but how else can I communicate when a function also has a setf version
<beach> gabbiel: It has a different name, as I said.
<beach> Two different functions.
<beach> Or it might not. It would be a SETF expander rather than a function.
<beach> The Common Lisp HyperSpec doesn't require an implementation to do one or the other.
<gabbiel> do you understand what I'm trying to do though? I know that's just semantics
<aeth> gabbiel: iirc, setf can have a function or a macro, and the "or a macro" is going to be the hard part.
<gabbiel> yeah I can see that already
<beach> gabbiel: There is no relation between the function FOO and the function (SETF FOO). You need to manipulate the two separately.
<gabbiel> there is a relation
<beach> Fine.
<gabbiel> I mean, it makese sense that car is related to (setf car)
<gabbiel> I understand they do different things, but they are related in a way, right?
<beach> gabbiel: Only by the name CAR.
<aeth> gabbiel: There doesn't have to be a relation, though. You could create one with a separate API from the corresponding regular function (if there even is one), it will just mess with e.g. SLIME's minibuffer which afaik prints the non-SETF version's API
<gabbiel> would you say (setf car) is more related to car than (setf some-random-function)
<beach> gabbiel: Only because they share the symbol CAR in their names.
<gabbiel> that's a relation, and also by the fact they work with the same concept. i.e. the car is a place, and to setf a car, means setting that place
<beach> gabbiel: Sure, but you can't find the function named (SETF CAR), given the function named CAR.
<aeth> gabbiel: well, one's a getter (accessor in CL terms) and one's a setter (writer in CL terms).
<gabbiel> it'd make sense that if we're synonimizing a function to another, we should synonymize their setf functions
<beach> gabbiel: You need to have the symbol CAR. Then you can find both CAR and (SETF CAR), and as I recall, (SETF CAR) may not exist. It could be a SETF expander instead.
<gabbiel> how do I recieve the function (setf car) given car, function doesn't seem to work
<gabbiel> nvm, it seems I quoted it, it works like this (function (setf car))
<beach> gabbiel: You are not listening are you?
<beach> gabbiel: There is no relation between the function FOO and the function (SETF FOO). You need to manipulate the two separately.
<gabbiel> I am.
<beach> gabbiel: You need to have the symbol CAR. Then you can find both CAR and (SETF CAR), and as I recall, (SETF CAR) may not exist. It could be a SETF expander instead.
<beach> "In general, the exact macro expansion of a setf form is not guaranteed and can even be implementation-dependent; all that is guaranteed is that the expansion is an update form that works for that particular implementation, that the left-to-right evaluation of subforms is preserved, and that the ultimate result of evaluating setf is the value or values being stored. "
<aeth> one thing you might be able to do is (get-setf-expansion `(car x)) as long as you're able to get the function's lambda list and as long as that lambda list matches the setter's (it doesn't have to!)
<gabbiel> so synonimizing setf functions too shouldn't be done?
<aeth> I see from that that SBCL uses SB-KERNEL:%RPLACA
<gabbiel> at least no in the same code for synonimyze-function?
<aeth> gabbiel: if you want the setter to match, you should probably have it as a separate argument imo... e.g. (#'car #'(setf car))
<aeth> Have the user do the work. Worse is better.
<gabbiel> what about the setf expander thing, that seems more complicated, I guess I'll do that separate argument thing
<gabbiel> the limited functionality kills me, Ideally, i'd want to be able to handle the expanders as well
john2x has quit [Ping timeout: 248 seconds]
rdh has quit [Remote host closed the connection]
eabarbosa has joined #lisp
eabarbosa has quit [Remote host closed the connection]
eabarbosa has joined #lisp
dieggsy has quit [Quit: ZNC 1.7.3 - https://znc.in]
Arcaelyx has quit [Ping timeout: 252 seconds]
dieggsy has joined #lisp
wxie1 has joined #lisp
rumbler31 has quit [Remote host closed the connection]
wxie has quit [Ping timeout: 250 seconds]
wxie1 is now known as wxie
rumbler31 has joined #lisp
varjag has joined #lisp
juliusdeane has quit [Remote host closed the connection]
<LdBeth> gabbiel: you can just let the setf expander to call (setf OLDSYMBL)
<gabbiel> I was thinking that too, now all I need is to know how to determine if its a normal setf function, or an expander, of it has none of them
rumbler31 has quit [Ping timeout: 268 seconds]
<LdBeth> Yes, a common case is that symbol is not setfable at all
<LdBeth> But the thing this what you’d like to do with that macro?
varjag has quit [Ping timeout: 246 seconds]
<gabbiel> I'd like to define a new function called new-name, which does what old name does, inhertis documentation, args, and the setf function/expander.
<gabbiel> Thanks to fdefinition, I have everything covered, except the setf function/expander
<gabbiel> I really want it to be a synonym, or as identical as possible
<LdBeth> gabbiel: so is there any practical use?
keep_learning_M has quit [Quit: This computer has gone to sleep]
<gabbiel> yes, for example, I have some code for keeping tracks of some recipes
<LdBeth> What one probably would do is refactoring
<LdBeth> With some textual utility’s instead
moldybits has quit [Quit: WeeChat 2.4]
<gabbiel> a recipe is a list, whose name is the car, now I'd like to calle recipe-name instead of car for readability purposes. and what if I want to change the name of a recipe? I'd rather also call (setf (recipe-name recipe) new-name) than (setf (car recipe) new-name)
<gabbiel> ldeth: what do you mean refactoring with textual utility? care to expand?
<gabbiel> *ldbeth:
<LdBeth> gabbiel: then you shouldn’t relay on the global namespace but use something like a hash table
<gabbiel> but aren't functions global in the package, i.e. once defun'd, they are reachable
<LdBeth> gabbiel: I mean what people usually do is replace the occurrence of recipe-name to new name in the source code
<LdBeth> And then reload the source code into a new lisp process
<gabbiel> I was thinking of using struct, since I know you can represent them as lists, I'm not sure one can setf the same, but regardless, this macro seems useful to me
<gabbiel> ldbeth: recipe-name is the new name, car is the one I'm trying to synonymize it to
<LdBeth> It’s the same: replace all occurrences of (car recipe) to new name
<LdBeth> Which is the process called refactoring
<gabbiel> that seems a hack, and what if I have (setf (car recipe)), not it wouldn't work because recipe-name has no "setfability"
<gabbiel> that's why im trying to get it to inherit everything from car, instead of defining it and its setf function and then doing the textual replacement
moldybits has joined #lisp
<LdBeth> If use defstruct, the field accessor is defined with setf as well
<gabbiel> I fogot defstructs can be represented as lists, and I stuck with lists because they can easily be printed to a file and retrieved later
<LdBeth> And defstruct will handle the corner cases well
<gabbiel> I don't think structs are serializable
<gabbiel> what corner cases
<no-defun-allowed> #s(arbitrary-structure :in-order-to-teach gabbiel)
<LdBeth> gabbiel: yes they can
<gabbiel> if I remember correctly, stuff that has a # means they aren't able to be read back
<gabbiel> yes I could print them, but not retrieve them later
<LdBeth> gabbiel: usually an accessor could implement checks to see if the argument supplied is a “well formed list”, ie not longer or shorter
<LdBeth> gabbiel: that’s #<
<LdBeth> Otherwise #' would fail
<no-defun-allowed> gabbiel: these can't be printed obviously: #c(1.0 1.0) #(1 2 3) #2a((1 2) (3 4)) #'foobar #p"/bin/sh"
<no-defun-allowed> oh wait i did print them
<gabbiel> I know they are printable, I just said they aren't readable
<White_Flame> and CL can READ them, too!
<gabbiel> (make-hash-table) => #<HASH-TABLE :TEST EQL :COUNT 0 {1002283AC3}>
<White_Flame> "#<" is the magic incantation there, not "#" on its own
<gabbiel> but now I understand only if #<
<White_Flame> and PRINT-UNREADABLE-OBJECT can make that output for you, including the address
<gabbiel> pretty cool that structs are serializable, I thought they werent cause of that #, but now I know
<gabbiel> still though, if I were to use structs in list form, (which defines getters and setters) it'd only do so for the first level of the list/tree. I have stuff like recipe-notes which is defined as the third of the second element in the tree, or the caddadr
<gabbiel> I still want the synonymize-macro and synonymize-function macros, I'll have to study up on get-setf-expansion, defsetf, and friends to know what to do
<gabbiel> thanks for the input though, i appreciate you guys
donotturnoff has joined #lisp
elderK has quit [Quit: Connection closed for inactivity]
igemnace has quit [Quit: WeeChat 2.4]
_leb has quit []
eabarbosa has quit [Remote host closed the connection]
makomo has joined #lisp
Mandus has quit [Ping timeout: 246 seconds]
<makomo> gabbiel: maybe you could use GET-SETF-EXPANSION to do what you want, i.e. discover whether your place is defined using a SETF expander or a SETF function
nanoz has joined #lisp
<makomo> you would first check whether the function (SETF <symbol>) exists. if it does, you're done. otherwise, a SETF expander for it might exist, so you use GET-SETF-EXPANSION to retrieve the expansion of the place
Mandus has joined #lisp
<makomo> if that expansion *didn't* expand into a call to the function (SETF <symbol>), then a valid SETF expander was provided
<makomo> (GET-SETF-EXPANSION will return an expansion that calls (SETF <sym>) if no SETF expander exists for the place, even if (SETF <sym>) itself doesn't exist)
<makomo> gabbiel: also, regarding your synonimization, i think the name you're looking for is "aliasing"
<makomo> gabbiel: check out DEFALIAS in Serapeum
<makomo> gabbiel: btw, how to actually check that GET-SETF-EXPANSION didn't return an expansion that calls (SETF <sym>)? i'm not sure
<makomo> i fear the expansion might be implementation-dependent
<makomo> but also, as people already pointed out, just because a place is of the form (<sym> ...) doesn't mean it has any relation to the function <sym>. it might take totally different parameters or a different number of them as well
<makomo> (this would be a problem when trying to call GET-SETF-EXPANSION, because you need to give it a place of the form (<sym> ...))
<makomo> (since there's no bulletproof way of discovering a function's lambda list)
ravenousmoose has joined #lisp
ggole has joined #lisp
refpga has joined #lisp
<gabbiel> hold on let me read all that
<gabbiel> I see that problem of (setf symbol) not being at all related to symbol
<gabbiel> but wouldn't that be a really small number of cases
<gabbiel> generally, if (symbol object) is a place, and we want to change it, we use (setf (symbol object) value)
manualcrank has quit [Quit: WeeChat 1.9.1]
<gabbiel> but to cover those cases, I'd do like someone said, to have an optional parameter detailing the setf function, idk what do do in case its a setf expansion though
manualcrank has joined #lisp
<gabbiel> gnite
rippa has joined #lisp
ravenousmoose has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
shangul has quit [Remote host closed the connection]
kajo has quit [Ping timeout: 258 seconds]
iovec has joined #lisp
random-nick has joined #lisp
manualcrank has quit [Quit: WeeChat 1.9.1]
kajo has joined #lisp
varjag has joined #lisp
dale has quit [Quit: dale]
FreeBirdLjj has joined #lisp
<phoe> Morniiiing
ravenousmoose has joined #lisp
<beach> Hello phoe.
john2x has joined #lisp
<no-defun-allowed> Hey phoe
dkmueller has joined #lisp
<saturn2> gabbiel: there's a very simple way to do what you want, which is simply (defmacro recipie-name (x) `(car ,x))
<saturn2> this will work with setf no matter how your implementation implements it
<saturn2> on the other hand, it's probably better style to use a structure or clos object unless you're doing something rather unusual
donotturnoff has quit [Ping timeout: 258 seconds]
<pjb> (defstruct (recipie (:type list)) name) (recipie-name (make-recipie :name "Tarte aux pommes")) #| --> "Tarte aux pommes" |#
<pjb> (make-recipie :name "Tarte aux pommes") #| --> ("Tarte aux pommes") |#
<pjb> (defstruct (recipie (:type list) :named) name) (make-recipie :name "Tarte aux pommes") #| --> (recipie "Tarte aux pommes") |# (recipie-name (make-recipie :name "Tarte aux pommes")) #| --> "Tarte aux pommes" |#
v88m has quit [Ping timeout: 244 seconds]
v88m has joined #lisp
igemnace has joined #lisp
john2x has quit [Remote host closed the connection]
john2x has joined #lisp
<aeth> saturn2: In practice, when I structure data in lists, it's not because there's not a better option, it's because it's in a macro (or, more rarely, function) to *build* the more appropriate data structures.
<aeth> gabbiel: So if that's the case, then use destructuring-bind. Very useful for parsing lists.
<aeth> (And the setter thing isn't an issue, since you'd be setting up a different data structure other than the input one)
<aeth> I basically never use CAR/CDR/CADR/CDAR/CAADR/... anymore.
gjvc has joined #lisp
dddddd has quit [Read error: Connection reset by peer]
hr0m has joined #lisp
ebzzry has quit [Read error: Connection reset by peer]
beach has quit [Disconnected by services]
beach has joined #lisp
nowhere_man has quit [Ping timeout: 258 seconds]
orivej has quit [Ping timeout: 272 seconds]
Lord_of_Life has quit [Ping timeout: 245 seconds]
Lord_of_Life has joined #lisp
baskethammer has joined #lisp
SaganMan has joined #lisp
_whitelogger has joined #lisp
void_pointer has joined #lisp
john2x has quit [Ping timeout: 250 seconds]
pfdietz has joined #lisp
wigust- has joined #lisp
wigust has quit [Ping timeout: 258 seconds]
<pfdietz> An issue I have with destructuring-bind ... indeed, with all builtins -- is that error signaling is too unspecific. I'm not sure how to make this better, though. Wrapping handlers around everything is too awkward.
<phoe> pfdietz: I hacked d-b once, https://github.com/phoe/destructuring-bind-star
karayan has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
cosimone has joined #lisp
Achylles has joined #lisp
FreeBirdLjj has quit [Ping timeout: 272 seconds]
<ggole> For destructuring that might fail, pattern matching is probably a nicer approach
_whitelogger has joined #lisp
random-nick has quit [Read error: Connection reset by peer]
<makomo> something werid going on with https://gitlab.common-lisp.net?
<makomo> i'm getting random 500 errors
lavaflow has joined #lisp
<pfdietz> Hmm, I Just did too.
lavaflow has quit [Ping timeout: 268 seconds]
varjag has quit [Read error: Connection reset by peer]
cosimone has quit [Quit: WeeChat 2.3]
<phoe> pfdietz: makomo: let ehuelsmann at #common-lisp.net know.
ravenousmoose has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
karayan has quit [Ping timeout: 256 seconds]
random-nick has joined #lisp
shangul has joined #lisp
<makomo> phoe: oh, didn't know there was a dedicated channel, cool
cosimone has joined #lisp
kajo2 has joined #lisp
kajo has quit [Ping timeout: 248 seconds]
nanoz has quit [Ping timeout: 245 seconds]
refpga has quit [Ping timeout: 248 seconds]
karayan has joined #lisp
shangul has quit [Remote host closed the connection]
Lycurgus has joined #lisp
libre-man has quit [Ping timeout: 245 seconds]
libre-man has joined #lisp
shangul has joined #lisp
v88m has quit [Remote host closed the connection]
v88m has joined #lisp
donotturnoff has joined #lisp
wxie has quit [Quit: wxie]
SaganMan has quit [Quit: WeeChat 1.6]
nowhere_man has joined #lisp
Arcaelyx has joined #lisp
xkapastel has joined #lisp
nowhere_man has quit [Ping timeout: 257 seconds]
dkmueller has quit [Quit: WeeChat 1.6]
jmercouris has joined #lisp
_whitelogger has joined #lisp
aindilis has quit [Read error: Connection reset by peer]
vms14 has joined #lisp
aindilis has joined #lisp
nanoz has joined #lisp
jmercouris has quit [Ping timeout: 248 seconds]
aindilis has quit [Read error: Connection reset by peer]
ravenousmoose has joined #lisp
aindilis has joined #lisp
karlosz has joined #lisp
hhdave has joined #lisp
t58 has joined #lisp
karayan has quit [Ping timeout: 256 seconds]
ravenousmoose has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
ravenousmoose has joined #lisp
igemnace has quit [Quit: WeeChat 2.4]
varjag has joined #lisp
hhdave has quit [Quit: hhdave]
cosimone has quit [Quit: WeeChat 2.3]
rumbler31 has joined #lisp