mister_m has quit [Remote host closed the connection]
wigust- has joined #lisp
hatchback176 has joined #lisp
<sjl>
manualcrank: `cat`ing their sample input 36000 times gives me a 1008000 line sample file, which is larger than their limit. Running (time (with-open-file (s "foos") (loop :for l = (read-line s nil nil) :while l :sum 1))) on that in SBCL takes 0.11s on my machine.
<sjl>
So you still have 89% of the allotted time to actually do stuff with the input.
wigust has quit [Ping timeout: 272 seconds]
<sjl>
So maybe whatever hardware they're running on is old or something.
torbo has joined #lisp
<hatchback176>
.109s in python
xvx has joined #lisp
xvx has quit [Client Quit]
<sjl>
Yeah, even a full solution is <1s on my laptop, but exceeds the limit on the site. So they must be running on something old/virtualized to all hell
aindilis has quit [Read error: Connection reset by peer]
sjl has quit [Quit: WeeChat 2.3-dev]
orivej has joined #lisp
anewuser has joined #lisp
aindilis has joined #lisp
hatchback176 has quit [Remote host closed the connection]
alexanderbarbosa has joined #lisp
<ebzzry>
Kabriel: thanks
ebzzry has quit [Quit: WeeChat 2.3]
Kaisyu7 has quit [Quit: ERC (IRC client for Emacs 26.2)]
hatchback176 has joined #lisp
lucasb has quit [Quit: Connection closed for inactivity]
<manualcrank>
can't use any library that isn't standard btw, so the mmap library is out
Kaisyu7 has joined #lisp
alexanderbarbosa has quit [Remote host closed the connection]
<manualcrank>
also, the allotted time includes the time to load and initialize sbcl
<Xach>
working with unsigned-byte 8 streams will be a lot faster.
<manualcrank>
i'll try that
<Xach>
but it will be less convenient and clear. but there are ways to reclaim clarity if not convenience.
paul0 has joined #lisp
<aeth>
manualcrank: do you have to process by the line? depending on what you're doing you could write a state machine that goes character-by-character (or byte-by-byte)
notzmv has quit [Ping timeout: 272 seconds]
<manualcrank>
no, it's just the most natural
<manualcrank>
i did slurp all of stdin in one attempt and subsequence individual lines out of it
<manualcrank>
but that timed out too
<aeth>
Well subseq isn't a good idea for performance. That's why nearly everything has a start and end optional or keyword parameter (or start1 end1 start2 end2, etc.)
<manualcrank>
largest possible input is 1,000,000 trees of 126 (+1 for newline) char-length each
<aeth>
obviously a lot of the time, especially these days, using subseq doesn't really matter
<manualcrank>
i used read-sequence to read that many characters in at once
<manualcrank>
it was too slow
<aeth>
if I needed performance and I didn't need to build up buffers of lines I would just work character-by-character (or, again, maybe just byte-by-byte)
<manualcrank>
subseq is necessary no matter what 'cuz you're putting stuff in a hash table
<aeth>
well, hash table performance isn't great in CL
<Bike>
uh? i would think it would be fine
<manualcrank>
here, too, you really want an ordered map
<aeth>
Bike: this is a very high performance coding contest or something
<manualcrank>
so you have to extract the keys into an array and sort them
<aeth>
the only hash table has everything as a key and a value, which isn't going to benchmark well against e.g. C++
<manualcrank>
honestly the performance of computation-bound stuff is perfectly fine
<aeth>
strange.
<aeth>
I thought the hash table benchmark was one of the places where SBCL was weak in the Benchmarks Game
<manualcrank>
no problems with array and hash table performance, maybe 0.02s slower than C++
<Bike>
even if it is, i/o is probably going to be worse
<aeth>
yeah, I guess this is just overwhelmingly dominated by I/O
<manualcrank>
yeah if you have to read or write a lot of stuff, all the other languages are faster
<manualcrank>
i'm happy with my alien c-gets, but i'd be happier still if i could get fgets_unlocked to work and if return values weren't converted to new string objects
<Bike>
new strings? that would be hard to avoid.
<Bike>
maybe displaced arrays would help. but i kind of doubt that
<manualcrank>
i get the sense it's possible reading sbcl foreign function docs
<manualcrank>
but i'm too new to fully understand what i'm reading
<aeth>
manualcrank: I wonder if working with bytes makes a difference over working with characters? A lot of languages use really weird strings but in SBCL afaik it's just utf32 so it reads utf8 into utf32 and there's a translation. Idk if that would make a difference, though
<Bike>
oh, with alien you mean
<Bike>
yeah, xach suggested that already.
<aeth>
ah, right
<manualcrank>
(setf sb-impl::*default-external-format* :utf-8) has no noticeable effect
<aeth>
external format.
<aeth>
internal format is utf-32
<aeth>
iirc
<Bike>
yes, probably.
<manualcrank>
uiop has uiop:read-file-string but that takes a filename arg and anyway uiop isn't an option on the site
<aeth>
so it takes 123 124 and turns it into 0 0 0 123 0 0 0 124. You could see this yourself reading some FASLs with a binary reader, like hexl-mode in emacs. I think, though, at some point they might have optimized the size to get rid of that, though. It looks like that's just for symbols, though
<aeth>
literal strings saved in the fasl still have the 000000 between each character (assuming ASCII subset of unicode)
<Bike>
you realize sb-alien is also not standard, i hope
<aeth>
the rule is probably no third party libraries, I hope
<manualcrank>
that's the rule
<aeth>
That still interferes with CL a lot. CL is a very multi-implementation language and each implementation implements extensions subtly differently and we rely heavily on portability libraries to actually use features
notzmv has joined #lisp
<Bike>
my dipshit solution can do 2.9 mil trees in 1.04s. let me try it with bytes or sorting as it goes or something
<Bike>
oh, that is only input, though, i gess
<Bike>
i suspect my solution is so dumb it's cpu bound, though
<manualcrank>
i don't mind not being able to use portability libs, it's just a puzzle site, point is to learn some algorithms
anewuser has quit [Read error: Connection reset by peer]
dale has joined #lisp
papachan has quit [Quit: Saliendo]
igemnace has quit [Read error: Connection reset by peer]
igemnace has joined #lisp
<Bike>
adjustable array crap worse, well that's nice
<Bike>
if displaced arrays are actually useful to me at some point it'll worry me
Lycurgus has quit [Quit: Exeunt]
quazimodo has quit [Ping timeout: 245 seconds]
<moldybits>
how do you specialize on a 2 dimensional array?
nanoz has joined #lisp
<moldybits>
'(array * 2), i guess
<Bike>
specialize as in methods? can't
<moldybits>
oh
<moldybits>
just array?
<Bike>
array, vector, bit-vector, string
ym555 has quit [Quit: leaving...]
alexanderbarbosa has joined #lisp
<manualcrank>
update to <http://pasted.co/d921528c>: reason it lops off the \n is because that's what gets() does, duh (fgets() doesn't)
<manualcrank>
also, returning a c-string according to docs implies a conversion to a Lisp string
<manualcrank>
i can though specify it returns (* char) and just return the buf i used to alien call gets
<manualcrank>
in that case there's no conversion, just an array of char (i changed the code to element type (unsigned-byte 8) though)
<manualcrank>
you have to find the 0 (#\Nul if array of character) yourself then
alexanderbarbosa has quit [Remote host closed the connection]
alexanderbarbosa has joined #lisp
karlosz_ has joined #lisp
<manualcrank>
also, base-char is better than character because the former doesn't convert going from Lisp to C
<Bike>
that would be the utf-32
orivej has quit [Ping timeout: 258 seconds]
zotan has quit [Ping timeout: 258 seconds]
zotan has joined #lisp
karlosz_ has quit [Quit: karlosz_]
loke has quit [Remote host closed the connection]
Bike has quit [Quit: Lost terminal]
orivej has joined #lisp
<manualcrank>
i'd really like to learn how to get at FILE *'s though, notably stdin
libertyprime has quit [Quit: leaving]
loke has joined #lisp
froggey has quit [Ping timeout: 245 seconds]
froggey has joined #lisp
alexanderbarbosa has quit [Remote host closed the connection]
bexx has quit [Remote host closed the connection]
dale has quit [Quit: dale]
gravicappa has joined #lisp
dacoda has joined #lisp
dacoda has quit [Remote host closed the connection]
dacoda has joined #lisp
moei has joined #lisp
terpri_ has joined #lisp
mathrick has quit [Ping timeout: 245 seconds]
terpri has quit [Ping timeout: 245 seconds]
dacoda has quit [Remote host closed the connection]
mathrick has joined #lisp
beach has joined #lisp
<beach>
Good morning everyone!
<LdBeth>
Morning
orivej has quit [Ping timeout: 245 seconds]
vlatkoB has joined #lisp
torbo has quit [Remote host closed the connection]
dddddd has quit [Remote host closed the connection]
Lycurgus has joined #lisp
nanoz has quit [Ping timeout: 272 seconds]
orivej has joined #lisp
<ck_>
GOod morning
<beach>
Hello ck_.
<ck_>
beach: you're like a benchmark. If I make it to my desk within let's say an hour of you saying good morning, it will probably be a good day : )
sauvin has joined #lisp
<beach>
Good to know I serve some important purpose.
paul0 has quit [Ping timeout: 244 seconds]
<loke>
ck_: I use him as much lunch clock. When he says good morning, I know I'm about to have lunch soon
* beach
has a feeling that he should change his profession.
<ck_>
beach: I meant it as a compliment. I wish I were as steady as you
<ck_>
loke: Mittler zwischen Hirn und Haenden muss das Herz sein!
<beach>
ck_: Don't worry. I took it as such.
Lord_of_Life has joined #lisp
<loke>
ck_: yes. I have watched the movie more than once, and I was never entirely happy with that conclusion.
<loke>
I do, however, feel that although I understand the words, the meaning is somewhat lost on me.
<ck_>
well, it is a product of its time.
<ck_>
I take it as 'pure rationality without empathy will not lead you to a good outcome', casually interpreted
orivej has joined #lisp
<pjb>
loke: new job, but old profession, that of watchman. They used to announce the hours during the night.
<loke>
ck_: I tend to read it as the idea that there must be harmony and understanding between the classes, and they have to understand each struggles. The understand is metaphorical heart. However, it also does imply that the classes permanent and you are born into it. That is very much a 1800's notion that feels incredibly uncomfotrable to me.
<loke>
“The understanding is the...”
<loke>
s/each/eachother's/
<ck_>
your interpretation is probably more apt.
Inline has quit [Quit: Leaving]
techquila has quit [Ping timeout: 248 seconds]
ofi has joined #lisp
tazjin has quit [Ping timeout: 252 seconds]
pchrist has quit [Ping timeout: 252 seconds]
gendl has quit [Ping timeout: 252 seconds]
pchrist has joined #lisp
tazjin has joined #lisp
<manualcrank>
in case anyone still cares, i found a kludge around getting access to stdin
gendl has joined #lisp
<manualcrank>
define-alien-routine fdopen
<manualcrank>
i can then use the return value in define-alien-routine fgets_unlocked
karlosz_ has joined #lisp
<manualcrank>
works ok: line by line input is now faster than alien-routine gets
ofi has quit [Remote host closed the connection]
<beach>
What is the logic of using foreign code when the purpose is to compete with Common Lisp code?
karlosz_ has quit [Quit: karlosz_]
JohnMS_WORK has joined #lisp
techquila has joined #lisp
<manualcrank>
in this case i can't come up with any Lisp code that doesn't TLE
mingus has joined #lisp
<manualcrank>
many times though i'm content to just use READ because the input is always correct and there isn't enough to make a difference
<beach>
So the logic is to be fast, no matter what language is used?
techquila has quit [Ping timeout: 258 seconds]
<manualcrank>
for me, no, speed is irrelevant as long as the code produces the correct answer in the allotted time
orivej has quit [Ping timeout: 258 seconds]
Oladon has quit [Ping timeout: 272 seconds]
karlosz_ has joined #lisp
<manualcrank>
i'm doing these problems on a core 2 duo from over a decade; it's always fast enough for me
<manualcrank>
some sites have a clojure option (not kattis) and that's hopeless because none of the code ever completes
<manualcrank>
but clojure is fast once it starts up; it's just not fast enough to verify your algorithm is correct on these sites
<LdBeth>
GG
<LdBeth>
But u should always be notified the thing gets verified is the model rather than the actual code
<LdBeth>
There are chances that hardware failure or compiler bugs
<LdBeth>
Also use foreign codes relies on ABI compatibility has potential of bugs
<manualcrank>
every problem is a script that compares your output with the correct output furnished by the problem writer
<LdBeth>
If the output mismatch, there’s high probability something is wrong, but the reverse is not true
test1600 has joined #lisp
<manualcrank>
you mean it's possible an incorrect solution can produce the correct output?
<manualcrank>
the input data sets are designed to test the correctness of your code
<manualcrank>
there are typically man tens of data sets for every problem
<manualcrank>
you can see how your code does for each set individually
<LdBeth>
I mean the possibility of memory leak or none terminating
<manualcrank>
none terminating programs are terminated after they exceed the time limit (1 sec typically)
<manualcrank>
there's also a memory limit, if you leak past it, you're terminated
<manualcrank>
if you leak less, that's fine, the script doesn't know or care
<LdBeth>
What if the program is a compiler that requires long time and a lot amount of space for execution
<manualcrank>
your code isn't analyzed for style, purity, correctness, elegance, etc.
<manualcrank>
a good example would be clojure -- start up time is too long, many TLEs
schweers has joined #lisp
<manualcrank>
it's just not a viable option for competitive programming sites
<manualcrank>
i'd guess 90% of users use C++/Java/Python
<manualcrank>
most problems are just an exercise in applying a known algorithm
hatchback176 has quit [Remote host closed the connection]
Josh_2 has quit [Ping timeout: 246 seconds]
<manualcrank>
identifying the correct string matching algorith, graph algorithm, computational geometry algorithm, etc.
<LdBeth>
I guess most JVM languages takes long to start
libertyprime has joined #lisp
<manualcrank>
it's never the fastest language (every problem has a statistics link) but neither is it the slowest
<manualcrank>
C++ dominates the left hand site of the performance histogram
test1600_ has joined #lisp
hiroaki has quit [Ping timeout: 272 seconds]
<manualcrank>
Java is fast enough though, i mean it doesn't TLE unless your algorithm is wrong
test1600 has quit [Ping timeout: 248 seconds]
<manualcrank>
Lisp is plenty fast too for the overwhelming majority of problems
Oladon has joined #lisp
libertyprime has quit [Ping timeout: 246 seconds]
igemnace has quit [Read error: Connection reset by peer]
igemnace has joined #lisp
<shka__>
from my expirence sbcl is more or less in the same speed category like java
<manualcrank>
mine too. i/o can be a bottle neck though
<ck_>
this is a good opportunity to re-read "Lisp as an Alternative to Java"
<ck_>
or that one --^. thanks, manualcrank. my second link is a follow-up
libertyprime has joined #lisp
<no-defun-allowed>
Thanks.
ltriant has quit [Quit: leaving]
<ck_>
if you like, also take a look at norvig.com/java-lisp.html , which is Peter Norvig's solution to the problem used in the study
beach has quit [Ping timeout: 245 seconds]
nolanv has quit [Ping timeout: 246 seconds]
bgardner has quit [Ping timeout: 246 seconds]
bgardner has joined #lisp
nolanv has joined #lisp
scymtym has joined #lisp
karlosz_ has quit [Quit: karlosz_]
ioa has joined #lisp
<ioa>
good morning
aindilis has quit [Remote host closed the connection]
aindilis has joined #lisp
jprajzne has joined #lisp
beach has joined #lisp
hhdave has joined #lisp
grumble has quit [Quit: indoctrination leads to lethal dedication]
grumble has joined #lisp
bgardner has quit [Ping timeout: 258 seconds]
bgardner has joined #lisp
scymtym has quit [Ping timeout: 248 seconds]
catalinbostan has joined #lisp
elderK has joined #lisp
notzmv has quit [Read error: Connection reset by peer]
manualcrank has quit [Quit: WeeChat 1.9.1]
themsay has quit [Ping timeout: 245 seconds]
defaultxr has left #lisp ["WeeChat 2.5"]
notzmv has joined #lisp
<dmiles>
#S is generally for "structures" .. though this would be OK.. #S(HASH-TABLE :TEST EQL :SIZE 120 :CONTENTS (1 ONE 2 TWO)) Does that mean the HASH-TABLE needs to be a structure-p ?
<jackdaniel>
if hash is printed as #s(hash-table …) then it is a structure
<jackdaniel>
s/hash/hash-table/
<jackdaniel>
if it is printed as something else then it is something else. I think that it is not specified what is a class of hash-table (i.e it may be built-in-class, structure-class etc)
<jackdaniel>
it is only specified, that class precedence list is: hash-table, t
<loke>
About #S “...denotes a structure. This is valid only if name is the name of a structure type already defined by defstruct and if the structure type has a standard constructor function.”
<shka__>
soooo #S is structure unless it is not?
<dmiles>
i was sort of hoping to reuse #S for ptrint readable of standard classes but i suppose i will choose another then
<jackdaniel>
shka__: *no*, #s means structure
<dmiles>
#.(make-instance ... )
<jackdaniel>
hash table are not specified to be printed as #s
<loke>
dmiles: the examples section is non-normative
<loke>
Just because it's in an example doesn't make it right
<dmiles>
*nod*
<jackdaniel>
also, if we believe it, than it would mean: if standardized notation is defined for hash-tables that means that hash tables are structures (what would be conforming)
<dmiles>
so i'd what to do something liek that for *print-readablely* ?
<loke>
dmiles: Yes.
<loke>
*PRINT-READABLY* is not guaranteed to write a readable hashtable. And even if it does, it's not compatible across implementations.
scymtym has joined #lisp
<loke>
It's interesting that SBCL prints a readable hashtable using #. notation
shrdlu68 has joined #lisp
<dmiles>
i am setting up my *PRINT-READABLY* to do as much as it can
jmercouris has joined #lisp
Lycurgus has quit [Quit: Exeunt]
<jmercouris>
is there a way in paredit to transform (("a" "b") ("c" "d")) to (("c" "d") ("a" "b"))?
<loke>
jmercouris: yes.
<jackdaniel>
C-f C- C-M-f C-w C-M-f C-y
<loke>
jmercouris: go to the opening paren in the middle and press M-C-t
<jackdaniel>
C-f C-[space] C-M-f C-w C-M-f C-y
themsay has quit [Ping timeout: 245 seconds]
<loke>
(the cursor should be on the opening paren just before "c"
<jmercouris>
M-C-t works
techquila has joined #lisp
fivo has joined #lisp
<loke>
jmercouris: It's not a paredit function by the way. it work equally well outside parwedit (the function is command-transpose-sexps)
themsay has joined #lisp
<dmiles>
for some objects that i really cant print readably i might do #.(nth 666 *this-instance-instances*)
<jmercouris>
jackdaniel: I don't understand the bindings you've printed "C-f C-"?
<jmercouris>
oh you are highlighting a marked region cutting it ok
<jmercouris>
I see
<jmercouris>
loke: ok, good to know thank you
<fivo>
Hey #lisp
<jmercouris>
hey fivo
<fivo>
Is there something like an indent spec for CL?
<jmercouris>
No, there is not, people use emacs for that
[6502] has joined #lisp
<jmercouris>
there are style guides, but no formal specification
<fivo>
Ok so whatever emacs + slime does is essentially the rule?
<loke>
fivo: Yes
igemnace has quit [Read error: Connection reset by peer]
<loke>
fivo: that, and dont put any closing parens on separate lines. The only valid excuse is if it's a vertical list of objects and the last line ends with a line comment.
[6502] has quit [Quit: Page closed]
igemnace has joined #lisp
<fivo>
I asking because I was wondering how an macro with only a &body argument would be indented.
<jmercouris>
fivo: don't worry so much about indenting and the like
<loke>
fivo: SLIME is clever enough to notice that the macro has a &body argument and indents accordingly
<loke>
&body and &rest are equivalent and the only difference is how it's indented
<jdz>
jmercouris: That's a very bad advice.
m00natic has joined #lisp
<fivo>
here is the specific case I was referring to
<loke>
fivo: if the definition of $ uses an entire &body, then SLIME would not format it like that. But I don't know how it's defined.
<loke>
The typical example of special formatting caused by complex macros is LOOP
<loke>
SLIME has special knowledge of LOOP so that it indents correctly.
slac-in-the-box has joined #lisp
elderK has quit [Quit: WeeChat 1.9]
slac-in-the-box has quit [Read error: Connection reset by peer]
<flip214>
Is there a definition whether (CHANGE-CLASS instance 'new-class :slot "value") has to change the slot's value if instance is already of class 'new-class?
jmercouris has quit [Ping timeout: 268 seconds]
SaganMan has quit [Ping timeout: 272 seconds]
heisig has joined #lisp
makomo has quit [Ping timeout: 246 seconds]
<beach>
flip214: I believe the standard is clear.
<flip214>
beach: so you think a CHANGE-CLASS to the same class is _defined_ to be a no-op too? Thanks a lot.
<beach>
flip214: Unless I read it wrong, the value is not changed.
<flip214>
yeah, that's how I read it too.
<flip214>
I'm not sure about "After completing all other actions, change-class invokes update-instance-for-different-class"
<flip214>
it's called "for different class", so should it be called for the same class?
<beach>
I don't see anything specifically said about that. You may have to consider both possibilities.
<flip214>
Well, in absence of a CDR the behaviour is undefined, and so I can just wish for the more performant, right? ;)
Arcaelyx has quit [Ping timeout: 272 seconds]
donotturnoff has joined #lisp
drot has joined #lisp
cpc26 has quit [Remote host closed the connection]
<fiveop>
I need a name for a function that closes over a function adding a number of ignored arguments to the back of the argument list. Sort of an inverse-curry.
<shka__>
fiveop: not in the standard
<Bike>
that's why they're asking for a name
<shka__>
ah
<shka__>
ok
<edgar-rft>
inverse-curry -> yrruc
<Bike>
i don't know what i'd call it though. morearityify
<shka__>
fiveop: discard-arguments
<fiveop>
going by everyday language with-ignored-args would be good, but would not match the common usage of the with-.. pattern
Inline has quit [Read error: Connection reset by peer]
warweasle has quit [Quit: gotta go...work.]
<Bike>
arguments-ignorer
<schweers>
adapter?
<fiveop>
add-ignored-arguments
<schweers>
strip-arguments
Arcaelyx has quit [Quit: Arcaelyx]
<grewal>
api-conformer
Inline has joined #lisp
troydm has quit [Ping timeout: 248 seconds]
saravia has joined #lisp
HDurer has joined #lisp
dale_ has joined #lisp
dale_ is now known as dale
fivo has quit [Ping timeout: 252 seconds]
fivo has joined #lisp
edgar-rft has quit [Quit: Leaving]
troydm has joined #lisp
mindCrime has joined #lisp
manualcrank has joined #lisp
kushal is now known as iamsayan2
iamsayan2 is now known as kushal
FreeBirdLjj has joined #lisp
fivo has quit [Ping timeout: 258 seconds]
v88m has quit [Ping timeout: 248 seconds]
iovec has quit [Quit: Connection closed for inactivity]
shka_ has joined #lisp
shrdlu68 has quit [Ping timeout: 248 seconds]
vaporatorius has joined #lisp
fivo has joined #lisp
Jesin has quit [Quit: Leaving]
<TMA>
fiveop: haskell has 'const' for something similar. (const .) is for 'ignore second argument', ((const .) .) is for 'ignore third'... there are no variadics in haskell though
jackhill has quit [Quit: leaving]
jackhill has joined #lisp
v88m has joined #lisp
<TMA>
fiveop: in general, keeping M and ignoring N arguments is constructed by composing N consts and then wrapping in M ( .)'s
Jesin has joined #lisp
<TMA>
fiveop: so something like const-m-n or keep-discard?
<TMA>
naming things is hard
gxt has quit [Ping timeout: 256 seconds]
gxt has joined #lisp
iskander has quit [Ping timeout: 248 seconds]
Inline has quit [Read error: Connection reset by peer]
pjb has quit [Read error: Connection reset by peer]
beach has quit [Ping timeout: 248 seconds]
z3t0 has quit [Ping timeout: 248 seconds]
iskander has joined #lisp
schweers has quit [Ping timeout: 248 seconds]
beach has joined #lisp
cosimone has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
sjl has joined #lisp
fivo has quit [Quit: WeeChat 1.9.1]
ebrasca has quit [Read error: Connection reset by peer]
keep_learning has quit [Remote host closed the connection]
donotturnoff has quit [Ping timeout: 244 seconds]
v88m has quit [Ping timeout: 245 seconds]
iovec has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
shangul has left #lisp ["3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067"]
pankajgodbole has quit [Ping timeout: 272 seconds]
xkapastel has joined #lisp
duncan has left #lisp [#lisp]
Jesin has quit [Quit: Leaving]
Jesin has joined #lisp
orivej has joined #lisp
hhdave has quit [Quit: hhdave]
rippa has joined #lisp
donotturnoff has joined #lisp
donotturnoff has quit [Read error: Connection reset by peer]
donotturnoff has joined #lisp
donotturnoff has quit [Ping timeout: 272 seconds]
moldybits has quit [Quit: WeeChat 2.4]
moldybits has joined #lisp
linli has joined #lisp
orivej has quit [Ping timeout: 248 seconds]
linli has quit [Ping timeout: 272 seconds]
m00natic has quit [Remote host closed the connection]
<fiveop>
TMA: but nothing is (necessarily) constant. it's just that the arguments passed by whatever API the function is passed to, are not of interest.
varjag has joined #lisp
donotturnoff has joined #lisp
<karlosz>
fiveop: curry-ignored
dyelar has joined #lisp
sjl has quit [Ping timeout: 245 seconds]
papachan has quit [Quit: Saliendo]
dyelar has quit [Client Quit]
dyelar has joined #lisp
rumbler31 has joined #lisp
Lord_of_Life_ has joined #lisp
equwal has joined #lisp
Lord_of_Life has quit [Ping timeout: 245 seconds]
Lord_of_Life_ is now known as Lord_of_Life
sjl has joined #lisp
Josh_2 has joined #lisp
xvx has joined #lisp
<flip214>
I just shot my swank connection... close-connection: The value 24009213 is not of type (UNSIGNED-BYTE 24) when binding COMMON-LISP:LENGTH ...
<flip214>
more than 16MB in a single swank result, that's a first for me
simendsjo has joined #lisp
xvx has quit [Quit: xvx]
bexx has joined #lisp
xvx has joined #lisp
xvx has quit [Client Quit]
cosimone has quit [Quit: WeeChat 2.4]
v88m has joined #lisp
srji has joined #lisp
rumbler31 has quit [Remote host closed the connection]
<srji>
im having a small lisp programm from the book "land of lisp" https://pastebin.com/WkJYcUGV | im trying to execute it with `clisp guess_my_number.lisp` but nothing happens?!
<srji>
do i miss something?
ebrasca has joined #lisp
<Bike>
your program does no output, as far as i can see
<Bike>
so nothing is output
<srji>
seems legit
<srji>
at first i was calling it from the repl
<srji>
and i got output
<srji>
i just expected the same behavior
<srji>
ty
<Bike>
that's the "p"rint part of "repl" working for you
<Bike>
but if you just throw clisp a file there is no repl
<srji>
i got it now :D
khisanth_ has quit [Ping timeout: 246 seconds]
sauvin has quit [Ping timeout: 248 seconds]
khisanth_ has joined #lisp
Zipheir has joined #lisp
Zipheir has left #lisp [#lisp]
nanoz has joined #lisp
dvdmuckle has quit [Quit: Bouncer Surgery]
Necktwi has joined #lisp
dvdmuckle has joined #lisp
vlatkoB has quit [Remote host closed the connection]
xvx has joined #lisp
vlatkoB has joined #lisp
beach has quit [Ping timeout: 245 seconds]
Jesin has quit [Quit: Leaving]
Jesin has joined #lisp
xvx has quit [Quit: xvx]
gravicappa has quit [Ping timeout: 246 seconds]
ebrasca has quit [Remote host closed the connection]
fortitude has quit [Remote host closed the connection]
edgar-rft has joined #lisp
Inline has joined #lisp
vlatkoB has quit [Remote host closed the connection]
Krystof has quit [Ping timeout: 244 seconds]
nanoz has quit [Ping timeout: 245 seconds]
CrazyEddy has quit [Ping timeout: 248 seconds]
Krystof has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
charh has joined #lisp
shka_ has quit [Ping timeout: 258 seconds]
ober has joined #lisp
orivej has joined #lisp
donotturnoff has quit [Ping timeout: 248 seconds]
CrazyEddy has joined #lisp
wilfredh has quit [Quit: Connection closed for inactivity]