jackdaniel changed the topic of #lisp to: Common Lisp, the #1=(programmable . #1#) programming language | <https://irclog.tymoon.eu/freenode/%23lisp> <https://irclog.whitequark.org/lisp> <http://ccl.clozure.com/irc-logs/lisp/> | offtopic --> #lispcafe
caltelt has joined #lisp
gal_ has quit [Ping timeout: 240 seconds]
gal has joined #lisp
Oladon has quit [Quit: Leaving.]
orivej has quit [Ping timeout: 260 seconds]
Oladon has joined #lisp
nicktick has joined #lisp
smazga has quit [Ping timeout: 240 seconds]
holycow has joined #lisp
smazga has joined #lisp
wxie has joined #lisp
smazga has quit [Ping timeout: 246 seconds]
mathrick has quit [Ping timeout: 240 seconds]
mathrick has joined #lisp
nicktick has quit [Read error: Connection reset by peer]
holycow has quit [Quit: Lost terminal]
orivej has joined #lisp
ralt has quit [Quit: Connection closed for inactivity]
gko_ has joined #lisp
nicktick has joined #lisp
mangoicedtea has quit [Remote host closed the connection]
ahungry has joined #lisp
orivej has quit [Ping timeout: 256 seconds]
<johnjay> Why in let statements are the assignments parallel but in setq sequential?
Oladon has quit [Quit: Leaving.]
smazga has joined #lisp
<aeth> johnjay: you want psetq/psetf... and yes, maybe consistently speaking, setq/setf should have been parallel like let and then setq*/setf* could have behaved sequentially like let*, but CL isn't consistent
<aeth> you generally want to be sequential when you setf, though.
EvW has quit [Ping timeout: 244 seconds]
<johnjay> idk. if i put each assignment on a new line then it just looks like a let
<johnjay> this is why we can't have nice things.... XD
* johnjay abandons let completely to only use lambdas
<aeth> CL is like a cathedral that was built over a century. Many minds were involved in its creation. Don't expect parts of it to be consistent, since it would rather be compatible with past Lisps.
smazga has quit [Ping timeout: 265 seconds]
<aeth> SETF is inconsistent with LET in another way. It removes two layers of parentheses over LET. Of course, one is understandable because there's no need for a body at the end.
sjl has quit [Ping timeout: 260 seconds]
<aeth> My guess is that the original SETQ only let you set two things so you'd have to do (setq foo 42) (setq bar 43) and you could only later do (setq foo 42 bar 43) and that's why you have to use newlines instead of parentheses to easily tell what's setting what, i.e. not (setq (foo 42) (bar 43))
<aeth> Either that or the designers just assumed that the SETQ with just one setting was far more common and worth "optimizing" the syntax for
<aeth> Perhaps the design decisions are documented somewhere, though
Oladon has joined #lisp
sjl has joined #lisp
smazga has joined #lisp
wxie has quit [Ping timeout: 256 seconds]
wxie has joined #lisp
patlv has joined #lisp
smazga has quit [Ping timeout: 256 seconds]
ahungry has quit [Ping timeout: 246 seconds]
smazga has joined #lisp
mindCrime has quit [Ping timeout: 244 seconds]
ahungry has joined #lisp
patlv has quit [Ping timeout: 260 seconds]
smazga has quit [Ping timeout: 265 seconds]
lucasb has quit [Quit: Connection closed for inactivity]
mindCrime has joined #lisp
eli` has joined #lisp
peterhil has quit [Ping timeout: 256 seconds]
peterhil has joined #lisp
<johnjay> perhaps
eli` is now known as kkjsdkjkdj
kkjsdkjkdj has left #lisp ["*sigh*"]
libertyprime has joined #lisp
mindCrime has quit [Ping timeout: 260 seconds]
jesse1010 has quit [Ping timeout: 260 seconds]
shifty has quit [Ping timeout: 265 seconds]
shangul has joined #lisp
smazga has joined #lisp
Alfr_ has joined #lisp
Bourne has joined #lisp
byFate` has joined #lisp
Alfr has quit [Ping timeout: 244 seconds]
morisama has quit [Quit: WeeChat 2.3]
smazga has quit [Ping timeout: 240 seconds]
mrcom has quit [Ping timeout: 265 seconds]
gal_ has joined #lisp
gal has quit [Read error: Connection reset by peer]
jibanes has quit [Ping timeout: 260 seconds]
jibanes has joined #lisp
mrcom has joined #lisp
smazga has joined #lisp
stepnem has quit [Ping timeout: 256 seconds]
smazga has quit [Ping timeout: 260 seconds]
space_otter has joined #lisp
rumbler31 has joined #lisp
hipete has quit [Ping timeout: 240 seconds]
torbo has quit [Remote host closed the connection]
<beach> Good morning everyone!
libertyprime has quit [Ping timeout: 264 seconds]
Bike has quit [Quit: leaving]
wxie has quit [Ping timeout: 260 seconds]
libertyprime has joined #lisp
libertyprime has quit [Ping timeout: 246 seconds]
libertyprime has joined #lisp
stepnem has joined #lisp
byFate` has quit [Quit: If you want to know more about the truth just visit my blog https://exodux222.wordpress.com/]
smazga has joined #lisp
smazga has quit [Ping timeout: 260 seconds]
smazga has joined #lisp
caltelt has quit [Ping timeout: 260 seconds]
Lord_of_Life_ has joined #lisp
smazga has quit [Ping timeout: 256 seconds]
Lord_of_Life has quit [Ping timeout: 265 seconds]
Lord_of_Life_ is now known as Lord_of_Life
smazga has joined #lisp
Bourne has quit [Ping timeout: 246 seconds]
Oladon has quit [Quit: Leaving.]
orivej has joined #lisp
smazga has quit [Ping timeout: 256 seconds]
orivej has quit [Ping timeout: 256 seconds]
orivej has joined #lisp
orivej_ has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
gravicappa has joined #lisp
shifty has joined #lisp
smazga has joined #lisp
gaqwas has joined #lisp
smazga has quit [Ping timeout: 265 seconds]
Oladon has joined #lisp
Oladon has quit [Client Quit]
smazga has joined #lisp
gko_ has quit [Read error: Connection reset by peer]
gko_ has joined #lisp
gxt has quit [Ping timeout: 240 seconds]
smazga has quit [Ping timeout: 256 seconds]
White_Flame has quit [Ping timeout: 256 seconds]
libertyprime has quit [Ping timeout: 240 seconds]
johnjay has quit [Ping timeout: 265 seconds]
krid` has quit [Ping timeout: 256 seconds]
White_Flame has joined #lisp
gxt has joined #lisp
bocaneri has joined #lisp
stux|RC-- has joined #lisp
stux|RC has quit [Ping timeout: 256 seconds]
libertyprime has joined #lisp
Balooga has quit [Ping timeout: 246 seconds]
johnjay has joined #lisp
jlpeters has quit [Ping timeout: 246 seconds]
jlpeters has joined #lisp
Balooga has joined #lisp
avicenna has quit [Ping timeout: 246 seconds]
smazga has joined #lisp
avicenna has joined #lisp
smazga has quit [Ping timeout: 256 seconds]
gxt has quit [Remote host closed the connection]
mangul has joined #lisp
orivej_ has quit [Ping timeout: 246 seconds]
gxt has joined #lisp
shangul has quit [Ping timeout: 265 seconds]
<loke> I did a blog post:
toorevitimirp has joined #lisp
mangul is now known as shangul
v3ga_ has quit [Quit: WeeChat 2.7.1]
v3ga has joined #lisp
smazga has joined #lisp
<beach> loke: Great, except that you don't "declare" the function. You "define" it.
bsd4me has quit [Quit: Leaving]
<loke> Good catch. I will fix
Mawile has joined #lisp
Archenoth has quit [Ping timeout: 256 seconds]
mangul has joined #lisp
<phoe> aeth: (foo 42) looks like a function call
<phoe> foo 42 doesn't
<phoe> ((foo 42)) looks much more like a binding
<aeth> quite a few things in macros look like a function call.
shangul has quit [Ping timeout: 246 seconds]
<phoe> yep, maybe I'm just so unused to the idea
<aeth> but, yes, SETF would make it worse with things like (setf ((aref foo 1) 42))
<aeth> so we're fortunate that the older SETQ wasn't like that
<aeth> (or maybe SETF would have different syntax, which would be worse, since I like how SETF's setter tends to parallel the accessor... where looking like a function call is usually a good thing)
<aeth> e.g. maybe we would have wound up with (setf (aref foo 1 42)) or with some other position for 42.
<markasoftware> how can I unbind a symbol's function slot?
<phoe> fmakunbound
<markasoftware> awesome, thanks
<phoe> <3
gko_ has quit [Ping timeout: 260 seconds]
<markasoftware> Did you ever figure out how to define a method for all instances of classes that have a certain metaclass? I would honestly like to know the best way to do this
smazga has quit [Ping timeout: 240 seconds]
<phoe> DEFMETHOD SHARED-INITIALIZE :AFTER over ADD-METHOD
shka_ has joined #lisp
Cymew has joined #lisp
<loke> markasoftware: Typically, what you do is to is to implement a method ININITIALIZE-INSTANCE with an :AROUND method for the given metaclass. It then changes the :DIRECT-SUPERCLASSES argument so as to add a new superclass for the class.
<loke> That way you can ensure that all instalced of a class with a given metaclass also inherits from a given class, and you can use that one to select for it in your method definitions.
ahungry has quit [Remote host closed the connection]
<markasoftware> I like loke's answer a bit more :)
lonjil has quit [Ping timeout: 256 seconds]
<loke> I implemented a metaclass to support automatic persisting of instances to couchdb. Here's the code that does adds PERSISTED-ENTRY as a superclass to ever class that uses PERSISTED-ENTRY-CLASS as metaclass:
chipolux has quit [Ping timeout: 260 seconds]
<phoe> ooooh, you take this sorta approach
lonjil has joined #lisp
<loke> phoe: I do. Don't you? :-) I found it really useful.
chipolux has joined #lisp
toorevitimirp has quit [Ping timeout: 260 seconds]
<phoe> my approach is slightly different because I'm tackling a different problem - I'm working on classes which have value semantics and I want to define methods on a #'EQV generic function that is Yet Another Take At Equality™
<phoe> two standard-objects are EQV iff they are instances of the same class (1) and then they are EQV slot-wise (2)
<loke> phoe: Oh I see.
<phoe> (1) is solved by me adding methods which specialize on (MY-CLASS MY-CLASS)
<loke> That sounds a bit fragile to me :-)
<phoe> and the method then calls a slotwise-eqv sort of thing
<phoe> which solves (2)
<loke> Yeah, I can see how it makes sense.
<phoe> and I'm open to criticism since this approach is still young young.
<phoe> in particular, I've seen stylewarning's ADT implementation and I guess I'm too used to classes and their inheritance and such to make a jump to full ADT like that.
<stylewarning> ADTs are most valuable when you want a “sealed discriminated union”; if you don’t want that then they’re not the right choice
<loke> What's an adt?
<beach> Abstract Data Type?
<stylewarning> algebraic data type, the funny ways Standard MLers or Haskellers introduce new data types
<loke> How are they different from regular data types?
mjl has quit [Ping timeout: 260 seconds]
l1x has quit [Ping timeout: 244 seconds]
<stylewarning> they’re different in the “mathematical properties” they guarantee. In terms of implementation they’re essentially equivalent to an abstract base class and a static set of sealed subclasses
mgsk has quit [Ping timeout: 244 seconds]
ffwacom has quit [Ping timeout: 260 seconds]
<stylewarning> it turns out that pattern shows up a lot in programming. If your compiler knows about this “static set” then it can warn you when you fail to consider all cases in this set when your functions consider the base class as their input type(s)
mgsk has joined #lisp
mgsk has quit [Max SendQ exceeded]
scymtym has quit [Ping timeout: 265 seconds]
farooqkz__ has joined #lisp
<phoe> I don't want to seal the set of subclasses
boeg has quit [Ping timeout: 260 seconds]
<phoe> That's because I don't yet know what I'm doing™ and I don't know what I will be doing in the future™
<phoe> and because I explicitly want extensibility in an otherwise functional program
<stylewarning> yeah it’s non-Common Lispy where everyone wants infinitely extensible runtime changeable everything
<phoe> which is why I try to make immutable objects that can be value-compared and whose identity is unimportant but where inheritance and specializing is still in effect
<phoe> and this combination seems to be a good fit for my purpose
mangul has quit [Ping timeout: 264 seconds]
<stylewarning> but when you do sort of know what you’re doing and you have 10,000 lines of code, and you add another subclass, it’s really nice to be warned where you’ve failed to consider this subclass at compile-time
<phoe> I guess I'll want to ossify my code/data like that once the project leaves the "let's make this run" phase and enters the "let's make this correct" phase
<stylewarning> yeah this also has to do with dev style. I frequently ,restart my image
<phoe> me too
farooqkz__ has quit [Quit: Leaving]
<stylewarning> it’s nice to not have to but I do it a lot anyway so as to not totally depend on invisible state I’ve built up, and that plays nice with sealed mumbo jumbo
<markasoftware> stylewarning: so you enforce that methods are defined for all subclasses of a certain class?
shangul has joined #lisp
<stylewarning> markasoftware: I don’t use methods, I just use functions and pattern matching
<stylewarning> (You can define methods on the subclasses if you want but it’s not enforced. It’s preferable to just use functions)
<markasoftware> what kinds of patterns?
l1x has joined #lisp
<markasoftware> is it basically Rust's case statement on enums?
boeg has joined #lisp
<markasoftware> i.e, are rust enums an example of an abstract data type?
ffwacom has joined #lisp
<stylewarning> Algebraic data type, yes
<stylewarning> Rust got inspiration from old ML’s
<markasoftware> awesome
<phoe> stylewarning: the invisible state I'm building up in this scheme is just the state of methods
<phoe> since all data is already immutable
<stylewarning> phoe: your approach sounds good and Lispy and simple
<phoe> and since methods are the thing that I'm working on the most now, I like the tradeoff for the time being
<phoe> later, when I've implemented everything™ and created the test suite for everything I've written, I'll try to refactor the code until I get bore^W^W^WI like the result
mgsk has joined #lisp
<stylewarning> CL-ADT was really me wanting Coalton without doing all the work of Coalton. Now I’ve decided to (slowly) do all the work of Coalton so I can have my Lisp cake and eat it functionally too.
<phoe> you can't functionally eat a cake, you can just create a new, eaten copy of the cake, and a new, full version of yourself
iamFIREc1 has joined #lisp
<phoe> but then you run into the issue of cloning yourself
<stylewarning> (:
<phoe> eating a cake is a fundamentally imperative operation with side effects.
<phoe> have you taken this into account while working on Coalton?
* phoe coughs, runs off to work on things
<stylewarning> ;)
iamFIREcracker has quit [Ping timeout: 240 seconds]
scymtym has joined #lisp
mjl has joined #lisp
smazga has joined #lisp
<phoe> stylewarning: I'
vutral has joined #lisp
<phoe> I'll publish my approach once it's kinda-polished-enough
<phoe> along with some README-quality rationale for why I'm reinventing ADTs again
<phoe> and then ask for some general critique
smazga has quit [Ping timeout: 264 seconds]
hendursa1 has joined #lisp
hendursaga has quit [Ping timeout: 240 seconds]
karlosz has quit [Quit: karlosz]
gko_ has joined #lisp
space_otter has quit [Remote host closed the connection]
ldb has joined #lisp
<ldb> good eve
<beach> Hello ldb.
<phoe> good mor
ljavorsk has joined #lisp
jlpeters has joined #lisp
Balooga has joined #lisp
jlpeters has quit [Changing host]
Balooga has quit [Changing host]
avicenna has quit [Changing host]
avicenna has joined #lisp
l1x has joined #lisp
boeg has joined #lisp
ffwacom has joined #lisp
mgsk has joined #lisp
mjl has joined #lisp
l1x has quit [Changing host]
boeg has quit [Changing host]
ffwacom has quit [Changing host]
mgsk has quit [Changing host]
mjl has quit [Changing host]
ldb has quit [Changing host]
ldb has joined #lisp
jello_pudding has quit [Ping timeout: 244 seconds]
<ldb> recently i find that EQ is a very efficient device that usually lacked in later functional programming languages such as SML
<beach> That's because identity is not important in functional programming.
pve has joined #lisp
<phoe> ^
<ldb> yes, but in the case of manipulating long nested expressions, being able to do a EQ before recursively decedents into deeper structures is a huge performance gain
<loke> ldb: Remember that pure function languages assue the existence of a "sufficiently smart compiler".
<ldb> once that was called lisp myth :D
<phoe> one Lisp myth is that Lisp is functional
wxie has joined #lisp
<ldb> i prefer the wording "applicative"
gko_ has quit [Remote host closed the connection]
gko_ has joined #lisp
technobean has joined #lisp
ldb has quit [Quit: Connection closed]
jello_pudding has joined #lisp
ralt has joined #lisp
jello_pudding has quit [Ping timeout: 240 seconds]
jello_pudding has joined #lisp
gravicappa has quit [Ping timeout: 256 seconds]
gko_ has quit [Ping timeout: 264 seconds]
jesse1010 has joined #lisp
smazga has joined #lisp
yitzi has quit [Quit: yitzi]
theBlackDragon has quit [Ping timeout: 256 seconds]
yitzi has joined #lisp
wxie has quit [Ping timeout: 260 seconds]
nicktick has quit [Ping timeout: 240 seconds]
theBlackDragon has joined #lisp
adam4567 has quit [Remote host closed the connection]
jello_pudding has quit [Ping timeout: 260 seconds]
smazga has quit [Ping timeout: 260 seconds]
frgo has joined #lisp
frgo_ has quit [Ping timeout: 240 seconds]
rogersm has joined #lisp
patlv has joined #lisp
wxie has joined #lisp
jello_pudding has joined #lisp
random-nick has joined #lisp
<edgar-rft> phoe: everybody should know that Lisp is misfunctional!
<Robdgreat> I find it more endearing to just think of it as dysfunctional
<beach> Wow, new word. What is the difference between it and dysfunctional?
* edgar-rft bought a smartphone in the hope that it has a sufficiently smart compiler
<jackdaniel> my guess would be: misfunctional - not suitable for functional programming; dysfunctional - not possible to use
<edgar-rft> beach: it means that Lisp causes mental illness
<Robdgreat> edgar-rft: I assumed it was the other way around
<edgar-rft> it might be a chicken-and-egg problem
<beach> edgar-rft: Ah, yes. Nice.
<edgar-rft> let's all be proud on our mental defects :-)
vutral has quit [Quit: Connection closed for inactivity]
smazga has joined #lisp
wxie has quit [Ping timeout: 264 seconds]
yitzi has quit [Quit: yitzi]
smazga has quit [Ping timeout: 260 seconds]
heisig has joined #lisp
orivej has joined #lisp
shangul has quit [Ping timeout: 256 seconds]
bitmapper has quit [Ping timeout: 264 seconds]
ralt has quit [Quit: Connection closed for inactivity]
stux|RC-- has quit [Quit: Aloha!]
stux|RC has joined #lisp
<jackdaniel> C&P: crazy and proud, a new lisp dialect by edgar-rft :)
ggole has joined #lisp
<edgar-rft> jackdaniel: I have an offical document that says I'm uncurable
<jackdaniel> C&P: crazy and proud, a new /certified/ lisp dialect by edgar-rft ^_^
patlv_ has joined #lisp
* jackdaniel stops the chatter, sorry
<edgar-rft> S&U - schizoid and uncurable
<edgar-rft> the doctors have given up :-)
smazga has joined #lisp
<edgar-rft> the "uncurable" is only important for the retirement insurance
patlv has quit [Ping timeout: 260 seconds]
smazga has quit [Ping timeout: 240 seconds]
wxie has joined #lisp
jw4 has quit [Read error: Connection reset by peer]
jw4 has joined #lisp
ralt has joined #lisp
zulu-inuoe has joined #lisp
cosimone has joined #lisp
yitzi has joined #lisp
_whitelogger has joined #lisp
hendursa1 has quit [Quit: hendursa1]
hendursaga has joined #lisp
zxcvz has joined #lisp
pfr has quit [Ping timeout: 240 seconds]
schweers has joined #lisp
mangul has joined #lisp
shangul has quit [Disconnected by services]
mangul is now known as shangul
krid` has joined #lisp
pfr has joined #lisp
shifty has quit [Ping timeout: 264 seconds]
wxie has quit [Ping timeout: 246 seconds]
xantoz has quit [Read error: Connection reset by peer]
xantoz has joined #lisp
Bike has joined #lisp
smazga has joined #lisp
<jmercouris> I'm trying to use loop like this (loop for i in list1 for y in list2 collect (or i y))
<jmercouris> I want to have list1 = abc def and list2 = ghi jkl
<jmercouris> then I want the output of the loop to be abc ghi def jkl
<pve> collect i collect y
<jmercouris> ah, damnit
<jmercouris> I knew I was so close
<jmercouris> thank you
smazga has quit [Ping timeout: 265 seconds]
<mfiano> (mapcar #'list '("abc" "def") '("ghi" "jkl"))
<jmercouris> that could work too, and it is probably faster
<phoe> ahh, mapcar #'list, also known as the zip function
<mfiano> or matrix transpose
Robdgreat has quit [Quit: scheduled maintenance]
<phoe> I have fond memories with that one - when I saw it for the first time and actually understood why it works, something clicked for me
<jmercouris> well supposedely it is faster according to SBCL
Lord_Nightmare has quit [Ping timeout: 246 seconds]
patlv__ has joined #lisp
Bourne has joined #lisp
patlv_ has quit [Ping timeout: 260 seconds]
Lord_of_Life has quit [Read error: Connection reset by peer]
Lord_of_Life has joined #lisp
patlv__ has quit [Ping timeout: 244 seconds]
__jrjsmrtn__ has joined #lisp
wsinatra has joined #lisp
_jrjsmrtn has quit [Ping timeout: 260 seconds]
wxie has joined #lisp
Bourne has quit [Ping timeout: 256 seconds]
wxie has quit [Ping timeout: 240 seconds]
gko_ has joined #lisp
bsd4me has joined #lisp
payphone has quit [Ping timeout: 256 seconds]
payphone has joined #lisp
<schweers> Does the output of DECODE-UNIVERSAL-TIME depend on the current timezone, and, more importantly, on whether or not dst is currently active? I’m concerned about the case where the optional TIME-ZONE argument is not given.
<beach> clhs decode-universal-time
<beach> "If time-zone is not supplied, it defaults to the current time zone..."
<schweers> It says that the current time zone is used, but not how dst is handled, at least I can’t find any further information on this. Or is dst simply part of the time zone?
<beach> It says "adjusted for daylight savings time"
<schweers> I know, I had already read that part and I’m not sure what to make of the implications of dst.
<beach> I suppose it is relative to UTC.
<beach> UTC does not change with DST.
<beach> You may look at the glossary entry for "time zone".
<schweers> The last part in parens seems to imply that if dst is not treated separatly, it’s part of the timezone
<beach> Yeah.
<schweers> damn.
FreeBirdLjj has joined #lisp
cosimone has quit [Quit: Quit.]
FreeBirdLjj has quit [Ping timeout: 260 seconds]
msk has quit [Remote host closed the connection]
msk has joined #lisp
<schweers> Although I’m obviously not satisfied with the answer, I’d like to thank you, for once again being very helpful, beach.
gravicappa has joined #lisp
<schweers> Or rather: not satified with the situation.
<schweers> Your answer was fine
<beach> Heh, sure.
<jmercouris> I have a bit of a problem, my lists are of different length, so using mapcar to zip them does not work
<jmercouris> I also don't know in advance HOW many lists there will be, and I can't think of how to form a loop construct to do it
<phoe> it does work, just likely not in the way you expect :D
<jmercouris> well, yes
<phoe> what empty value are you thinking of?
<jmercouris> I want it to keep appending the rest of the elements
<phoe> if the input lists are '(1 2 3) and '(a), what should the output be?
<jmercouris> (alexandria:flatten (mapcar #'list '("abc" "def") '("ghi" "jkl" "qrt"))) -> ("abc" "ghi" "def" "jkl" "qrt")
<jmercouris> that is what I would expect
<jmercouris> or rather, desire
EvW1 has joined #lisp
cosimone has joined #lisp
<jmercouris> to answer your question, the output would be 1 a 2 3
<phoe> hmmmm
<jmercouris> to make it more precise, here is EXACTLY the data I am starting with
<jmercouris> (("Sea Turtle" "Turtle" "Box Turtle") ("Carp"))
<jmercouris> and I would like to end with
Oddity_ has joined #lisp
<jmercouris> Sea Turtle Carp Turtle Box Turtle
cosimone has quit [Client Quit]
Lord_Nightmare has joined #lisp
ralt has quit [Quit: Connection closed for inactivity]
<schweers> Loop over all lists, always take the car and rebind/replace the list in question with the rest of the list. If the list is nil, don’t append anything. Am I missing something?
<phoe> (defun intertwine (x y) (let ((result '())) (loop (when x (push (pop x) result)) (when y (push (pop y) result)) (when (not (or x y)) (return (nreverse result))))))
<jmercouris> phoe: that only accepts two lists
<jmercouris> and if you do three lists by applying it twice, the order will be wrong
<jmercouris> or am I wrong..?
<phoe> ooooh, I see
Oddity has quit [Ping timeout: 260 seconds]
Robdgreat has joined #lisp
<jmercouris> schweers: no, but easier said than done
<phoe> (defun intertwine (&rest lists) (let ((result '())) (loop (loop for list on lists do (when (car list) (push (pop (car list)) result)) (when (every #'null lists) (return-from intertwine (nreverse result)))))))
<phoe> seems to work better
<phoe> could be further optimized to avoid EVERY
<_death> phoe: you need to copy the &rest list
<_death> (let ((heads (copy-list lists))) ...)
<phoe> oh right! I am mutating it
yur3i__ has joined #lisp
<phoe> (defun intertwine (&rest lists) (let ((heads (copy-list lists)) (result '())) (loop (loop for list on heads do (when (car list) (push (pop (car list)) result)) (when (every #'null heads) (return-from intertwine (nreverse result)))))))
smazga has joined #lisp
<jmercouris> time to try to understand this now...
<yur3i__> Yo I started reading 'Lisp in Small Pieces' the other day but ran into a couple of functions I can't find any reference to in the scheme spec, `invoke` and `eprogn`, anyone know what they're for?
<jmercouris> why is there a parent loop?
<jmercouris> it has no forms in it
<jmercouris> I mean no keywords
leo_song has quit [Ping timeout: 256 seconds]
<phoe> yur3i__: #scheme might help you better
<phoe> you have wandered into a Common Lisp channel :D
<jmercouris> the inner loop does make sense to me though
<yur3i__> phoe: lol
<yur3i__> Cheers
<phoe> jmercouris: the outer one is a forever loop
<jmercouris> I see
<phoe> we only escape it when the lists are all empty via the explicit RETURN-FROM
<jmercouris> OH I SEE
<jmercouris> you are using car to avoid traversing INTO th eloop and just removing the first
<phoe> yes, that's LOOP ON
<phoe> this allows me to pop elements from the individual lists
yur3i__ has left #lisp [#lisp]
<jmercouris> why (when (car list)) instead of (when list) ?
<_death> because it's actually cons-holding-the-list\'s-head instead of list
<jmercouris> but a list is a list of cons
<jmercouris> I don't get what you are saying
smazga has quit [Ping timeout: 256 seconds]
<phoe> jmercouris: because I am doing LOOP ON, not LOOP IN
leo_song has joined #lisp
<jmercouris> Ah
kssytsrk has joined #lisp
cosimone has joined #lisp
<jmercouris> Ah, Ok, I somehow missed that even though you said it twice
<phoe> this causes the variable to be bound to successive conses
<phoe> which makes it possible for me to mutate that cons.
<jmercouris> right, because otherwise, mutating the list during loop traversal would be disastrous
<jmercouris> thank you very much phoe
<beach> phoe: You can't mutate with ON.
<beach> phoe: You have to use for x = ... then (cdr x)
<phoe> beach: but I just did
<phoe> I mean, is mutating the CAR with LOOP ON forbidden?
<jmercouris> not according to my compiler
<beach> Good question.
<phoe> clhs 3.6
<specbot> Traversal Rules and Side Effects: http://www.lispworks.com/reference/HyperSpec/Body/03_f.htm
<phoe> "For list traversal operations, the cdr chain of the list is not allowed to be destructively modified."
<beach> jmercouris: The compiler is not the standard.
<phoe> so mutating the CAR is safe
<jmercouris> I was making a joke :-D
<beach> Right, I thought you were mutating the CDR. Sorry.
<phoe> oh, I'm not - that would be a very bad thing to do
<beach> It is good to know, though, that you can do that with for .. then.
<phoe> hey, that is also nice
<phoe> much more elegant than mine
<jackdaniel> remove nil, or even delete nil shoudl be also fine I suppose
<jackdaniel> s/shoudl/should/
<kssytsrk> hey everyone, i'm trying to replace all occurences of substring in a string with newline. i tried using cl-ppcre:replace-all but it won't give me a newline no matter what i try ("\n" "\\n" "\\\n" "#\Newline" '(#\Newline) etc). could anyone point me in the right direction?
<_death> I wouldn't use a &rest list for this function btw
<jmercouris> yeah, I ended up having to (apply #'intertwine ....)
<jmercouris> that was the signature phoe gave though, and I assumed he had his reasons
<jackdaniel> _death: why not?
<jmercouris> I would have (defun intertwine (2d-list) ..)
<jmercouris> kssytsrk: are you tied to kssytsrk ?
<jmercouris> kssytsrk: are you tied to cl-ppcre?
<jmercouris> you could do it with cl-str pretty easily
<_death> jackdaniel: it just looks like a function for processing a list of lists.. so let it take a list of lists
<jackdaniel> thanks for elaborating
<phoe> kssytsrk: (string #\Newline)
<phoe> this gives you a string containing a single newline character
<kssytsrk> jmercouris: i've tried to quickload cl-str, but it gives me an error with cl-ppcre-unicode
<kssytsrk> phoe: oh thanks, ill try that now
<jmercouris> strange
<jmercouris> phoe's answer is correct
<phoe> Lisp doesn't interpret "\n" as a newline character on its own; you might want to look into CL-INTERPOL for that sort of functionality
<phoe> AFAIK it offers the #"\n" notation that figures out the C-style \n newline
Robdgreat has quit [Ping timeout: 256 seconds]
<schweers> Doesn’t cl-ppcre use single-line mode by default?
<_death> jackdaniel: e.g., you'd need to use apply if you don't have a fixed number of lists (as jmercouris likely found out)
<kssytsrk> phoe: hm, that gave me a space.
<jmercouris> I did find out, which is why I said I had to use apply :-D
<phoe> works on my machine
<_death> jmercouris: well it could also be useful if you have a fixed but large number of lists.. Common Lisp may provide FIRST, SECOND, ... TENTH but it doesn't provide ELEVENTH ;)
<beach> Aww! But this one goes to eleven!
<jmercouris> (defun eleventh (li) (nth 11 li))
smazga has joined #lisp
<_death> of course that can be remedied using intern and "~:R" ;)
<_death> jmercouris: off by one
<jmercouris> (defun eleventh (li) (nth 12 li))
<jackdaniel> I'm not sure i fit is a bad joke or a bad mistake
<jackdaniel> s/i fit/if it/
<jmercouris> which one do you think?
<_death> (defun eleventh (list &optional (base 20)) (nth (+ base 10) list))
<phoe> (defmacro defnth (n) (let ((var (gensym "LIST"))) `(defun ,(intern (substitute #\- #\Space (format nil "~:@(~:R~)" n))) (,var) (nth ,n ,var))))
<phoe> (defnth 1234) (one-thousand-two-hundred-thirty-fourth (loop for i below 2000 collect i))
<jmercouris> lol
<jmercouris> that's great
<phoe> fixing off-by one errors left as an exercise to the reader
<phoe> macro dedicated to the folk who have debated the chicken-and-egg problem of Lisp and mental illness just a few whiles ago
smazga has quit [Ping timeout: 240 seconds]
<kssytsrk> phoe: oh wait, thanks, that works for me now too. had an unrelated problem
<_death> that's one of CL improvements over Lisp Machine Lisp.. that latter only defined accessors upto SEVENTH
FreeBirdLjj has joined #lisp
<_death> though it did have REST1/REST2/REST3/REST3 ;)
<phoe> mop structure-class
<specbot> Couldn't find anything for structure-class.
<phoe> clhs structure-class
<edgar-rft> exercise: use INTERN, string concatenation, and LOOP to define list accessors up to MOST-POSITIVE-BIGNUMTH
mseddon has joined #lisp
<_death> just run it in a background thread
<_death> may want to add a SLEEP.. every now and then hot-upgrade your system to have more RAM
<mseddon> Any Lisp historians in? I'm curious where the package system came from, and how it looked in it's early implementations. MacLisp clearly did not have them, so I figure they were added in Lisp Machine Lisp, but I wonder if they came in from the start, or were added later.
shifty has joined #lisp
<_death> there was an OBLIST
<mseddon> and then there was an OBHASH
<mseddon> yes.
<mseddon> But when did we start seeing FOO:BAR etc?
<mseddon> (or at least, similar namespacing)
<_death> LML is the earliest I know
smazga has joined #lisp
<_death> edgar-rft: another exercise would be to have an undefined-function handler-bind that recognizes such accessor names and defines them as needed, then restarts the operation
<scymtym> i had the same idea: (handler-bind ((undefined-function (lambda (condition) (let* ((name (cell-error-name condition)) (ds (count #\D (symbol-name name)))) (setf (fdefinition name) (lambda (list) (nthcdr ds list))) (continue))))) (cddddddddddddddddddr (alexandria:iota 20)))
<_death> it could also work for caadadadaaadadadar
smazga has quit [Ping timeout: 256 seconds]
smazga has joined #lisp
<_death> scymtym: this reminds me of my autoquickload thingy https://github.com/death/slime/commit/19569ef771641a0afcb10ec4a44ba7f242ccde91
<mseddon> jackdaniel: :D that is silly
<jackdaniel> on more serious note, I think that the implementation which defines the most-positive-bignum would be still conforming if it signals a storage-condition if a result of the operation would be bigger
<scymtym> _death: that's funny
<jackdaniel> afaik most implementations try their best and cons until the memory ends, but still you could say i.e "the biggest bignum consumes 1MB"
<mseddon> jackdaniel: yeah, it makes sense. An implementation may want to keep everything contiguous in heap for performance reasons, rather than doing silly contortions for very rarely used edge cases.
<mseddon> Although heaps are huge now. so. it'd better be a lot bigger than that.
<jackdaniel> if it is /big/ enough arguably it would be better to set an upper cap at the bignum size, because then the program would be more predictable (instead of running out of heap at random times), although I can imagine not many people would agree with that
patlv__ has joined #lisp
<mseddon> jackdaniel: I don't see why a bignum would be special, vs a list, for e.g.
patlv__ has quit [Client Quit]
<jackdaniel> sure, you have a point here
<mseddon> but I would hope a bignum is nicely cache-coherent within a reasonable range.
<mseddon> rather than just a horrible cons of fixnums :)
<jackdaniel> however arrays i.e have maximal dimensions
<jackdaniel> since they are a single object, while conses (unlike bignums), are linked independent objects
nicktick has joined #lisp
<mseddon> not wrong.
yitzi has quit [Quit: yitzi]
<edgar-rft> hmm, why are there no lists of negative length? And if yes, would they *give* memory instead of consing?
<phoe> edgar-rft: these are dangerous thoughts
<mseddon> :)
<phoe> (make-list -10) ;; the 10 most recently allocated conses are freed, good luck
<mseddon> that's too easy. Make it the 10 least recently allocated. More fun debugging.
<mseddon> it may mean you crash later, so it's a Sensible Engineering Trade-off (tm).
<jackdaniel> s/while conses/while lists/
nullheroes has joined #lisp
<phoe> well technically
<phoe> NIL is not a linked object, even though it is independent
<_death> (defun cons (a b) (glue (halfcons a) (halfcons b)))
schweers has quit [Ping timeout: 260 seconds]
<jackdaniel> Smurtfs are not blue, because they have white teeth
<jackdaniel> smurfs*
<phoe> I stand corrected
<mseddon> anyway. "There is no limit to the magnitude of an integer" and bignum == (and integer (not fixnum)). so most-positive-bignum indicates a botch.
<mseddon> but that's an old article, maybe it didn't say that in 1984
<edgar-rft> That's because Lisp has only CONS but no PROS
<jackdaniel> physically there is always a limit, so having most-positive-bignum would be only admitting that (+ adding some deterministic behavior)
<jackdaniel> but it doesn't matter anyway, I've just brought it up as a curiosity :)
<mseddon> back in the 90's I'm pretty sure you could detonate allocating a most-positive-fixnum vector and nobody would have raised an eyebrow.
<_death> most-lucrative-fixnum seems to contain a bank account number
<mseddon> :D
<edgar-rft> even if there were such a thing the value of the MOST-POSITIVE-FIXNUM variable alone would eat up all your memory
<edgar-rft> sorry, MOST-POSITIVE-BIGNUM of course
<mseddon> btw am I right in thinking the only real serious CL web browser attempt is JSCL at the moment?
<jackdaniel> if we decide, that i.e the most-positive-bignum takes 32MB, then it will just eat some memory (today), also it could be consed only on demand (i.e when someone actually reads its value)
<mseddon> yes but now your language looks stupid in 10 years when we all want bigger bignums :)
jackdaniel has quit [Remote host closed the connection]
<edgar-rft> another idea would be to allocate all your memory with rubbish, then you can easily define MOST-POSITIVE-BIGNUM as zero because there's no memory left
jackdaniel has joined #lisp
<jackdaniel> re browser implementations, there is also jacl
<jackdaniel> developed by alandipert
<mseddon> jackdaniel: ah, excellent, thanks! I shall check that out.
<jackdaniel> also, few years ago, author of SCL (scieener common lisp) was active on wasm mailing lists advocating for lisp-friendly features
<mseddon> I'm in that situation where I want one, I don't have one, and am working out if I sink ages into making my own or grab a shovel.
<mseddon> yeah, wasm is crap atm. We can't do concurrent GC because SharedArrayBuffer was disabled, due to SPECTRE attacks. :|
<jackdaniel> ecl works with nacl and pnacl (however both are afair deprecated)
<_death> SLip looked pretty cool
<mseddon> yeah that's a no-go. it has to go everywhere or it's broken.
<mseddon> yeah, mishoo did a real good job on that. really slick work.
<jackdaniel> there is also a path of porting ecl to emscripten compiler
gal_ has quit [Ping timeout: 272 seconds]
<mseddon> jackdaniel: again, until we have a roadmap for sensible gc, it's going to be worse than just transpiling to js
<_death> funny, I also wrote a logo thingy recently (but with many turtles, a la netlogo, which is awesome.. so much lisp influence)
bitmapper has joined #lisp
mujjingun has joined #lisp
<jackdaniel> it seems that a slightly modified libgc works on wasm, but I don't know details
<beach> mseddon: What makes you think we don't have a roadmap for a sensible GC?
<jackdaniel> he said that the problem is some limitation of wasm, not on the lisp side
<beach> Ah, OK. Sorry.
* beach is switching contexts too often today.
<jackdaniel> mseddon: sure, I've just wanteed to be through about available options
<jackdaniel> which doesn't imply implementing cl from scratch ;)
jackdaniel has quit [Remote host closed the connection]
kssytsrk has quit [Quit: ERC (IRC client for Emacs 27.1)]
jackdaniel has joined #lisp
<mseddon> ah yes, but it's single threaded. so you can't scavenge concurrently. So you either have to pause or just slow down entirely doing incremental gc
* jackdaniel doesn't have a problem with non-concurrent GCs
<mseddon> I mainly want CL because clojurescript is a performance nightmare for realtime graphics. so.. yeah.
Robdgreat has joined #lisp
<mseddon> I'm niche. and hardware is still too slow to smooth that out.
<mseddon> and also meh. cljs
<jackdaniel> it would certainly help to design your programs with having the gc in mind then -- i.e preallocate things you'll need and not cons at runtime. that's quite a hassle though
<mseddon> well, clojurescript kind of hates you doing that.
<mseddon> you don't even need to have some kind of weird region optimization like symbolics machines in a modern browser, so it seems rather silly I pay attention to trivia like that.
<mseddon> I mean I can make clojurescript scream, it's just now the code is completely non-idiomatic and ugly as sin. And also, due to the purity, 100% incompatible with the rest of the standard library.
<jackdaniel> if you are interested in graphic microoptimizations for weird scenarios, take a look at this http://turtleware.eu/posts/Charming-CLIM-tutorial-part-2--Rethinking-The-Output.html
<mseddon> jackdaniel: Thanks! That looks like a really interesting series, and right up my street :D
<jackdaniel> I think that the third post will be simply a manual which describes the final architecture
<jackdaniel> clambering approach like this one is interesting, but very tedious and slow
<mseddon> :D and the nature of lisp- very bottom up. Hard to actually predict where you end up.
<jackdaniel> (and tutorials how to use the library)
gal has joined #lisp
<mseddon> jackdaniel: another reason why I'm skeptical about implementing CL in wasm currently: https://stackoverflow.com/questions/44263019/how-would-setjmp-longjmp-be-implemented-in-webassembly
<mseddon> In time, it will be doable, and at THAT point, it's utterly important that that is the way it is done. But the platform hasn't completely come online yet, and it may take another decade or so for that.
<mseddon> right now there are too many performance cliffs to fall off.
sedx\_ has joined #lisp
heisig has quit [Quit: Leaving]
iamFIREcracker has joined #lisp
iamFIREc1 has quit [Ping timeout: 265 seconds]
mindCrime has joined #lisp
ljavorsk has quit [Ping timeout: 260 seconds]
dominic34 has joined #lisp
dominic34 has quit [Excess Flood]
dominic34 has joined #lisp
<mseddon> that said of course, for code that does not allocate, marshalling costs are cheap as chips.
sedx\_ has quit [Killed (Sigyn (Stay safe off irc))]
Robdgreat has quit [Ping timeout: 264 seconds]
liberliver has quit [Ping timeout: 256 seconds]
libertyprime has quit [Quit: leaving]
technobean has quit [Ping timeout: 240 seconds]
dddddd_ has joined #lisp
dddddd has quit [Ping timeout: 256 seconds]
scymtym has quit [Ping timeout: 244 seconds]
karlosz has joined #lisp
<mseddon> @alandipert, Just watched your ELS 2020 talk, interesting work!
<beach> mseddon: The @ convention is not used on IRC. Just type the nick followed by a `:'. Your IRC client should complete for you.
<mseddon> alandipert: Just watched your ELS 2020 talk, interesting work!
<mseddon> beach: Thanks, I have slipped into very bad habits.
<beach> Don't worry about it. Just pointing it out.
ukari has joined #lisp
<mseddon> np, it was helpful :)
<alandipert> mseddon: thank you
<mseddon> I have been privately thinking along similar lines and trying out small toys myself. Is it okay to email you later?
orivej has quit [Ping timeout: 264 seconds]
<mseddon> I have a few cute little tricks.
ukari has quit [Ping timeout: 256 seconds]
<beach> You can use #sicl do discuss implementation ideas if you like.
mujjingun has quit [Ping timeout: 260 seconds]
<mseddon> beach: Thanks!
ukari has joined #lisp
Lord_of_Life_ has joined #lisp
scymtym has joined #lisp
nicktick has quit [Ping timeout: 246 seconds]
mindCrime has quit [Ping timeout: 244 seconds]
Lord_of_Life has quit [Ping timeout: 265 seconds]
Lord_of_Life_ is now known as Lord_of_Life
Alloc95 has joined #lisp
gko_ has quit [Ping timeout: 246 seconds]
ukari has quit [Ping timeout: 265 seconds]
rogersm has quit [Quit: Leaving...]
shangul has quit [Ping timeout: 240 seconds]
yitzi has joined #lisp
mindCrime has joined #lisp
Alloc has joined #lisp
dmrintr has joined #lisp
colony has joined #lisp
mseddon has quit [Read error: Connection reset by peer]
Cymew has quit [Ping timeout: 265 seconds]
Alloc has quit [Quit: Quit]
mindCrime has quit [Ping timeout: 244 seconds]
smazga has quit [Ping timeout: 265 seconds]
Alloc has joined #lisp
mseddon has joined #lisp
smazga has joined #lisp
smazga has quit [Ping timeout: 240 seconds]
<mseddon> beach: to clarify wrt "What makes you think we don't have a roadmap for a sensible GC?", I think we do, and ultimately it will get there, but concurrent gc on mobile is out of the question due to https://caniuse.com/#feat=sharedarraybuffer being disabled because it allows hilarious side channel attacks.
<mseddon> footnote 1
grewal has quit [Quit: leaving]
smazga has joined #lisp
<mseddon> it may be serial gc is better than I last looked, so I wouldn't rule it out completely of course.
dmrintr has quit [Ping timeout: 264 seconds]
<mseddon> but basically I ran out of tricks to make it fast.
<mseddon> again, I'm looking for pause-less, or at least amortized into imperceptible pauses gc, because I'm interested at flinging things at the screen reliably within 60hz
<mseddon> perhaps you can tune a serial gc to get acceptable performance?
shangul has joined #lisp
<mseddon> IE only just died. Any good solution is going to have to wait for a long time if it wants to realistically place itself in the browser, if I'm not mistaken.
gaqwas has quit [Remote host closed the connection]
Alloc95 has quit [Ping timeout: 245 seconds]
akoana has joined #lisp
<mfiano> I make games and typically fling things at the screen at 120hz without any perceptible pauses
shifty has quit [Ping timeout: 240 seconds]
krid` has quit [Ping timeout: 260 seconds]
epony has quit [Ping timeout: 258 seconds]
<mseddon> :D this is a good sign.
VincentVega has joined #lisp
cosimone has quit [Remote host closed the connection]
<VincentVega> Hi, all. I have been trying to hack up some stuff with the metaobject protocol. My current goal is to make a custom slot option, accessed per instance, inherited simply by replacement. I started with the more sophisticated example given in the Art of the Metaobject Protocol (p. 87) which adds :attributes option, unions them when inherited, and
<VincentVega> provides a (slot-attribute instance slot-name attribute) interface. I thought it would be a good start, but I can't make it run. While I managed to fix some errors in the original code, this last one I don't know how to fix, it would be cool if someone could take a look. https://pastebin.com/kqNVj59F
<Bike> you want standard-effective-slot-definition, not effective-slot-definition
<Bike> the latter is an abstract class
<VincentVega> Bike: well, that was fast. it works now.
<Bike> someone else had the same issue a few weeks ago
<VincentVega> Bike: Oh : ) Well, thanks man. I suppose this example in the book is relevant otherwise?
<Bike> does the book actually make-instance effective-slot-definition?
<VincentVega> let me check
<Bike> i don't have a copy and it's been a while since i read it
<VincentVega> It just calls make-effective-slot-definition
<Bike> i don't think that's an actual function, so that sounds wrong to me
<Bike> the book is about a work in progress, after all
<VincentVega> Yeah, I didn't find it to be defined anywhere, so I just figured I would call make-instance.
<VincentVega> I mean it's defined in the book appendix, but not in closer mop.
<Bike> how is it defined in the book?
<VincentVega> just a sec
shangul has quit [Ping timeout: 260 seconds]
mseddon has quit [Quit: Leaving]
EvW1 has quit [Ping timeout: 260 seconds]
<mfiano> What would be a good way to define a custom #'typep function that is only suitable for testing if an object is of a particular standard-class type (so no complex type specifiers), so undefined types should not raise an error condition, just simply return NIL?
gal has quit [Ping timeout: 272 seconds]
<phoe> of particular standard-class type?
<mfiano> (defclass foo () ()) (typep (make-instance 'foo) 'foo) ; => T. (typep (make-instance 'foo) 'bar) ;=> NIL
<_death> (and (find-class typespec nil) (typep object typespec)) ?
<mfiano> Ah that could work, thanks.
<phoe> (defun my-typep (object type) (let ((class-1 (class-of object)) (class-2 (find-class type nil))) (when class-2 (subtypep class-1 class-2))))
<phoe> oh, yes, what _death said
gaqwas has joined #lisp
gaqwas has joined #lisp
<Bike> VincentVega: oh, well, this is just some bootstrapping thing then
jonatack has quit [Quit: jonatack]
gravicappa has quit [Ping timeout: 240 seconds]
gal has joined #lisp
<VincentVega> Bike: Yeah
sjl has quit [Ping timeout: 264 seconds]
bocaneri has quit [Read error: Connection reset by peer]
tamurasama has joined #lisp
Alloc has quit [Ping timeout: 260 seconds]
Alloc has joined #lisp
gal has quit [Ping timeout: 272 seconds]
jonatack has joined #lisp
<phoe> Xach: the code blocks on planet lisp could perhaps use either line breaks or horizontal scrolling
colony has quit [Remote host closed the connection]
<phoe> saying this because the recentmost post of mine digs into the sidebar with one line of LOOP
colony has joined #lisp
sjl has joined #lisp
gaqwas has quit [Remote host closed the connection]
krid` has joined #lisp
<Xach> oh bother
<_death> you should also define the setf function ;)
<phoe> _death: left as an exercise for the reader
gal has joined #lisp
narendraj9 has quit [Quit: Bye bye!]
colony has left #lisp [#lisp]
edgar-rft has quit [Quit: Leaving]
<phoe> Xach: the simplest CSS fix I have found: pre { overflow-x: auto; }
Jesin has joined #lisp
rumbler31_ has joined #lisp
orivej has joined #lisp
CrazyEddy has joined #lisp
gal has quit [Ping timeout: 272 seconds]
Jesin has quit [Quit: Leaving]
dominic35 has joined #lisp
dominic34 has quit [Ping timeout: 265 seconds]
dominic35 is now known as dominic34
dddddd_ is now known as dddddd
pfr has quit [Ping timeout: 240 seconds]
troydm has quit [Ping timeout: 246 seconds]
mindCrime has joined #lisp
sjl_ has joined #lisp
troydm has joined #lisp
tamurasama has quit [Quit: WeeChat 2.3]
vhost- has quit [Quit: WeeChat 2.8]
TwoNotes has joined #lisp
vhost- has joined #lisp
vhost- has quit [Changing host]
vhost- has joined #lisp
kaftejiman has joined #lisp
q3d has joined #lisp
ukari has joined #lisp
VincentVega has quit [Remote host closed the connection]
<jasom> wow; abcl shaved quite a bit of time off of startup since 1.5
<jasom> as in several minutes on the DoppioVM on firefox
<jasom> I'll have to try to find and resurrect my abcl-in-doppio demo and see if I can't get a REPL in under 5 minutes on firefox and under 2 minutes on chrome
aaaaaa has joined #lisp
<jasom> Firefox loading a .lisp file with only '(quit) in it: Time elapsed: 237277 ms. Chrome: Time elapsed: 97819 ms.
<jasom> in both cases, the majority of the time is *after* abcl prints the "Startup completed" message.
luckless has joined #lisp
luckless_ has quit [Ping timeout: 240 seconds]
ggole has quit [Quit: Leaving]
aaaaaa has quit [Quit: leaving]
epony has joined #lisp
<alandipert> jasom that's an interesting idea
gaqwas has joined #lisp
gaqwas has quit [Changing host]
gaqwas has joined #lisp
msk__ has joined #lisp
msk has quit [Ping timeout: 264 seconds]
mseddon_ has joined #lisp
mseddon has joined #lisp
mseddon has quit [Client Quit]
mseddon_ has quit [Client Quit]
tutti has joined #lisp
wsinatra has quit [Quit: WeeChat 2.9]
shka_ has quit [Ping timeout: 265 seconds]
yitzi has quit [Read error: Connection reset by peer]
TwoNotes has quit [Quit: Leaving]
CrazyEddy has quit [Ping timeout: 256 seconds]
yitzi has joined #lisp
_whitelogger has joined #lisp
fsmunoz has joined #lisp
ralt has joined #lisp
Bourne has joined #lisp
cosimone has joined #lisp
CrazyEddy has joined #lisp
q3d has quit [Remote host closed the connection]
epony has quit [Remote host closed the connection]
<aeth> wait, so that makes ABCL the way to run CL in the browser, not the actual attempts like JSCL? Wow.
rogersm has joined #lisp
epony has joined #lisp
Jesin has joined #lisp
X-Scale has quit [Read error: Connection reset by peer]
akoana has left #lisp ["Leaving"]
pve has quit [Quit: leaving]
msk__ has quit [Ping timeout: 240 seconds]
rogersm has quit [Quit: Leaving...]
gaqwas has quit [Ping timeout: 265 seconds]
cosimone has quit [Quit: Quit.]
sjl_ has quit [Ping timeout: 265 seconds]
tutti has quit [Ping timeout: 272 seconds]
gal has joined #lisp
shifty has joined #lisp
kaftejiman has quit [Remote host closed the connection]
bsd4me has quit [Quit: Leaving]
hiranochan has joined #lisp
igemnace has quit [Quit: WeeChat 2.9]
EvW has joined #lisp
mangoicedtea has joined #lisp
random-nick has quit [Ping timeout: 240 seconds]
wxie has joined #lisp
Jesin has quit [Quit: Leaving]
orivej has quit [Ping timeout: 256 seconds]
orivej has joined #lisp
wxie has quit [Ping timeout: 264 seconds]
fsmunoz has quit [Ping timeout: 240 seconds]
grewal has joined #lisp
rumbler31_ has quit [Ping timeout: 256 seconds]
rme has quit [Ping timeout: 272 seconds]
gendl has quit [Ping timeout: 260 seconds]
selwyn has quit [Ping timeout: 244 seconds]
terrorjack has quit [Ping timeout: 244 seconds]
rme has joined #lisp
mpontillo has quit [Read error: Connection reset by peer]
selwyn has joined #lisp
mpontillo has joined #lisp
jesse1010 has quit [Remote host closed the connection]