akater has quit [Remote host closed the connection]
akater has joined #lisp
bexx has joined #lisp
<bexx>
i'm trying to understand reduce from the end
<bexx>
why (reduce #'expt '(2 3 2) :from-end t) is 512 but (reduce #'expt '(2 3 2)) is 64?
<bexx>
isn't the same?
<Bike>
(expt 2 (expt 3 2)) versus (expt (expt 2 3) 2), i think
<bexx>
oooh i see
<bexx>
so reduce takes two elements?
<Bike>
expt takes two arguments
FreeBirdLjj has joined #lisp
<Bike>
reduce takes a function of two arguments, such as expt
<bexx>
ha!
<bexx>
now i can see!
<bexx>
thanks Bike!
<Bike>
you're welcome
<LdBeth>
because expt is not associative
holycow has joined #lisp
holycow has quit [Quit: Lost terminal]
<bexx>
LdBeth: which means?
<bexx>
s/which/that/
<bexx>
i have terrible english skills
<bexx>
sorry
<Bike>
it means that (expt x (expt y z)) does not equal (expt (expt x y) z).
<LdBeth>
which means (expt a b) is not guaranteed to (expt b a)
<Bike>
* is associative, so (* x (* y z)) = (* (* x y) z).
<Bike>
well that's commutativity.
techquila has joined #lisp
techquila has quit [Remote host closed the connection]
techquila has joined #lisp
<LdBeth>
GG, associative means 1+2+3 is (1+2)+3
<LdBeth>
My bad, expt is right associative, + is left associative
<LdBeth>
So 2^3^2 is 2^(3^2) if write out the parentheses
<Bike>
that's just a property of parsing
<grewal>
Except + is associative in most systems we talk about
<LdBeth>
APL, haha
<grewal>
By convention, ^ is right associative because (2^3)^2 = 2^6
<Bike>
that's not really relevant.
<LdBeth>
I guess many would understand reduce as insert infix operator in between each elements of the list
<Bike>
maybe, but it doesn't associate differently based on the function. it's just left associative.
<Bike>
or right-associative if you do :from-end t.
<grewal>
Yes, I guess my point was more that if you're transcribing a math formula, you need to know what the conventions are and how to implement that in lisp
wxie has joined #lisp
catchme has quit [Quit: Connection closed for inactivity]
_whitelogger has joined #lisp
lucasb has quit [Quit: Connection closed for inactivity]
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 245 seconds]
Lord_of_Life_ is now known as Lord_of_Life
bexx has quit [Remote host closed the connection]
atgreen has quit [Ping timeout: 250 seconds]
atgreen has joined #lisp
jason_m has joined #lisp
jason_m has quit [Ping timeout: 245 seconds]
jason_m has joined #lisp
jason_m has quit [Ping timeout: 246 seconds]
ricekrispie2 has joined #lisp
ricekrispie has quit [Ping timeout: 250 seconds]
dale has quit [Quit: dale]
piku has joined #lisp
_whitelogger has joined #lisp
anewuser has joined #lisp
noobineer has joined #lisp
anewuser has quit [Read error: Connection reset by peer]
<akater>
LdBeth: I'd say “insert infix” would be #'apply. I could never understand reduce at all and consider it misguided at best and meaningless at worst, a malformed and crippled fold.
<Bike>
but it is fold.
ebrasca has joined #lisp
noobineer has quit [Read error: Connection reset by peer]
<stylewarning>
apply is absolutely not “insert infix” except for a few corner cases
noobineer has joined #lisp
<White_Flame>
the fact that reduce calls its function even with zero arguments is odd, though. I would think that should be a separate operation, not a reduction of pairs
<White_Flame>
it really only makes sense for + and *
<akater>
Bike: fold accepts functions X⨯Y→X, while reduce accepts mere X⨯X→X. Clearly, reduce is expressible through fold but not (sanely) vice versa.
<Bike>
you can use :initial-element.
<Bike>
it's not as pretty, but it's definitely fold
<akater>
Bike: I have fold defined with reduce and initial-element, of course. Nevertheless, reduce accepts functions that are less general than those accepted by fold, if one cares about types. fold always makes sense when you deal with empty sequences, reduce does not.
<Bike>
oh, i misunderstood.
<Bike>
but i still don't understand. if you restrict yourself to using :initial-value, empty sequences work fine. and you can do the former type.
<Bike>
(reduce (lambda (x y) (check-type x integer) (check-type y list) (cons x y)) '(1 2 3) :initial-value nil :from-end t)
<akater>
If you restrict yourself this way, it *is* indeed fold. It's great that Common Lisp has reduce. Actually it probably *should* have reduce and not fold as the more basic component, if there has to be one, I'd say.
dddddd has quit [Remote host closed the connection]
Aruseus has quit [Remote host closed the connection]
<beach>
Good morning everyone!
arescorpio has joined #lisp
<akater>
By the way, fold generalizes cleanly to mulitiple sequences, unlike reduce with its need for keywords.
caltelt_ has joined #lisp
<akater>
Also, one can imagine foldf but reducef would be quite ugly.
torbo has joined #lisp
patlv has quit [Quit: patlv]
igemnace has joined #lisp
dale has joined #lisp
Tordek has quit [Ping timeout: 246 seconds]
Tordek has joined #lisp
piku has left #lisp ["Leaving"]
<LdBeth>
why care about funcion type? lisp is unitype.
<LdBeth>
T * T -> T
<aeth>
oh wow, so apparently #'reduce sets initial-value to (+) or (*) or whatever the function is if you don't provide one
<aeth>
Yes, that does seem like it's just a shortcut so * and + are more concise
<Bike>
pretty much, yes.
_whitelogger has joined #lisp
<LdBeth>
good evening
<aeth>
hi \{_}
<Josh_2>
aeth: but can you turn CL into a girlfriend?
<\{_}>
does it take a lot of *magic* to implement something like the &key in a macro?
<\{_}>
say if I want to make something that has a structure similar to defun itself?
<Bike>
usually you can use destructuring-bind or a lambda or something and thus not implement it yourself.
<aeth>
A key is just a plist tail
<\{_}>
hm!
<LdBeth>
Josh_2: GG, make AI
<aeth>
If you didn't have destructuring-bind you could use plist functions to handle it, although you'd probably have to do something like walk through it first to make sure that it's well-formed (even length, every other as a key, no double key...)
<\{_}>
aeth: right, that was I worrying about, didn't know about defstructuring-bind though
<\{_}>
let me check it out
<aeth>
destructuring-bind does all the work for you
<aeth>
It's very fun
<\{_}>
and to think I was to reimplement (poorly ofc) something already in the language
<aeth>
destructuring-bind makes sure it's valid. If you take car and cadr, the list might look like (1 2 3 4 5 6 7) and you're just taking the first two. If you do (destructuring-bind (first second) your-list ...) you know that it must look like (1 2) unless you e.g. (first second &rest rest) and then (declare (ignore rest)) in the body or maybe do a blank keys like (first second &key &allow-other-keys)
<aeth>
And that's just taking the first two elements! plist tails (since the key doesn't have to start at the first element) are much trickier, and destructuring-bind handles it.
<aeth>
you can do (destructuring-bind (foo &key bar baz quux) (list 42 :quux 42 :bar 43 :baz 44) (values foo bar baz quux))
Bike has quit [Quit: Lost terminal]
<aeth>
I wouldn't want to write code to make sure that that's valid, but I don't have to.
<\{_}>
my head hurts. but I'll get the hang of this at some point
<\{_}>
I'm starting to understand the function
<\{_}>
cl surely has some spooky stuff
arescorpio has quit [Quit: Leaving.]
<\{_}>
thanks for the help! I'm off work now g2g
\{_} has quit [Quit: \{_}]
wxie has quit [Ping timeout: 250 seconds]
ltriant has quit [Quit: leaving]
caltelt_ has quit [Ping timeout: 255 seconds]
nopf has quit [Remote host closed the connection]
orivej has joined #lisp
noobineer has quit [Read error: Connection reset by peer]
torbo has quit [Remote host closed the connection]
_whitelogger has joined #lisp
_whitelogger has joined #lisp
sauvin has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
anewuser has quit [Ping timeout: 250 seconds]
norserob has joined #lisp
frodef has joined #lisp
_whitelogger has joined #lisp
vlatkoB has joined #lisp
gxt has quit [Ping timeout: 252 seconds]
JohnMS_WORK has joined #lisp
pjb has joined #lisp
_whitelogger has joined #lisp
Inline has quit [Quit: Leaving]
jprajzne has quit [Remote host closed the connection]
varjag has joined #lisp
<pjb>
aeth: to see how difficult it is to parse lambda-list, you can have a look at com.informatimago.common-lisp.lisp-sexp.source-form:parse-lambda-list
<pjb>
(not very difficult).
Ukari has quit [Remote host closed the connection]
Ukari has joined #lisp
nicolas23[m] has quit [Remote host closed the connection]
djeis[m] has quit [Read error: Connection reset by peer]
Manny8888 has quit [Remote host closed the connection]
rudi[m] has quit [Read error: Connection reset by peer]
akanouras has quit [Read error: Connection reset by peer]
illandan[m] has quit [Remote host closed the connection]
Gnuxie[m] has quit [Read error: Connection reset by peer]
sielicki has quit [Read error: Connection reset by peer]
LdBeth has quit [Remote host closed the connection]
Woazboat has quit [Remote host closed the connection]
no-defun-allowed has quit [Read error: Connection reset by peer]
colelyman has quit [Read error: Connection reset by peer]
xylef has quit [Write error: Connection reset by peer]
Jachy has quit [Read error: Connection reset by peer]
juristi has quit [Remote host closed the connection]
dtw has quit [Read error: Connection reset by peer]
irdr has quit [Max SendQ exceeded]
ricekrispie2 is now known as ricekrispie
irdr has joined #lisp
varjag has quit [Ping timeout: 268 seconds]
ggole has joined #lisp
Manny8888 has joined #lisp
jprajzne has joined #lisp
shrdlu68 has joined #lisp
<splittist>
morning
Josh_2 has quit [Remote host closed the connection]
<flip214>
is that a setup problem on c-l.net, or has the repository moved?
Ukari has joined #lisp
techquila has quit [Ping timeout: 250 seconds]
Essadon has joined #lisp
<jackdaniel>
as far as I recall year or two ago Eric made a shoutout on the mailing list if anyone has problem with migrating all cl-net repositories to git
<jackdaniel>
and make them available on gitlab instance
<jackdaniel>
flip214: ↑
<flip214>
jackdaniel: yeah, thanks, saw that. so it's moved to git.... I'll take a look.
<flip214>
minion: memo for _death: I've got a couple of (old!) patches up at github.com/phmarek/dbus.git ... Would you please take a
<minion>
Remembered. I'll tell _death when he/she/it next speaks.
<flip214>
minion: memo for _death: look? Thanks!
<minion>
Remembered. I'll tell _death when he/she/it next speaks.
akanouras has joined #lisp
colelyman has joined #lisp
xylef has joined #lisp
dtw has joined #lisp
no-defun-allowed has joined #lisp
sielicki has joined #lisp
Jachy has joined #lisp
illandan[m] has joined #lisp
Woazboat has joined #lisp
rdap has quit [Remote host closed the connection]
rdap has joined #lisp
j-r has quit [Quit: Page closed]
dddddd has joined #lisp
ebrasca has quit [Remote host closed the connection]
Ukari has quit [Ping timeout: 264 seconds]
JohnMS_WORK has quit [Read error: Connection reset by peer]
JohnMS_WORK has joined #lisp
akoana has left #lisp [#lisp]
frodef has quit [Ping timeout: 250 seconds]
Ukari has joined #lisp
rdap has quit [Remote host closed the connection]
rdap has joined #lisp
juristi has joined #lisp
rdap has quit [Remote host closed the connection]
rdap has joined #lisp
frodef has joined #lisp
amerlyq has joined #lisp
LdBeth has joined #lisp
asedeno has quit [Ping timeout: 252 seconds]
asedeno has joined #lisp
lnostdal has quit [Excess Flood]
lnostdal has joined #lisp
orivej has quit [Ping timeout: 245 seconds]
X-Scale has quit [Read error: Connection reset by peer]
rumbler31 has joined #lisp
esrse has quit [Read error: Connection reset by peer]
rumbler31 has quit [Ping timeout: 264 seconds]
__jrjsmr_ has joined #lisp
vlatkoB_ has joined #lisp
frodef has quit [Ping timeout: 244 seconds]
rdap has quit [Remote host closed the connection]
rdap has joined #lisp
vlatkoB has quit [Ping timeout: 250 seconds]
warweasle has joined #lisp
igemnace has quit [Quit: WeeChat 2.4]
random-nick has joined #lisp
patlv has joined #lisp
shifty has quit [Ping timeout: 245 seconds]
Lord_of_Life_ has joined #lisp
Josh_2 has quit [Read error: Connection reset by peer]
rdap has quit [Remote host closed the connection]
rdap has joined #lisp
Lord_of_Life has quit [Ping timeout: 255 seconds]
Lord_of_Life_ is now known as Lord_of_Life
orivej has joined #lisp
Bike has joined #lisp
orivej has quit [Ping timeout: 250 seconds]
LiamH has joined #lisp
__jrjsmr_ has quit [Read error: Connection reset by peer]
djeis[m] has joined #lisp
atgreen has quit [Ping timeout: 250 seconds]
<pfdietz>
I had wanted to go to ELS this year. Maybe if there's one next year.
<beach>
Of course.
<beach>
There is one every year.
cage_ has joined #lisp
X-Scale has joined #lisp
<splittist>
I have enjoyed reading the beta-peta paper
pankajgodbole has joined #lisp
__jrjsmrtn__ has joined #lisp
__jrjsmrtn__ has quit [Client Quit]
__jrjsmrtn__ has joined #lisp
__jrjsmrtn__ has quit [Client Quit]
__jrjsmrtn__ has joined #lisp
lucasb has joined #lisp
atgreen has joined #lisp
shrdlu68 has left #lisp ["WeeChat 2.3"]
lumm has joined #lisp
ralt has joined #lisp
rumbler31 has joined #lisp
hhdave has joined #lisp
atgreen has quit [Ping timeout: 245 seconds]
Ukari has quit [Remote host closed the connection]
Ukari has joined #lisp
rxf has joined #lisp
igemnace has joined #lisp
varjag has joined #lisp
jmercouris has joined #lisp
<jmercouris>
how to get slime to recognize environment variables from my login shell?
<jmercouris>
but it doesn't seem to want to load env varabiles
<dlowe>
you'll have to start your lisp implementation from the shell, load and start swank, then connect to it with M-x slime-connect
<jmercouris>
no way to do it via some emacs configuration?
<nirved>
jmercouris: create a shell script which starts lisp, and set it as the one slime should run
__jrjsmrtn__ has quit [Quit: __jrjsmrtn__]
<dlowe>
jmercouris: if you start emacs in the shell, it should inherit the environment vars
<pjb>
jmercouris: your question is strange. what do you mean?
<pjb>
jmercouris: eg. how is slime related at all with environment variables?
<pjb>
jmercouris: What would for slime to "recognize" environment variables mean?
spoeplau has quit [Ping timeout: 245 seconds]
<jmercouris>
I mean that when I do a setting of a term environment variable
<jmercouris>
and then I do an osicat test, it will appear
<nirved>
jmercouris: setting it where? if lisp is already running, how would it know that you set it?
<jmercouris>
I have it set before I even launch emacs...
<jmercouris>
whether lisp is already running or not is irrelevant
<jmercouris>
I'm talking about: (osicat:environment-variable "APP_ENV") returning the value of APP_ENV
<jmercouris>
because in a term I can easily echo $APP_ENV and get the value, but in Slime it does not appear
<Bike>
environment variables you set in a shell are only in that one shell.
<nirved>
or its child processes
<nirved>
(at the fork time)
<jmercouris>
I am also using the emacs package that inherits the environment vars from the shell
<jmercouris>
I forget the name
<Bike>
i mean, if you start a program from the shell, and then alter a variable in the shell, the program will still have the old value because it got a copy of the environment, they don't all share the same environment.
<Bike>
i think.
__jrjsmrtn__ has joined #lisp
angavrilov has joined #lisp
flamebeard has quit []
JetJej has joined #lisp
<jmercouris>
Yes, but in this case I've already set the variable
rdap has quit [Remote host closed the connection]
rdap has joined #lisp
varjag has quit [Ping timeout: 245 seconds]
atgreen has joined #lisp
<Bike>
i see. well, i think a lisp started by a slime in an emacs run from a shell should inherit that shell's environment variables. but it's a little indirect.
<Bike>
let me see if i can test this in some non stupid way
Ukari has quit [Ping timeout: 250 seconds]
<Bike>
yep, if i `export FOO=347`, `/path/to/emacs`, then M-x - slime, launch sbcl, and do (sb-ext:posix-getenv "FOO"), i get "347"
<Bike>
that's the kind of thing you have in mind, yes?
jprajzne has quit [Quit: Leaving.]
varjag has joined #lisp
rumbler31 has quit [Remote host closed the connection]
<pjb>
dlowe: nope. packages and symbols are named with strings, not with symbols.
<pjb>
dlowe: setters are named with lists such as (setf foo).
zotan has joined #lisp
<asarch>
I thought it was something a la C/C++ headers files: #include "foo.h" also #include "bar.h" which also #include "baz.h"
<pjb>
asarch: what does it mean to export a value? You sound crazy…
<pjb>
asarch: can you export 42 from a C++ class? or "duh!" ?
<dlowe>
pjb: "string designators" but yes
<pjb>
strings.
<pjb>
(package-name :cl) #| --> "COMMON-LISP" |# a string!
<pjb>
(symbol-name '#:foo) #| --> "FOO" |# again a string!
<dlowe>
(defpackage #:foo) ; not a string!
<asarch>
One stupid question: why (:use :common-lisp) and not (:use :common-lisp-user) if the latter is a super package of the first one?
<dlowe>
(intern 'baz) ; also not a string!
<pjb>
(intern 'baz) #| ERROR: The value baz is not of the expected type string. |#
<Xach>
asarch: it is not a super package
<dlowe>
whoops, haha
<asarch>
?
<pjb>
dlowe: yes, defpackage accepts string designators, but it uses strings.
<pjb>
asarch: the pacakge common-lisp-user doesn't export anything, usually. It's implementation dependent if it does. And its content is entirely implementation dependent.
<pjb>
asarch: the firs thing you should do, is to delete the common-lisp-user package and recreate it the same in all implementations!
pankajgodbole has quit [Ping timeout: 268 seconds]
<asarch>
Which one is the preferred way, (defpackage :asarch ...) or (defpackage "asarch" ...)?
<dlowe>
There's no consensus
<dlowe>
I like (defpackage #:asarch)
<dlowe>
You'll probably want to uppercase it in someway though
slyrus__ has quit [Quit: Leaving]
<asarch>
Ok
<pjb>
asarch: I use (defpackage "ASARCH" …)
<pjb>
asarch: you can use (defpackage "asarch" …), but then you will have either to set (readtable-case *readtable*) or write |asarch|:foo etc.
<asarch>
Oh :-(
<asarch>
Can I have both the name of a class with the same name of the package?
<Xach>
asarch: yes
<Xach>
asarch: package names and symbol names are distinct.
<asarch>
Ok
<pjb>
Classes are named with symbols. Packages are named with strings.
<Xach>
it is no big deal to have a symbol that prints as bob:bob
<pjb>
You know a lot of symbols that are eql to strings?
<pjb>
Tsk! Tsk!
<asarch>
Wow!
<asarch>
Ok, ok
<asarch>
Let's finish this
<asarch>
BTW, a moment of silence for Google+
<jdz>
What is Google+?
<dlowe>
please take it to #lispcafe
sauvin has quit [Ping timeout: 246 seconds]
shifty has joined #lisp
rumbler31 has joined #lisp
Josh_2 has joined #lisp
<aeth>
asarch: I go with dlowe's #:foo style because visually it stands out when syntax highlighted
<aeth>
(and even without, since #: is rare)
<aeth>
asarch: Packages are just namespaces for symbols. They import/export/etc. symbols. Symbols themselves have multiple namespaces (this is the other namespace concept) which can be associated with things.
ebrasca has joined #lisp
<aeth>
So you can have a class and a function both named FOO, whose real name is YOUR-PACKAGE:FOO (two :: instead of : if it isn't an exported symbol)
gxt has quit [Ping timeout: 268 seconds]
<Josh_2>
I also use #:
<aeth>
asarch: So there's no reason why you can't have FOO:FOO because those are different parts of the symbol
moei has joined #lisp
varjag has quit [Ping timeout: 246 seconds]
<aeth>
asarch: The package prefix allows you to not have name collisions, and can be removed in certain cases (and usually is for CL:FOO). What that symbol in the package means depends on context, which is how you can get a variable, a function, and a type with the same name (there are others, but these three are common)
<aeth>
And in case you wonder about the difference between classes and types, afaik classes are a subset of types. Types let you do things like (integer 0 42) so you can be more specific than classes
<asarch>
Ok
<aeth>
And now for some heresy. Properly written CL is case-insensitive, so you can ignore the upcasing by (setf *print-case* :downcase) in the REPL since the original FOO was probably upcased from foo so now you get the original foo back in errors/etc. You just have to know that some code might not obey this, such as a package mistakenly named "foo" instead of "FOO" or #:foo
<aeth>
So it works 99.9% of the time, but sometimes you would have to disable it to debug properly. I usually turn it on because I macroexpand-1 all of the time
<asarch>
Ok
<aeth>
The only two cases I can think of where you might see lower case symbols are in hash-table keys or in people implementing another, case-sensitive language inside of CL
<asarch>
I see
<aeth>
You can get them by escaping, like '|foo| or '|fooBar| as well as from interning or changing the readtable's rules.
<asarch>
How can you set aliases for your package?
<aeth>
nicknames, but those aren't popular because they make name collisions very easy
<aeth>
Some implementations have package-local-nicknames.
<asarch>
COMMON-LISP-USER -> CL-USER
<asarch>
?
<aeth>
asarch: defpackage has a :nicknames and COMMON-LISP-USER probably has a (:nicknames #:cl-user) in its defpackage
atgreen has quit [Ping timeout: 264 seconds]
<aeth>
asarch: If you want to provide an additional nickname to it locally to you, you can use package-local-nicknames, which unfortunately doesn't seem to be complete at the moment. https://github.com/3b/package-local-nicknames
<aeth>
SBCL has an implementation-specific way to do package local nicknames, and other implementations might have similar capabilities.
<momozor>
my Open/Closed principle explanations sucks really bad
<momozor>
so sorry for that
<momozor>
i'm going to rewrite them soon
<Xach>
momozor: i generally think it is better to start from generic functions, not classes, for clos design.
<Xach>
starting from classes and using arguments named "self" is a sign of writing another OOP style using CLOS, which in my view is generally a mismatch
atgreen has quit [Ping timeout: 245 seconds]
<momozor>
Xach: thank you. I will consider rewriting the examples with generic functions instead. :)
<LdBeth>
momozor: it is redundant to wrap around accessor because accessor itself is defined as a generic function
<aeth>
What do you all use instead of self? (I haven't really seen self in CL, either, because it isn't a good name in CL methods.) Is it generally (foo foo) instead of (self foo)?
<Bike>
i don't use anything "instead of" self, because i don't think in those terms.
<grewal>
I usually use (foo foo)
<Bike>
i just like, write what the parameter is for or does or is, like in any function
slyrus_ has joined #lisp
<momozor>
LdBeth: Do you mean that for Single Responsibility topic? If yes, yeah. I realized I can just call them with (brand object) or use :reader (or to set them, use :accessor)
lemoinem has quit [Killed (verne.freenode.net (Nickname regained by services))]
lemoinem has joined #lisp
<momozor>
LdBeth: but thank you :)
<aeth>
Bike: I was saying "instead of" because the linked PDF has "self" all over the place
<Bike>
because the author is thinking more in message passing terms, i guess.
<Bike>
you should use whatever would be descriptive for the particular function you are writing
<momozor>
okay. thanks!
<Bike>
which is probably not "obj", since "object" says nothing specific.
<Bike>
sometimes one gets lazy, though.
<Xach>
sometimes an object is just an object.
<Xach>
and a list is just a list.
asarch has quit [Ping timeout: 246 seconds]
<pfdietz>
A sigh is just a sigh...
<aeth>
I usually use object in the defgeneric, not the defmethod
<aeth>
If I generate the defmethod from a macro, I use object, though
<aeth>
Looks like I inconsistently sometimes use object in a defmethod if it's extremely trivial. Maybe I should do a large renaming or maybe it's not worth it.
<aeth>
stylewarning: I would assume replace could be the fastest way
<aeth>
stylewarning: oh sorry, fill
<stylewarning>
FILL works on sequences
<aeth>
ah, now I see it
<aeth>
If you're concerned about efficiency, then it would probably actually be more efficient to write your own aref (if possible) than to write your own fill, since the fill could potentially fill one byte at a time if optimized for bit arrays.
<Bike>
i don't think there's a more efficient way than the obvious. bit arrays are missing some stuff in CL
<aeth>
Bike: the issue here is that 2D arrays are missing stuff, not bit arrays
lnostdal has joined #lisp
kenu has joined #lisp
<kenu>
I would like to run my system from command line
<Xach>
kenu: that is because the form must be read before any of it is evaluated.
<Xach>
kenu: so the (require "ASDF") does not happen in time to read asdf:load-system.
<aeth>
kenu: If you put that logic in a separate file then you can just run sbcl --non-interactive --load /some/dir/path/file-that-loads-your-system.lisp
<MichaelRaskin>
You can use two different --eval
<aeth>
kenu: It's a lot easier to reason about a .lisp file than arguments to a command line argument... and the file is portable, the ways to load it are specific
<aeth>
s/to a command line argument/to a command/
nanoz has quit [Ping timeout: 245 seconds]
Arcaelyx has joined #lisp
<kenu>
@MIchalRaskin two different --evals do the trick
<kenu>
and the other thing I wonder about, I've got my system in common-lisp folder but it depends on some systems from quicklisp, at the moment I've got them quickloaded at the top of .asd file. I assume it's not the right approach as it works only once all required systems are already instaled with quicklisp