ng0 has quit [Quit: Alexa, when is the end of world?]
badkins has quit [Ping timeout: 240 seconds]
pierpal has joined #racket
badkins has joined #racket
Fare has joined #racket
acarrico has joined #racket
<jcowan>
Feh. That's a "design pattern" in miniature, with all the faults of design patterns.
edoput has quit [Ping timeout: 250 seconds]
cantstanya has quit [Ping timeout: 256 seconds]
ym has quit [Ping timeout: 246 seconds]
ym has joined #racket
cantstanya has joined #racket
edoput has joined #racket
<samth>
jcowan: I think design patterns are something else -- `(filter values lst)` is more like the classic C for loop for copying 0-terminated strings
clacke has quit [Ping timeout: 250 seconds]
<jcowan>
That too is a design pattern in small, and the fact that we who write C use it is a sign of the lack of expressive power in the C language.
<nisstyre>
you could also do (for/list ([x xs] #:when x) x)
<nisstyre>
but that's more verbose
<nisstyre>
(filter identity xs) is more idiomatic imo though
<nisstyre>
if you needed to do it for multiple lists I'd use the list comp though
catonano_ has joined #racket
catonano has quit [Ping timeout: 250 seconds]
catonano_ is now known as catonano
<jcowan>
I agree that "identity" is better. Using "values" as an identity function was the "pattern" I objected to.
hjek has joined #racket
hjek has quit [Client Quit]
Arcaelyx has joined #racket
hjek has joined #racket
<bremner>
where does that come from? was there some older scheme dialects that only had values and not identity predefined?
hjek has quit [Client Quit]
<nisstyre>
bremner: apparently MIT/GNU Scheme does not have "identity" defined in the top level
<nisstyre>
I just tested it
<nisstyre>
which isn't surprising really, it's very minimal
<bremner>
huh. I guess that's R5RS?
<nisstyre>
I'm not sure
<bremner>
at least racket's r5rs doesn't have identity
<nisstyre>
I can't find anywhere in the MIT Scheme manual saying which report it supports
<nisstyre>
R7RS apparently, according to wikipedia
<nisstyre>
"mostly"
<nisstyre>
> Multiple-value returns are usable only in restricted ways. This can't be fixed without significant compiler work, which probably won't happen.
<nisstyre>
that's interesting
<nisstyre>
I wonder why
<nisstyre>
something to do with continuations I'm guessing
<bremner>
I can't quite decide if multiple return values are worth having.
<nisstyre>
I don't think it adds much value personally
<nisstyre>
pun intended
<samth>
jcowan: I think there's a difference between idioms (such as `values` as the identity function) vs design patterns (which are ways of constructing things)
<nisstyre>
the underlying architecture that allows for it could be useful in other ways though
<jcowan>
I think the difference is one of size, not of kind
pera has quit [Quit: leaving]
pie__ has quit [Remote host closed the connection]
pie__ has joined #racket
selimcan has joined #racket
<lexi-lambda>
I agree with samth that there’s a difference. A design pattern is a not-quite-abstraction, something that encourages a holistic view but perhaps can’t be abstracted over because of language limitations. An idiom is just a thing that shows up a lot. The difference between those is more than size.
<lexi-lambda>
An idiom is no more a design pattern than a function is a design pattern.
<nisstyre>
lexi-lambda: so, would an event loop be a design pattern?
pie__ has quit [Remote host closed the connection]
pie__ has joined #racket
widp_ has quit [Ping timeout: 252 seconds]
dddddd has quit [Remote host closed the connection]
selimcan has quit [Remote host closed the connection]
ym555 has quit [Ping timeout: 255 seconds]
Fare has quit [Ping timeout: 252 seconds]
Fare has joined #racket
selimcan has joined #racket
selimcan has quit [Remote host closed the connection]
sebastianlin has joined #racket
<lexi-lambda>
I think it could be. Though a library that provides an event loop DSL (whether via metaprogramming or just some encapsulated datatypes and functions on them) wouldn’t be a design pattern anymore, it would be an abstraction.
FreeFull has quit []
efm has joined #racket
obfusk has quit [Quit: No Ping reply in 180 seconds.]
lf94 has quit [*.net *.split]
bartbes has quit [*.net *.split]
eagleflo has quit [*.net *.split]
hexagoxel has quit [*.net *.split]
comstar has quit [*.net *.split]
bremner has quit [*.net *.split]
sebastianlin has quit [Ping timeout: 256 seconds]
pie___ has joined #racket
pie__ has quit [Ping timeout: 245 seconds]
clacke has joined #racket
bartbes has joined #racket
comstar has joined #racket
eagleflo has joined #racket
hexagoxel has joined #racket
lf94 has joined #racket
bremner has joined #racket
notzmv has quit [Ping timeout: 255 seconds]
notzmv has joined #racket
selimcan has joined #racket
YuGiOhJCJ has quit [Quit: YuGiOhJCJ]
pierpal has quit [Read error: Connection reset by peer]
endformationage has quit [Quit: WeeChat 2.3]
selimcan has quit [Remote host closed the connection]
<J_Arcane>
So one of my long-term plans for Heresy was always to make an actual QBASIC-ish syntax for it, and I'm wondering what the best route is there?
<J_Arcane>
Is it possible just to parse something directly to s-exp's such that the result can just be handed to the normal expansion/eval phase and off we go?
jao has joined #racket
ZombieChicken has quit [Remote host closed the connection]
notnotdan[m] has quit [Remote host closed the connection]
notnotdan[m] has joined #racket
ZombieChicken has joined #racket
widp_ has joined #racket
notzmv has quit [Remote host closed the connection]