<aeth>
None of this that we've been talking about is strictly necessary with a sufficiently restrictive syntax
ym555 has quit [Ping timeout: 246 seconds]
zotan has quit [Ping timeout: 252 seconds]
<aeth>
e.g. you could require the user write things like "foo 42\nbar 43\n" (replace \n with newlines in your head; IRC is limited to one-line-per-message) in which case you don't technically need any intermediate strings.
<vms14>
well I'll go for strings them, and study that code later
<vms14>
thanks for the help
<vms14>
see you guys
<vms14>
<3
<aeth>
bye
vms14 has quit [Quit: WeeChat 2.3]
ym555 has joined #lisp
zotan has joined #lisp
<aeth>
(I guess reading wouldn't be unsafe if CL's read wasn't so powerful.)
<pjb>
and macros wouldn't be unsafe (and worse, unhygienic) if CL's macros weren't so powerful.
<pjb>
and eval wouldn't be unsafe if CL's eval wasn't so powerful.
<pjb>
CL is too powerful! :-)
wxie has joined #lisp
<aeth>
I guess my point is that for untrusted user input you don't want power, so you wind up having to write your own (or use a library) functionality. Shortcuts here are bad.
<aeth>
read-line vs. read-char is up to you (unless you *need* to not hang, then you have to use read-char-no-hang)
dddddd has quit [Remote host closed the connection]
<aeth>
read-char/read-char-no-hang will probably use a FSM.
chewbranca has quit [Ping timeout: 264 seconds]
pent has quit [Ping timeout: 252 seconds]
rvirding has quit [Ping timeout: 252 seconds]
tehidiot has quit [Ping timeout: 252 seconds]
chewbranca has joined #lisp
adulteratedjedi has quit [Ping timeout: 264 seconds]
patlv has joined #lisp
tazjin has quit [Ping timeout: 264 seconds]
igemnace has quit [Quit: WeeChat 2.4]
CrazyEddy has quit [Remote host closed the connection]
chewbranca has quit [Ping timeout: 264 seconds]
smasta has joined #lisp
chewbranca has joined #lisp
tazjin has joined #lisp
rvirding has joined #lisp
tehidiot has joined #lisp
adulteratedjedi has joined #lisp
pent has joined #lisp
patlv has quit [Ping timeout: 252 seconds]
cyberoctopi has joined #lisp
myrkraverk has joined #lisp
estest has joined #lisp
CrazyEddy has joined #lisp
Achylles has quit [Remote host closed the connection]
Lord_of_Life has quit [Ping timeout: 250 seconds]
Lord_of_Life has joined #lisp
cyberoctopi has quit [Ping timeout: 264 seconds]
patlv has joined #lisp
patlv has quit [Ping timeout: 268 seconds]
techquila has joined #lisp
techquila has quit [Remote host closed the connection]
techquila has joined #lisp
smasta has quit [Ping timeout: 252 seconds]
smasta has joined #lisp
python476 has joined #lisp
cyberoctopi has joined #lisp
__jrjsmrtn__ has quit [Ping timeout: 252 seconds]
shifty has quit [Ping timeout: 252 seconds]
nowhere_man has quit [Ping timeout: 252 seconds]
t58 has quit [Quit: Night All]
ym555_ has joined #lisp
ym555 has quit [Read error: Connection reset by peer]
jb__ has joined #lisp
okeg has quit [Quit: WeeChat 1.6]
nanoz has joined #lisp
Arylla has joined #lisp
jb__ has quit [Quit: leaving]
<Arylla>
Is there any way to set up SBCL so that it's possible to (attempt to) recover from heap exhaustion by aborting to the REPL?
<Arylla>
(or from just having a relatively low amount of heap space; I'm okay with having to abort while there's still some heap left)
python476 has quit [Ping timeout: 246 seconds]
dale has quit [Quit: dale]
techquila has quit [Ping timeout: 250 seconds]
atgreen_ has quit [Remote host closed the connection]
atgreen_ has joined #lisp
remexre has joined #lisp
<remexre>
coming from Scheme and Haskell (as my most lisplike languages), what does Common Lisp have over e.g. Haskell?
<remexre>
(specifically, I'm a bit afraid of losing type-safety)
<Arylla>
Common Lisp is quite similar to Scheme in a lot of ways, so if you're familiar with the comparative advantages of Scheme and Haskell, you'll probably find the comparison between CL and Haskell similar
<remexre>
okay, the lisp-2-ness of CL really put me off
<remexre>
also, minor inflammatory statement, a large part of my attraction to scheme is that guile is installed on school machines and ghci isn't
<remexre>
like I guess my real question is
<remexre>
how do you make large software without types
<remexre>
I've worked on a python project from hell before, which pretty much scared me into types-for-everything-land
<estest>
remexre: Common Lisp has types and there are a number of multi million line projects created with it.
<remexre>
er, static types?
<remexre>
and I know there are, I mean like...
<remexre>
what mental/organizational/technica tools help you do so
<Arylla>
I think that a large part of it is macros and the domain-specific-languageiness of Lisp
<estest>
There are a lot... one that might be up your ally is simply declaring your types. SBCL will give you warnings at compile time when it detects type issues.
<Arylla>
yeah, compiler type-checking will help too
<Arylla>
when you look at any particular function or something, which is written with macros, it's
<Arylla>
usually expressed in terms of what the person meant, rather than in terms of whatever constructs the language already supports
<Arylla>
so that way, it's a lot easier to keep track in one's head of what code is actually trying to do, so a strong, static type system is somewhat less necessary
<Arylla>
if this makes any sense at all
<remexre>
doesn't this break down when you try to mix DSLs?
<remexre>
I'm somewhat used to DSLish programming from Haskell
<remexre>
but there, there are all sorts of problems getting them to work together (e.g. embedding code in another DSL within some place in yours)
<remexre>
since the inner DSL might be expecting certain invariants to be true that are broken by the outer one
<Arylla>
I'm not completely sure; I haven't had a whole lot of issues with this in Lisp, but then again I've never done very much DSL-based programming in Haskell
<Arylla>
or really run into such problems before, so it's totally possible that I just don't have that experience
<Arylla>
also if you want to learn about the details of the type system, the Hyperspec is probably the best resource: http://clhs.lisp.se/Body/04_.htm
<remexre>
afaik the canonical example is that nondeterministic choice doesn't compose with pretty much any other control flow effect
<p_l>
remexre: remember that static/dynamic and strong/weak typing are orthogonal axes
<remexre>
er yeah, I mean dynamic typing, not weak
<estest>
remexre: The second reference is better for understanding the type system, and the hyperspec will be the most standard-compliant reference... SBCL goes beyond the standard with its type inference (and use of type information to compile faster code). I believe it's based on Kaplan-Ullman inference, like this: https://web.archive.org/web/20181107011706/http://home.pipeline.com/~hbaker1/TInference.html
<p_l>
remexre: Common lisp is strongly-typed but with static analysis being, unfortunately, mostly an optimization method
<remexre>
estest: okay, thanks, I'll give that a read!
<p_l>
CMUCL pioneered advanced static type derivation in Common Lisp, SBCL derives from CMUCL thus also having it
<p_l>
one of the problems with CL type system is that it's explicitly turing complete, which means you can't run exhaustive static analysis
<p_l>
(which harks back to the original problem for which lambda calculus was invented, btw)
<remexre>
how tractable-in-practice does it tend to be?
<remexre>
e.g. rust and haskell's type systems are turing-complete, but it's pretty rare to infinite-loop the typechecker there
<p_l>
remexre: Depends on how you code. For a lot of applicationss, heavy use of classes makes things easier, as classes are also types
<p_l>
but you can make a custom function as oracle on whether something satisfies a type
igemnace has joined #lisp
<p_l>
and SUBTYPEP is apparently complex enough to get recent PhD papers
<remexre>
oh, ouch
<p_l>
(and possibly a victim of "lost in email" during language design (I kid you not)
<Arylla>
remexre: hmm I haven't heard much about that before; would you mind linking a resource of some sort which describes the difficulties with nondeterministic choice and other control flow?
<p_l>
it's however easy to make them form assertions in your code, and debugging facilities even on poorest CL environments are pretty great in comparison
<remexre>
and the free monad is super-nice for being able to write your logic in your DSL, then test it against multiple implementations of the DSL itself
<p_l>
remexre: I just find it funny that the biggest hack of Haskell became it's most recognizable feature
<remexre>
:P fair
<p_l>
though I'll admit that I learnt of how hacky Monads are in uni, few years after I started any experience with Haskell
<Arylla>
hmm usually in Lisp different macros and other such constructs do tend to play nicely together, as a result of the main method of DSL creation involving substituting in forms provided by the user
<p_l>
Arylla: the moment you stop pushing for mathetically pure functions, Monad stops making sense
<Arylla>
p_l: huh? what's this in response to?
<p_l>
ahh, commenting on DSL and Monads :D
Oddity has quit []
<Arylla>
oh heh ok
<Arylla>
and also, macros also allow you to do the part where you write your logic in your DSL and test it against multiple implementations
<remexre>
would that be just conditionally defining some macros?
<Arylla>
for a big example, look at CLIM (Common Lisp Interface Manager); both McCLIM, an open-source implementation, and implementations derived from Allegro CLIM have the exact same semantics
<Arylla>
because they define macros with the same names that do the same things
<Arylla>
so switching from one to the other is as simple as just importing a different one
Bike has quit [Quit: Lost terminal]
<p_l>
Also, CL macros are essentially normal functions that just run at different "time"
<p_l>
CL has a bunch of "times" that a function might run
smasta has joined #lisp
<remexre>
ok wow the clim screenshot on wikipedia is like
<Arylla>
yeah they're basically code that generates code; think more "Template Haskell" than "C macros"
<p_l>
the main difference in contract of MACRO-FUNCTION from FUNCTION is that MACRO-FUNCTION gets arguments unevaluated
<Arylla>
except that they're easier to write than Template Haskell, owing to the simpler AST of Lisp
Oddity has joined #lisp
<remexre>
yeah, I only dipped my toe into TH before running for the hills because of the complexity of the AST :P
<remexre>
at this point I do things at runtime and spam INLINE and RULES annotations when performance matters
<Arylla>
yeah; Lisp macros don't suffer from those issues as much because of the characteristics of Lisp itself
* Arylla
has also briefly gazed upon Template Haskell and realized that it was not for me
<nisstyre>
Arylla: the reason Template Haskell is harder to understand is because of the type system I think
momozor has joined #lisp
<Arylla>
nisstyre: it would make sense that that's part of it, but I'm sure that the AST isn't helpful either
<nisstyre>
yeah it doesn't have s-expressions or anything obviously
<nisstyre>
arguably some things you would need macros for aren't an issue though
<nisstyre>
because of the lazy evaluation
atgreen_ has quit [Ping timeout: 264 seconds]
<Arylla>
that's true, although macros (unlike lazy evaluation) don't necessarily interact terribly with all impure functions
<Arylla>
(and while monads do exist and work, they're more complicated to understand and at times to use imo)
gravicappa has joined #lisp
<remexre>
I'm tbh big on having algebraic effects (like in http://www.eff-lang.org/ ) instead of monads-as-a-hack-for-effects
<remexre>
but it looks like deriving a type system where effects are statically checked is somewhat difficult
<Arylla>
I've never heard of algebraic effects before
<remexre>
as far as I know they're pretty niche
vlatkoB has joined #lisp
patlv has joined #lisp
<Arylla>
huh; reading through the "Print" example at least reminds me quite strongly of CL's condition system
<remexre>
I've played around with trying to fit a type system for these, and it looks like it ends pretty poorly
<remexre>
yeah, I'm mainly looking into CL because of conditions
<Arylla>
yeah they're pretty neat
caltelt_ has joined #lisp
<remexre>
the big problem I've found is that you usually end up wanting some sort of subtyping for the "set" of effects you have
<remexre>
"set" being in quotes because you also want a partial order
<remexre>
because if you have e.g. a State effect and an Exception effect, the order in which they're handled makes a big difference
alca has joined #lisp
patlv has quit [Ping timeout: 264 seconds]
<aeth>
remexre: If you're willing to be a heretic with non-idiomatic style you can have some degree of static typing in Common Lisp (in addition to the dynamic typing, making it gradual typing), at least in SBCL
rwlisp has quit [Quit: rwlisp]
<Arylla>
ahh yes partial order would be kind of hard to achieve in a traditional type system
<aeth>
remexre: Your toolbox is fairly limited for CL "static typing". You have type declarations (though macros can make the syntax much nicer), :type in defstruct, and :element-type in arrays. Portably, only :element-type must be respected, and only for characters and bits. element-type is also only for simple things like numbers and characters, e.g. (unsigned-byte 8) or octet (a common deftype rename for that) is pretty common
<Arylla>
I almost think that something interesting would be to have types be data and have the operations on the types (including checking their equality) just be expressed in the same language as the code itself
<p_l>
well, that's for portable treatment
<remexre>
aeth: yeah, that got mentioned a bit above; I was wondering more about how people "cope" with not having it
<p_l>
implementations can extend it
<remexre>
Arylla: yep, that's dependent types!
<aeth>
remexre: The strongest static checking is limited to being within a function, but a lot of it also can take place within a file. sb-ext:*derive-function-types* tells the SBCL compiler to assume that a function type never changes so it can make even more assumptions (unfortunately, you can't do much working with function types)
<Arylla>
is it? I thought dependent types were more about having the type of a variable or whatever depend on the data that the variable contains
<aeth>
It also can make static type assumptions with stuff in the COMMON-LISP (CL) package, since those can't be redefined. so e.g. +
<p_l>
remexre: I'd say that protocols, which exist mostly by social convention though, are pretty common approach
<p_l>
you define a set of operations and arguments etc.
<p_l>
and use that to organize a piece of functionality
<remexre>
Arylla: yes, but they way in which they depend ends up being value-level functions in all the dependent languages I've seen
smasta has quit [Ping timeout: 250 seconds]
<aeth>
remexre: Oh and you also have :type in defclass, btw, but that unfortunately is even less respected than :type in defstruct so I made my own metaclass to enforce checking of a :checked-type slot
<remexre>
though equality checking types isn't a common feature, because you lose parametricity (aka theorems for free)
smasta has joined #lisp
<aeth>
remexre: You can do a lot of verification within macros, and the type system is fairly decent for CHECK-TYPE or declarations or typed slots... where supported. Not Haskell-level, but it supports stuff like (integer 4 37) and (or null integer)
<remexre>
p_l: hm, ok; is the approach of having laws alongside protocols (e.g. if a type is foldable, it should satisfy foldr f z t = appEndo (foldMap (Endo . f) t ) z) common, or does having side-effects pervasively reduce that
<p_l>
Not sure how to transcribe this into CL
<aeth>
The real weakness is in typed collections. Arrays are stuck with simple element-types, hash-tables are stuck generic, and if you want typed conses (for e.g. linked lists that can only hold a certain type in the car) you have to define your own struct to do that with :type in its slots for about a 30% performance loss
<p_l>
I mean, ultimately it's possible, that's how you got Haskell, but not sure
<aeth>
Another big weakness is you have elaborate ftypes (in some implementations) but no real way to access those.
<remexre>
p_l: sorry, that law was a bit pathological, I wanted a non-mathy name for the interface/protocol :p
<p_l>
aeth: AFAIK only linked lists are truly limited in that, the rest can be done in compliant implementation
<remexre>
aeth: ftype == function type?
<aeth>
remexre: yes, in this case, it's the type of its input and its return value(s)
<remexre>
p_l: a better example is that if a type is a functor, it must respect fmap id == id and fmap (f . g) = fmap f . fmap g, where id is the identity function and . is function composition
<aeth>
remexre: You can declare it, and it will be used for checking (perhaps even at compile time, at least in SBCL with sb-ext:*derive-function-types* as T), potential optimizations, etc., but there's no real way to access it
<remexre>
huh, ok
<aeth>
remexre: you can add a lot of your own compile-time validation in macros, though.
smasta has quit [Ping timeout: 252 seconds]
<remexre>
like by adding runtime type checks, or by writing a typechecker as a macro, or...?
<Arylla>
remxre: I feel like this type system I'm thinking up would work rather nicely in Lisp, which already doesn't really have parametric polymorphism per se
theemacsshibe has joined #lisp
<theemacsshibe>
Good afternoon
<aeth>
remexre: You can create a foo with a define-foo instead of directly, and as long as the values it uses are simple literal values like 42 or "hello" (probably not even constants) then you can check those things at compile time during macro expansion. Basically, those values need to be available at the time.
<remexre>
ah, ok
<aeth>
remexre: Clever use of metadata could overcome some of the limitations, though
<aeth>
s/probably not even constants/probably not even constant variables like +foo+/
<Arylla>
oh uh I'm not sure if anyone saw but I asked an SBCL question earlier; is there a way to make SBCL abort back to the REPL before it runs out of heap?
<aeth>
You can also do a lot of compile time typechecks (implementation-specific, obviously) with type declarations as long as it can be encoded in the type system. Stuff like (defun foo () (the (unsigned-byte 8) 31487)) being caught by SBCL
<Arylla>
e.g. when it's running fairly low on heap but still has enough to invoke the ABORT restart
<aeth>
remexre: e.g. (with-compilation-unit () (defun foo () 31487) (defun bar (n) (declare ((unsigned-byte 8) n)) (* n 2)) (defun baz () (bar (foo)))) ; this is caught in SBCL at compile time as long as it's in the same compilation unit... that wrapper is so it works in the REPL and isn't needed if they're in the same file
<aeth>
It derived the return type of foo, accepted the declaration for the return type of bar, and then in baz notes that foo's type is incompatible with bar's type.
<remexre>
hm, does that work for cases where foo outputs a more complex expression?
rippa has joined #lisp
<aeth>
p_l: Afaik, conses can have types, but the way they're declared makes it look like it would be O(n) to verify, whereas a struct version would only be O(1) since you'd only have to verify the first cons, since the cdr slot's type would be the new cons struct itself
<p_l>
aeth: individual conses yes, but you can't tag individual conses
<aeth>
(this is assuming a linked list cons, a tree cons is a bit trickier since it would be (or null the-type-to-store the-struct-itself) for both the car and cdr
<aeth>
)
aindilis has quit [Ping timeout: 252 seconds]
moldybits has quit [Quit: WeeChat 2.4]
<aeth>
remexre: sometimes yes, sometimes no, e.g. it doesn't catch it when I replace 31487 with (random 31487) even though it has the same sort of issue there in terms of foo's return type. It normally catches it, though, and you can declaim ftype the rest of the time.
<aeth>
SBCL is normally really good at deriving the return type. You will have to declare the input types every time, though.
<remexre>
okay
dale has joined #lisp
<aeth>
You can recompile functions one at a time but SBCL assumes that you will recompile a file at a time, so recompiling just one function can sometimes cause issues with heavily declared functions if it inlines too many assumptions. Especially e.g. something that returns a constant string "hello".
<aeth>
Change that to "Hello, world!" and you'll get a surprise runtime type error because it essentially wrapped all calls to foo in (the (simple-array character (5)) (foo))
<remexre>
oof, okay
<aeth>
It's also limited to functions that it assumes cannot change (mostly CL built-ins) and functions in the same file, unless you do the non-standard behavior with sb-ext:*derive-function-types* that makes it assume function types won't change.
<aeth>
This is also basically just SBCL. Other implementations have some degree of this, but nowhere near as much as SBCL
aindilis has joined #lisp
karlosz has quit [Quit: karlosz]
<aeth>
It's an amazing type system for a language that's dynamically typed, though. Compare this to TypeScript where you have "number" and "string" and "boolean"
<remexre>
yeah, I tried typescript for about a month at $DAYJOB
momozor has quit [Quit: Leaving]
<remexre>
was distinctly unhappy with its typesystem :/
pankajgodbole has joined #lisp
dddddd has joined #lisp
cyberoctopi has quit [Ping timeout: 264 seconds]
<theemacsshibe>
kinda have to deal with it when until recently all JS numbers were floats
<aeth>
CL has a much more solid foundation as far as types go
<theemacsshibe>
but then there's no ratios, reduced precision floats (JS numbers are doubles?) or complex numbers still
<theemacsshibe>
if there were circular type specifiers, you could express typed conses among other things but i understand that's a bit much for implementors
<aeth>
You'd probably want separate types for conses that hold a certain type, immutable versions of various data structures, and arrays that compactly hold things too complex for :element-type (although you could still just add type checking to regular specialized arrays)
<aeth>
Probably a few other areas that are missing in the standard language that would be nice to have.
andrei-n has joined #lisp
<aeth>
Something more important is probably standardizing various non-standard parts of the condition system, especially which things various standard macros/functions like destructuring-bind raise/throw/whatever-the-correct-term-is.
Ukari has quit [Remote host closed the connection]
karlosz has joined #lisp
gravicappa has quit [Ping timeout: 246 seconds]
<beach>
Good morning everyone!
<aeth>
good morning beach
<aeth>
beach: What's your view of "gradual typing" in CL?
<beach>
I don't know how to answer that question. Can you be more specific?
<aeth>
beach: adding type declarations, :type to slots, etc.
<beach>
I usually don't. At least not early on in a project.
cyberoctopi has joined #lisp
<jeosol>
aeth; for most of my defclass definitions, I normally add those, but if only as a form of documentation
<aeth>
well, yes, that's one advantage... the docstrings got way simpler
<jeosol>
they aren't enforced right or check?
<aeth>
I use my own metaclass to enforce it, with :checked-type
<aeth>
;type is only enforced in certain optimization levels on some compilers
<jeosol>
aeth: very nice
<jeosol>
so will it trigger an error/warning if a slot is (re)assigned a wrong type?
<aeth>
it's an assert
<aeth>
I couldn't use check-type, unfortunately
<jeosol>
ok
wxie has quit [Quit: Bye.]
wxie has joined #lisp
moldybits has joined #lisp
ggole has joined #lisp
<aeth>
I should probably make it its own microlibrary because it's so standalone
<aeth>
I'm not a big fan of single-file libraries, though
patrixl has quit [Remote host closed the connection]
<theemacsshibe>
make the metaclass one library and the methods another
eschatologist has quit [Excess Flood]
<theemacsshibe>
[npmjs.com would like to know your location]
<PuercoPop>
that would explain why they mention the idiom (setq x (prog2 0 y (setq y x))) instead of (setq x (prog1 y (setq y x))). Fortunately CL has rotatef
<theemacsshibe>
well, I remember a lambda.txt fortune which was a hack for swapping variables used prog2 and a dummy value in place of prog1
<vms14>
I really like the fact format can write directly to a string since you can use all the power format has
<vms14>
I like it for the html generator I'm doing, I have meta body head style arrays and I use format to add stuff
<vms14>
then I add all those arrays to the html one
<vms14>
this is nice, because it lets you separate text, I can add meta and style to head and then add head to html
nanoz has quit [Ping timeout: 264 seconds]
Arylla has quit [Ping timeout: 250 seconds]
<vms14>
btw I should make arrays from a fixed size instead of 0?
<vms14>
(make-array 0 :adjustable t) If I know the array will grow, shouldn't be better to (make-array 100 :adjustable t) ?
<vms14>
I suppose it's more expensive to make the array grow than give it an initial size
<grewal>
I wouldn't worry about it yet
<vms14>
yeah, it's not time to worry about this
<vms14>
but it's fine to know it
atgreen_ has joined #lisp
<puchacz>
hi, does anybody know if there are any plans to make ABCL work with Java > 8 please? I use ABCL at work, but I have no skills to tinker with internals....
<puchacz>
they changed something in Java 9 around classloaders and setAccessible for what I read
<puchacz>
(at work to run my personal "scripts" interactively around our application)
Essadon has joined #lisp
Essadon has quit [Max SendQ exceeded]
Essadon has joined #lisp
refpga has joined #lisp
scymtym has joined #lisp
<easye>
puchacz: Yes, I have patches to make ABCL work with Java 11.
<mfiano>
Well, nevermind. It appears the ASD specification for the file load order changed in a recent commit and I hadn't noticed.
psyklax has joined #lisp
libertyprime has quit [Ping timeout: 264 seconds]
warweasle has joined #lisp
SaganMan has quit [Quit: WeeChat 1.6]
<puchacz>
easye: that's fantastic news! thanks a lot :-)
patlv has quit [Ping timeout: 268 seconds]
<puchacz>
and as we are talking about corporate environment, I had to download quicklisp libraries manually, because we have a proxy with password - of course :(
<puchacz>
last time I checked it was impossible to use quicklisp via proxy that requires authentication
vms14 has joined #lisp
<vms14>
there is any difference between eq and char= while comparing characters?
<vms14>
in performance, correctness, or whatever
<grewal>
yes, eq is implementation-dependent
<grewal>
So don't use it
<vms14>
just for symbols then
<vms14>
ty grewal
<vms14>
btw I had an idea time ago and since you're lispers you can implement easily new ideas to the language
<vms14>
I'd like to create a toy language, and one of the ideas I had was the statement "when"
<vms14>
but not like lisp one, a concurrent one
<vms14>
like when a is 0 print "a is 0"
<vms14>
and whenever in your program the variable a goes to 0 that print will be executed
<ggole>
eq is useful for more than symbols, eg, whether two mutable things are the same one
<Bike>
that's "constraint programming", vms14
rumbler31 has joined #lisp
<vms14>
in lisp should be easy to do that since you can make a repl just using loop eval print and read
<vms14>
Bike: idk what you mean
<vms14>
but I think is a nice feature and I ask to myself why we don't have it yet
<ggole>
char= will check that its arguments are of type character as well
<vms14>
hmm
<vms14>
what about prolog vs lisp?
<Bike>
what about it?
<vms14>
and also about prolog vs lisp in ai?
<grewal>
vms14: What are you asking?
rumbler31 has quit [Ping timeout: 252 seconds]
<vms14>
really I want to ask what you think about prolog, but this is offtopic, so nvm xD
<vms14>
but it has lisp similar stuff?
shka_ has quit [Read error: No route to host]
<vms14>
and it's better for metaprogramming than lisp?
<vms14>
a user told me that with prolog was easier because you just need to stablish a grammar
<puchacz>
vms14: maybe check the PAIP book, it has a working prolog-in-lisp example
<puchacz>
with use cases
<vms14>
but I think lisp is a very nice option to do this kind of work
<vms14>
I mean as a parser/transpiler or an entire compiler
<vms14>
puchacz: I have the book and there is a guy who said if I read the PAIP and the pragmatic programmer book it will make me a good programmer
<vms14>
but also I'd like to read the Onlisp book
<vms14>
I guess this is where you learn what paul tries to say in beating the averages
<vms14>
and that it's strongly related with the "enlightenment" people say lisp will give you once you understand it
<grewal>
vms14: Possibly, but unlikely. You first have to program before you can be a good programmer. Reading a lot of books isn't programming
<vms14>
what do you think about this "enlightenment"
<vms14>
I'm not able to say I've seen any light, but I guess from the bit I have tried lisp it's right
<ggole>
Prolog has good support for metaprogramming. Dunno about 'better'.
<vms14>
also I guess part of that enlightenment is related with functional programming, but not's all
shka_ has joined #lisp
t58 has quit [Quit: rebooting...]
<vms14>
grewal: this is why I'm writing shit code
<vms14>
xD
<vms14>
but to write code you need to learn first, so you need to read and practice what you've read
<vms14>
also I think part of the enlightenment is about abstraction
<grewal>
vms14: yes, reading those books is a good first step. But that's all it is -- a step
<vms14>
and this is why is related with functional programming
<vms14>
since the function is the first building block of abstractions
svillemot has joined #lisp
t58 has joined #lisp
psyklax has quit [Read error: Connection reset by peer]
scymtym has quit [Remote host closed the connection]
scymtym has joined #lisp
orivej has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
<p_l>
puchacz: what kind of proxy?
<p_l>
puchacz: there are some proxies you can run locally which will wrap your connections in authorization
makomo has joined #lisp
<makomo>
does a non-destructive version of REMF exist?
amz3 has left #lisp ["WeeChat 2.2"]
<Bike>
remprop... ish.
<makomo>
ah, ALEXANDRIA:REMOVE-FROM-PLIST
<makomo>
yeah, REMPROP is lame because it takes a symbol :(
shifty has joined #lisp
q3d has joined #lisp
<puchacz>
p_l: not sure, but I'd rather just keep my username and password in config file than install yet another piece of software, as corporate police might get me eventually
<puchacz>
in java eclipse there is a setting for network proxy
<p_l>
puchacz: asking because I used to deal with Windows ISA proxy (which used non-standard authorization) and had to run local proxy to add credentials to all connections because only IE understood it
<puchacz>
p_l: the ideal situation would be to have quicklisp ask me for auth each time I download something
orivej has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
nowhere_man has joined #lisp
orivej has quit [Remote host closed the connection]
<remexre>
pjb: No, because I'm not passing or returning types in C :P
orivej has joined #lisp
nowhere_man has quit [Ping timeout: 250 seconds]
catchme has joined #lisp
rumbler31 has joined #lisp
terpri has quit [Remote host closed the connection]
terpri has joined #lisp
trafaret1 has joined #lisp
cyberoctopi has joined #lisp
lumm has quit [Quit: lumm]
lumm has joined #lisp
Ukari has quit [Ping timeout: 255 seconds]
Ukari has joined #lisp
rumbler31 has quit [Remote host closed the connection]
ravndal has quit [Quit: WeeChat 2.4]
shifty has quit [Ping timeout: 255 seconds]
kajo has quit [Ping timeout: 264 seconds]
cyberoctopi has quit [Ping timeout: 264 seconds]
<vms14>
Prolog has a mechanism that works much like macros in Lisp. In fact, macros are a lot easier to write in Prolog for several reasons. For example, you do not have to quote Prolog code when reasoning about it or generating it, and you cannot accidentally run into name clashes with different variables.
<vms14>
how much this is right?
fivo has joined #lisp
<vms14>
are powerful like lisp ones?
<vms14>
lol there is a pun in this paragraph
<vms14>
This simplicity is the main reason why Prolog programmers are not as hysteric about this feature as several other language communities.
<vms14>
xD
<makomo>
vms14: i haven't used prolog much but this sounds interesting. does the author give any examples? what's the source?
<makomo>
hm, sadly no explicit examples are given, but in lisp you don't have to quote arguments to macros either. it's done automatically.
<makomo>
maybe someone else knows what example the author had in mind
cyberoctopi has joined #lisp
<makomo>
are there any tricks i can use so that SLIME properly indents my reader macros?
<makomo>
(the reader macros have a C-like syntax)
q3d has quit [Quit: Page closed]
kajo has joined #lisp
<remexre>
vms14 left, but afaik the magic with Prolog "macros" isn't so much homoiconicity
<remexre>
as it is that Prolog's semantics are simple enough to make writing an interpreter with a different search strategy simple
hjudt has quit [*.net *.split]
masterdonx has quit [*.net *.split]
shka__ has quit [*.net *.split]
swflint has quit [*.net *.split]
Posterdati has quit [*.net *.split]
dyelar has quit [*.net *.split]
micro has quit [*.net *.split]
chrpape has quit [*.net *.split]
shenghi has quit [*.net *.split]
sbryant has quit [*.net *.split]
isoraqathedh has quit [*.net *.split]
erkin has quit [*.net *.split]
Ziemas has quit [*.net *.split]
sjas has quit [*.net *.split]
White_Flame has quit [*.net *.split]
gabot has quit [*.net *.split]
McParen has left #lisp [#lisp]
bitch has quit [Ping timeout: 246 seconds]
Krystof has quit [Ping timeout: 255 seconds]
bitch has joined #lisp
chrpape has joined #lisp
micro has joined #lisp
masterdonx has joined #lisp
sbryant has joined #lisp
White_Flame has joined #lisp
Ziemas has joined #lisp
erkin has joined #lisp
sjas has joined #lisp
gabot has joined #lisp
dyelar has joined #lisp
swflint has joined #lisp
Aruseus has joined #lisp
hjudt has joined #lisp
isoraqathedh has joined #lisp
dddddd has quit [Read error: Connection reset by peer]
aindilis has joined #lisp
pankajgodbole has quit [Ping timeout: 250 seconds]
morgan_ has joined #lisp
Fade has joined #lisp
morgan_ has quit [Client Quit]
scymtym has quit [Ping timeout: 240 seconds]
catchme has quit [Quit: Connection closed for inactivity]
Posterdati has joined #lisp
<grewal>
Is there a reason that remove-duplicates keeps the last duplicated item by default?
lucasb has joined #lisp
gxt has quit [Quit: WeeChat 2.4]
<Bike>
easier to code that way, maybe?
cyberoctopi has quit [Ping timeout: 252 seconds]
<grewal>
It supports :from-end, so it has to be able to work in either direction. The behavior of :from-end just seems backwards to me
rumbler31 has joined #lisp
notzmv has joined #lisp
xylef has quit [Ping timeout: 250 seconds]
DGASAU has quit [Read error: Connection reset by peer]
Woodi has joined #lisp
warweasle has quit [Quit: nap]
cyberoctopi has joined #lisp
smasta has joined #lisp
bendersteed has quit [Ping timeout: 252 seconds]
karlosz has joined #lisp
<jackdaniel>
win 9
ebrasca has joined #lisp
xylef has joined #lisp
DGASAU has joined #lisp
karlosz has quit [Quit: karlosz]
sjas has quit [Quit: WeeChat 2.3]
cyberoctopi has quit [Ping timeout: 240 seconds]
cyberoctopi has joined #lisp
ebrasca has quit [Remote host closed the connection]
random-nick has quit [Ping timeout: 250 seconds]
nowhere_man has joined #lisp
smasta has quit [Ping timeout: 264 seconds]
<sjl>
when you use from-end, you /remove/ the duplicates /from the end/. And thus are left with the ones at the beginning.
<sjl>
when you don't use from-end, it's the opposite (you're removing the ones at the beginning, and thus are left with the final one)
smasta has joined #lisp
xkapastel has joined #lisp
smasta has quit [Ping timeout: 246 seconds]
drewc has joined #lisp
cyberoctopi has quit [Ping timeout: 250 seconds]
xylef has quit [Ping timeout: 252 seconds]
random-nick has joined #lisp
patlv has joined #lisp
xylef has joined #lisp
cyberoctopi has joined #lisp
cyberoctopi has quit [Ping timeout: 250 seconds]
orivej has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
Kundry_Wag has joined #lisp
orivej has quit [Quit: No Ping reply in 180 seconds.]
xylef has quit [Ping timeout: 255 seconds]
orivej has joined #lisp
xylef has joined #lisp
warweasle has joined #lisp
caltelt has quit [Ping timeout: 246 seconds]
estest has quit [Quit: Leaving.]
xylef has quit [Read error: Connection reset by peer]
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
dale has joined #lisp
smasta has joined #lisp
mrak has joined #lisp
rumbler31 has quit [Ping timeout: 250 seconds]
impulse has quit [Quit: leaving]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
<pjb>
remexre: So what? Types are not first class objects in CL, so you cannot return types in CL either!
rumbler31 has joined #lisp
<pjb>
remexre: but granted, in C, variables and functions are in the same namespace. This is why you cannot name a variable index, in C!
xylef has joined #lisp
<remexre>
pjb: obviously, the solution is hungarian notation; flarru8u8Index or go home
<pjb>
makomo: nope. reader macros are free style, so if you want to indent them, you will have to implement your own emacs lisp indentation code for them.
<pjb>
remexre: :-)
smasta has quit [Ping timeout: 240 seconds]
<makomo>
pjb: right. i guess what i meant was "to stop SLIME from indenting my macros", i.e. "somehow" leave them alone
<makomo>
because currently it tries to indent the C-like syntax and messses it up
Jesin has quit [Quit: Leaving]
<pjb>
grewal: the naive implementation of remove-duplicates for lists is (defun remove-duplicates (list) (cond ((null list) list) ((member (car list) (cdr list)) (remove-duplicates (cdr list))) (t (cons (car list) (remove-duplicates (cdr list)))))) ; so you can see why it keeps the last one.
<makomo>
i'm not sure what i expect SLIME to do myself, but maybe it could treat the span of the reader macro as an "opaque sexp" that it can move around within enclosing code (when indenting that enclosing code) but never indent it
<pjb>
Well, naive is perhaps too pejorative a qualifier. It's probably the first implementation of it.
<makomo>
but never indent the opaque sexp itself*
<pjb>
makomo: it's difficult for slime to do that, since it would have to evaluate the reader macro to determine the needed parameters.
cyberoctopi has joined #lisp
smasta has joined #lisp
<makomo>
hm, right. i jumped to that conclusion because my reader macro uses matching delimiters to mark its start/end
<pjb>
makomo: you would have to add some communication with swank to have it read the form to indent, and note the positions in the text.
<makomo>
eh :^(
<makomo>
but iirc SLIME already evaluates reader macros anyway, when reading source code files for example
<pjb>
slime doesn't read CL sources. swank may do it.
<makomo>
it has a function like SKIP-N-TOPLEVEL-FORMS or something that uses READ with *READ-SUPPRESS*
<makomo>
right, yeah
<pjb>
I don't find it.
<makomo>
i meant SLIME as in "the whole thing"
<makomo>
that's not the exact name, let me see what it was
<pjb>
makomo: note that to be able to read reader macros from the sources, you need to have loaded the sources! slime can also work on lisp sources that haven't been loaded yet.
Jesin has joined #lisp
cyberoctopi has quit [Ping timeout: 250 seconds]
<pjb>
makomo: you could try to add the feature, perhaps it won't be too hard.
smasta has quit [Ping timeout: 268 seconds]
<makomo>
true, and the reader macro has to respect *READ-SUPPRESS* otherwise you'll get errors and "jump to source" will fail
caltelt has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
<makomo>
pjb: hm maybe, but that's for another time then :-)
khisanth_ has quit [Ping timeout: 252 seconds]
dig` has quit [Remote host closed the connection]
pagnol has joined #lisp
dacoda has joined #lisp
digash has joined #lisp
khisanth_ has joined #lisp
vlatkoB has quit [Remote host closed the connection]
cyberoctopi has joined #lisp
fivo has quit [Quit: WeeChat 1.9.1]
warweasle has quit [Quit: later]
cyberoctopi has quit [Ping timeout: 240 seconds]
Kundry_Wag has joined #lisp
Folkol has joined #lisp
<aeth>
You know those tools that generate inheritance hierarchy charts in HTML? Are there any of those for CL?
Kundry_Wag has quit [Remote host closed the connection]
<aeth>
It'd be interesting to see how people organize their standard- and structure-classes.
kajo has quit [Remote host closed the connection]
kajo has joined #lisp
akoana has joined #lisp
<p_l>
aeth: you should be able to crib some code from McCLIM, then format it into something (graphviz?)
<aeth>
graphviz is probably the thing to do, .dot is a nice format
<aeth>
would it support both types of classes, though?
<p_l>
I think so
ggole has quit [Quit: Leaving]
<p_l>
well, structure-classes tend to be mapped onto same graph? even if they are not exactly compatibe
<aeth>
p_l: I think they should be there, but they'd be different colors or shapes and part of the importance would be to see where people decide to use one over the other
<p_l>
well, the render code could check type and issue different attributes to generated output
<aeth>
There seems to be three schools of thought on defstruct (excluding defstruct for defining sequences): (1) defstruct is legacy and irrelevant, (2) defstruct for high performance parts, (3) defstruct for simplicity
<p_l>
4) extended defstruct for low-level control of storage
<p_l>
but that's beyond CL
patlv has quit [Ping timeout: 255 seconds]
<aeth>
Personally, I usually use it where :type is important and could make a difference in performance, especially for containing numbers and specialized arrays
dddddd has joined #lisp
<aeth>
So e.g. a struct could have a slot with the type (simple-array (unsigned-byte 8) (32))
<aeth>
Something with type foobar where the type is more documentation than performance is probably a better fit for my checked-type metaclass (since :type isn't going to be checked all of the time in defclass). Or e.g. defclass for something that is holding a queue, implemented as a struct containing an array and some numbers.
<p_l>
the main argument against defstruct is how it causes non-trivial issues if you want to recompile defstruct later
shka_ has quit [Ping timeout: 252 seconds]
<aeth>
Absolutely. That's the argument against #3 (simplicity) imo.
puchacz has quit [Quit: Konversation terminated!]
rumbler31 has quit [Remote host closed the connection]
<aeth>
The differences lead to two very different ways of processing things at least in how I structure my code. With structure instances, I don't really worry about passing them as deep as possible to reduce the number of arguments to my functions. With standard instances, I'm a lot more worried about a possible dramatic redefinition in the middle of my computation, so I'm much more likely to place the relevant data into local variables.
<aeth>
essentially LET vs. WITH-ACCESSORS
<aeth>
the latter won't necessarily be the same thing twice in a loop.
<aeth>
Technically, I guess you could get the same thing with structs with threading, but hopefully that's handled with locks when relevant.
Kundry_Wag has joined #lisp
xylef has quit [Quit: WeeChat 2.4]
xylef has joined #lisp
salamad has joined #lisp
salamad has quit [Client Quit]
rumbler31 has joined #lisp
pagnol is now known as always-xy
lumm has quit [Read error: Connection reset by peer]
lumm has joined #lisp
patlv has joined #lisp
kajo has quit [Ping timeout: 240 seconds]
kajo has joined #lisp
argoneus has quit [Quit: No Ping reply in 180 seconds.]
moei has joined #lisp
argoneus has joined #lisp
caltelt has quit [Ping timeout: 240 seconds]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
dacoda has quit [Ping timeout: 255 seconds]
Kundry_Wag has quit [Ping timeout: 252 seconds]
caltelt has joined #lisp
amz3 has joined #lisp
selwyn has joined #lisp
<amz3>
hello, can you recommend me some lisp work related to frontend webdev? I am looking for attempts at building apps or framework using lisp in the browser.
<selwyn>
in the ABCL manual section 1.1.1 it is stated that 'Somewhat confusingly, this statement of non-conformance in the accompanying user documentation fulfills the requirements that ABCL is a conforming ANSI Common Lisp implementation according to the Common Lisp HyperSpec.'
<amz3>
tx
<selwyn>
does anyone know the relevant section of the hyperspec that discusses this?