2016-11-23T00:01:23Z cromachina joined #lisp
2016-11-23T00:01:30Z rumbler31 joined #lisp
2016-11-23T00:02:43Z DeadTrickster_ joined #lisp
2016-11-23T00:04:01Z Velveeta_Chef joined #lisp
2016-11-23T00:06:07Z DeadTrickster quit (Ping timeout: 265 seconds)
2016-11-23T00:07:17Z robotoad joined #lisp
2016-11-23T00:08:05Z DeadTrickster_ quit (Ping timeout: 248 seconds)
2016-11-23T00:10:21Z Kaisyu quit (Ping timeout: 258 seconds)
2016-11-23T00:13:54Z al-damiri quit (Quit: Connection closed for inactivity)
2016-11-23T00:15:15Z gmcastil quit (Ping timeout: 260 seconds)
2016-11-23T00:19:35Z sz0 quit (Quit: Connection closed for inactivity)
2016-11-23T00:20:43Z rumbler31 quit (Remote host closed the connection)
2016-11-23T00:23:40Z macdavid313 quit (Ping timeout: 250 seconds)
2016-11-23T00:23:49Z macdavid313 joined #lisp
2016-11-23T00:24:26Z papachan joined #lisp
2016-11-23T00:25:18Z rumbler31 joined #lisp
2016-11-23T00:29:13Z manuel__ quit (Ping timeout: 245 seconds)
2016-11-23T00:29:49Z rashmirathi quit (Remote host closed the connection)
2016-11-23T00:31:18Z Hoolootwo joined #lisp
2016-11-23T00:31:53Z rashmirathi joined #lisp
2016-11-23T00:34:23Z Orion3k quit (Ping timeout: 260 seconds)
2016-11-23T00:36:53Z biubiubiu joined #lisp
2016-11-23T00:38:17Z biubiubiu: (defmacro b (x) x)   (b '(+ 1 1))   why it return (+ 1 1) not 2?
2016-11-23T00:39:03Z biubiubiu: I supoose 2 because of eval twice
2016-11-23T00:40:38Z phoe quit (Ping timeout: 256 seconds)
2016-11-23T00:43:43Z biubiubiu quit (Ping timeout: 260 seconds)
2016-11-23T00:46:40Z Orion3k joined #lisp
2016-11-23T00:48:22Z Xach: i...
2016-11-23T00:49:16Z CEnnis91 quit (Quit: Connection closed for inactivity)
2016-11-23T00:52:03Z axion: didn't know how to respond to that either
2016-11-23T00:52:16Z sellout- joined #lisp
2016-11-23T00:52:47Z phoe joined #lisp
2016-11-23T00:53:50Z BlueRavenGT quit (Read error: Connection reset by peer)
2016-11-23T00:56:32Z newcup joined #lisp
2016-11-23T01:09:28Z rashmira_ joined #lisp
2016-11-23T01:11:20Z rashmirathi quit (Ping timeout: 260 seconds)
2016-11-23T01:11:39Z neoncontrails quit (Remote host closed the connection)
2016-11-23T01:13:12Z EvW quit (Ping timeout: 260 seconds)
2016-11-23T01:18:17Z macdavid314 joined #lisp
2016-11-23T01:19:44Z macdavid313 quit (Ping timeout: 256 seconds)
2016-11-23T01:19:45Z macdavid314 is now known as macdavid313
2016-11-23T01:23:33Z neoncontrails joined #lisp
2016-11-23T01:25:18Z robotoad quit (Quit: robotoad)
2016-11-23T01:27:49Z rumbler31: http://paste.lisp.org/display/332234
2016-11-23T01:29:41Z rumbler31: am i dumb?  Just trying to calculate the mode of a list of numbers.  I use a plist to store counts of seen numbers in a list, then use this plist as a key to sort on the original list of numbers.  when I use the guts of (mode independently, as in, I use count-stuff on a list and then use the guts on the result, I get what I expect, when I tie it all together in one function it is unhappy
2016-11-23T01:31:13Z attila_lendvai quit (Ping timeout: 260 seconds)
2016-11-23T01:31:54Z lexicall joined #lisp
2016-11-23T01:32:42Z lexicall quit (Remote host closed the connection)
2016-11-23T01:32:50Z shdeng joined #lisp
2016-11-23T01:34:47Z BlueRavenGT joined #lisp
2016-11-23T01:35:59Z Orion3k quit (Ping timeout: 260 seconds)
2016-11-23T01:36:05Z slyrus quit (Ping timeout: 248 seconds)
2016-11-23T01:37:38Z attila_lendvai joined #lisp
2016-11-23T01:37:38Z attila_lendvai quit (Changing host)
2016-11-23T01:37:38Z attila_lendvai joined #lisp
2016-11-23T01:37:44Z giraffe quit (Quit: ZNC - http://znc.in)
2016-11-23T01:37:45Z SlashLife joined #lisp
2016-11-23T01:39:32Z SlashLife quit (Remote host closed the connection)
2016-11-23T01:40:09Z SlashLife joined #lisp
2016-11-23T01:41:57Z itruslove joined #lisp
2016-11-23T01:44:57Z giraffe joined #lisp
2016-11-23T01:45:57Z swflint_away joined #lisp
2016-11-23T01:46:11Z swflint_away is now known as swflint
2016-11-23T01:47:02Z lexicall joined #lisp
2016-11-23T01:49:34Z slyrus joined #lisp
2016-11-23T01:53:11Z Josh_2 quit (Remote host closed the connection)
2016-11-23T01:54:38Z Orion3k joined #lisp
2016-11-23T01:54:43Z test1600 joined #lisp
2016-11-23T01:54:52Z BlueRavenGT quit (Ping timeout: 265 seconds)
2016-11-23T01:57:50Z lexicall quit (Remote host closed the connection)
2016-11-23T01:58:17Z lexicall joined #lisp
2016-11-23T02:00:53Z beach` joined #lisp
2016-11-23T02:02:44Z vaporatorius quit (Remote host closed the connection)
2016-11-23T02:02:45Z beach quit (Ping timeout: 248 seconds)
2016-11-23T02:06:34Z floatingman quit (Quit: ZNC 1.6.3 - http://znc.in)
2016-11-23T02:09:29Z attila_lendvai quit (Ping timeout: 260 seconds)
2016-11-23T02:10:17Z ym quit (Ping timeout: 240 seconds)
2016-11-23T02:11:28Z ym joined #lisp
2016-11-23T02:12:03Z floatingman joined #lisp
2016-11-23T02:14:16Z Reinisch joined #lisp
2016-11-23T02:14:33Z lexicall quit (Remote host closed the connection)
2016-11-23T02:15:03Z lexicall joined #lisp
2016-11-23T02:18:08Z manuel__ joined #lisp
2016-11-23T02:18:24Z pjb quit (Quit: Be seeing you!)
2016-11-23T02:18:52Z rumbler31 quit (Remote host closed the connection)
2016-11-23T02:20:38Z roscoe_tw joined #lisp
2016-11-23T02:20:38Z seg_ joined #lisp
2016-11-23T02:21:15Z seg quit (Ping timeout: 260 seconds)
2016-11-23T02:21:33Z seg_ is now known as seg
2016-11-23T02:22:59Z Reinisch quit (Remote host closed the connection)
2016-11-23T02:23:29Z arescorpio joined #lisp
2016-11-23T02:25:52Z mrf3000 quit (Remote host closed the connection)
2016-11-23T02:26:20Z mrf3000 joined #lisp
2016-11-23T02:26:44Z Reinisch joined #lisp
2016-11-23T02:27:55Z Fare quit (Ping timeout: 268 seconds)
2016-11-23T02:28:44Z ahungry joined #lisp
2016-11-23T02:30:44Z rashmira_ quit (Remote host closed the connection)
2016-11-23T02:31:04Z mrf3000 quit (Ping timeout: 250 seconds)
2016-11-23T02:31:44Z NeverDie joined #lisp
2016-11-23T02:32:20Z rumbler31 joined #lisp
2016-11-23T02:36:47Z heddwch is now known as hedvicha
2016-11-23T02:38:06Z _leb joined #lisp
2016-11-23T02:39:04Z NeverDie quit (Quit: http://radiux.io/)
2016-11-23T02:41:05Z macdavid313 quit (Ping timeout: 244 seconds)
2016-11-23T02:43:12Z lexicall quit (Remote host closed the connection)
2016-11-23T02:43:38Z lexicall joined #lisp
2016-11-23T02:45:25Z Jesin joined #lisp
2016-11-23T02:47:06Z papachan quit (Quit: Saliendo)
2016-11-23T02:51:57Z _death: rumbler31: there are 3 problems.. (i) GETF uses EQ for comparison, plists should have symbols for keys, not numbers; (ii) SORT is destructive, therefore may modify the numbers list, while you use it in the key function; (iii) you are passing a literal to MODE, which SORT may attempt to modify
2016-11-23T02:52:23Z rumbler31: derp
2016-11-23T02:52:41Z rumbler31: i knew it was too clever for my own good
2016-11-23T02:53:15Z loke: rumbler31: I'd also recommend against using recursion instead of LOOP
2016-11-23T02:56:25Z loke: Also, a plist tends to be slow as the number of values grow.
2016-11-23T02:58:09Z karswell` joined #lisp
2016-11-23T02:58:59Z robotoad joined #lisp
2016-11-23T02:59:35Z karswell quit (Ping timeout: 256 seconds)
2016-11-23T03:02:32Z jleija joined #lisp
2016-11-23T03:04:37Z defaultxr joined #lisp
2016-11-23T03:04:58Z jleija quit (Client Quit)
2016-11-23T03:05:27Z jleija joined #lisp
2016-11-23T03:05:57Z rashmirathi joined #lisp
2016-11-23T03:10:18Z rashmirathi quit (Ping timeout: 246 seconds)
2016-11-23T03:13:43Z BlueRavenGT joined #lisp
2016-11-23T03:13:48Z robotoad quit (Quit: robotoad)
2016-11-23T03:14:13Z lexicall quit (Quit: Ah, my macbook is gonna sleep!)
2016-11-23T03:22:31Z robotoad joined #lisp
2016-11-23T03:24:22Z hedvicha is now known as heddwch
2016-11-23T03:28:55Z TDT quit (Quit: TDT)
2016-11-23T03:33:12Z cmatei quit (Ping timeout: 260 seconds)
2016-11-23T03:34:00Z shikhin is now known as driyoyleujiy
2016-11-23T03:34:11Z driyoyleujiy is now known as shikhin
2016-11-23T03:36:13Z sellout- quit (Quit: Leaving.)
2016-11-23T03:38:01Z rumbler31 quit (Remote host closed the connection)
2016-11-23T03:41:12Z sellout- joined #lisp
2016-11-23T03:45:54Z ym: Is there a terminal emulator implementation for linux?
2016-11-23T03:46:50Z ym: VT100 preferably.
2016-11-23T03:47:39Z |3b| knows of at least 2 terminal emulators in lisp, neither is linux specific though
2016-11-23T03:48:12Z loke: ym: Yes.
2016-11-23T03:48:16Z loke: ym: xterm.
2016-11-23T03:48:21Z loke: For example.
2016-11-23T03:48:35Z |3b|: mezzano has one (UI is specific to mezzano lisp OS), and i ported the terminal emulation part of st to lisp, but no UI at all for that
2016-11-23T03:49:08Z |3b| is assuming some relevance to the channel, there are lots and lots of them if not :p
2016-11-23T03:49:47Z loke: |3b|: very good point.
2016-11-23T03:50:01Z loke: I wrote one in Java about 15 years ago. It's not hard to do.
2016-11-23T03:50:58Z |3b|: yeah, hardest part is probably deciding on exactly what you are implementing and what the specs for it are
2016-11-23T03:51:51Z MrWoohoo joined #lisp
2016-11-23T03:52:27Z |3b|: i think there is also at least one terminal emulation C lib that might not be too hard to wrap with CFFI
2016-11-23T03:56:30Z loke: When I did it in Java, I just implemented plain VT102. It was simple, compatible with most everything else and very well documented.
2016-11-23T03:56:48Z loke: If you want somehting simpler, VT52 might be an option.
2016-11-23T03:57:05Z loke: Or the simplest of them all, design your own codes and write a terminfo entry for it.
2016-11-23T03:58:01Z loke: You'll have some issues with shitty software that hard-codes escape sequences (I'm looking at you, DOCKER) though.
2016-11-23T04:02:26Z ym: |3b|, st in CL? Could you provide a link, please?
2016-11-23T04:03:35Z fouric quit (Ping timeout: 260 seconds)
2016-11-23T04:03:47Z |3b|: https://github.com/3b/3bst
2016-11-23T04:03:47Z |3b|: just does the terminal state though, no IO
2016-11-23T04:04:43Z ym: Interesting. Thanks.
2016-11-23T04:07:01Z _leb quit (Quit: Computer has gone to sleep.)
2016-11-23T04:10:44Z |3b|: https://github.com/froggey/Mezzano/blob/master/gui/xterm.lisp is the term from mezzano i was talking about, not sure how hard it would be to remove the dependency on mezzano. i probably would have tried that first if i noticed it before doing the ST port
2016-11-23T04:15:30Z yrk quit (Read error: Connection reset by peer)
2016-11-23T04:16:05Z slyrus quit (Ping timeout: 248 seconds)
2016-11-23T04:20:18Z vtomole: Just use xterm on mezzano without removing it ;)
2016-11-23T04:20:49Z fouric joined #lisp
2016-11-23T04:21:46Z tmtwd joined #lisp
2016-11-23T04:22:03Z |3b|: vtomole: original request was for linux though, and running a VM seems a bit much just to get a terminal :)
2016-11-23T04:22:59Z NeverDie joined #lisp
2016-11-23T04:32:19Z manuel__ quit (Quit: manuel__)
2016-11-23T04:32:58Z _leb joined #lisp
2016-11-23T04:36:24Z jason_m quit (Ping timeout: 246 seconds)
2016-11-23T04:37:27Z slyrus joined #lisp
2016-11-23T04:46:39Z arescorpio quit (Quit: Leaving.)
2016-11-23T04:47:08Z akkad: is there anyway to represent a plist as a string for printing?
2016-11-23T04:47:15Z akkad: mapc concat
2016-11-23T04:47:43Z loke: akkad: Yes, you can do it using FORMAT
2016-11-23T04:48:07Z akkad: oh like a regular list?
2016-11-23T04:48:21Z |3b|: it is a regular list
2016-11-23T04:48:26Z akkad: right.
2016-11-23T04:48:28Z loke: (format t "~{~s = ~s~%~}" '(a 10 b 20 c 30))
2016-11-23T04:48:34Z akkad: yeah.
2016-11-23T04:48:42Z akkad: thanks
2016-11-23T04:49:58Z araujo quit (Read error: Connection timed out)
2016-11-23T04:51:08Z araujo joined #lisp
2016-11-23T04:51:29Z PinealGlandOptic quit (Quit: leaving)
2016-11-23T05:02:29Z tmtwd quit (Ping timeout: 248 seconds)
2016-11-23T05:06:23Z beach` is now known as beach
2016-11-23T05:09:21Z beach: Good morning everyone!
2016-11-23T05:10:48Z vlatkoB joined #lisp
2016-11-23T05:18:42Z marusich joined #lisp
2016-11-23T05:19:18Z vtomole: morning beach!
2016-11-23T05:27:15Z shka_ joined #lisp
2016-11-23T05:27:18Z Reinisch quit (Quit: Leaving...)
2016-11-23T05:27:32Z Reinisch joined #lisp
2016-11-23T05:30:59Z _leb quit (Quit: Computer has gone to sleep.)
2016-11-23T05:32:05Z _leb joined #lisp
2016-11-23T05:32:05Z Harag joined #lisp
2016-11-23T05:33:37Z beach: vtomole: You were asking for more information about my plans for LispOS, right?  Did you see this PDF? http://metamodular.com/lispos.pdf
2016-11-23T05:34:38Z loke: beach: Interesting, and I'll read that in a bit
2016-11-23T05:34:49Z loke: That said, how different is your vision from what Mezzano does?
2016-11-23T05:35:03Z beach: Not much in common, I think.
2016-11-23T05:35:40Z bocaneri joined #lisp
2016-11-23T05:35:46Z vtomole quit (Ping timeout: 260 seconds)
2016-11-23T05:35:52Z loke: The single address space thing is something that I find very interesting and have wanted for a long time.
2016-11-23T05:36:55Z loke: Another ting I was thinking of (not sure how viable it is in actual prcatice) is to extend a machine address with another 128 bits (the IP-address) to make such addresses completely universal.
2016-11-23T05:38:12Z beach: That's an interesting idea.  I am not sure how practical that would be.
2016-11-23T05:39:02Z eschatologist: a lot of work in the lispm world went into making references less costly, rather than more
2016-11-23T05:39:17Z eschatologist: for example, cdr coding, array/vector representation, etc.
2016-11-23T05:39:47Z loke: beach: That thinking was part of me hypothesising around the required number of bits needed to address _anything_. I figured 128 bits for the IP address + 64 bits for the memory would cover anything actually running. However, 64 bits is not enough to cover all local data, since 16 EB is within the range of reasonableness soon enough.
2016-11-23T05:39:58Z loke: So 128 bits IP + 128 bits local address is needed.
2016-11-23T05:40:29Z eschatologist: making every address 3x-5x its current size would demand a really good use case
2016-11-23T05:40:35Z Zhivago: The single address space thing is a seductive trap.
2016-11-23T05:40:46Z loke: Zhivago: Indeed. It's probbaly not practical though :-)
2016-11-23T05:41:08Z loke: I don't even know if it's useful :-)
2016-11-23T05:41:11Z Zhivago: It makes a reasonable amount of sense where code isn't distributed.
2016-11-23T05:41:45Z eschatologist: even the lispm world effectively used IPC to coordinate processes, despite all of them sharing an address space, because working set has always been limited
2016-11-23T05:41:57Z Zhivago: I'd suggest going in completely the other direction, and strengthening the specification of environments sufficiently that each environment is effectively a separate machine.
2016-11-23T05:42:06Z gingerale joined #lisp
2016-11-23T05:42:32Z loke: Zhivago: I think I agree with you (assuming I fully understood you).
2016-11-23T05:43:45Z Zhivago: loke: No expectation of direct reference to objects in other environments.
2016-11-23T05:43:49Z loke: Mainly because there is a huge difference between local storage and network access. One can be trusted to work, and the other not. It'd be a hassle to have to assume partial failures inside a single machine, and assuming that remote machines never fail is equally problematic (something the CORBA guys realised)
2016-11-23T05:44:41Z vtomole joined #lisp
2016-11-23T05:45:52Z vibs29 quit (Ping timeout: 268 seconds)
2016-11-23T05:51:52Z vibs29 joined #lisp
2016-11-23T05:59:17Z Amplituhedron quit (Remote host closed the connection)
2016-11-23T05:59:31Z _leb quit (Quit: Computer has gone to sleep.)
2016-11-23T05:59:35Z Amplituhedron joined #lisp
2016-11-23T06:03:08Z mishoo joined #lisp
2016-11-23T06:04:39Z ASau quit (Ping timeout: 244 seconds)
2016-11-23T06:10:11Z dmiles quit (Read error: Connection reset by peer)
2016-11-23T06:10:56Z jleija quit (Quit: leaving)
2016-11-23T06:11:17Z flip214: pipping: thanks, playing around now and hoping for a new release
2016-11-23T06:12:54Z dmiles joined #lisp
2016-11-23T06:13:57Z rpg quit (Ping timeout: 256 seconds)
2016-11-23T06:15:23Z gingerale quit (Remote host closed the connection)
2016-11-23T06:16:27Z sdothum quit (Quit: ZNC - 1.6.0 - http://znc.in)
2016-11-23T06:18:59Z sdothum joined #lisp
2016-11-23T06:21:42Z shka_ quit (Ping timeout: 244 seconds)
2016-11-23T06:23:52Z leb joined #lisp
2016-11-23T06:29:47Z jusss joined #lisp
2016-11-23T06:30:18Z jusss: (defmacro (b x) x)  (b '(+ 1 1)) why not return 2?
2016-11-23T06:31:01Z BlueRavenGT quit (Ping timeout: 248 seconds)
2016-11-23T06:32:27Z |3b|: jusss: the macro sees the list (quote (+ 1 1)) and returns that list, which evaluates to the list (+ 1 1)
2016-11-23T06:33:07Z jusss: |3b|: does it evaluate twice?
2016-11-23T06:33:38Z oleo quit (Quit: Leaving)
2016-11-23T06:33:56Z |3b| isn't sure what you mean, but probably not
2016-11-23T06:34:17Z sdothum quit (Quit: ZNC - 1.6.0 - http://znc.in)
2016-11-23T06:35:23Z |3b|: lisp operates on lisp data structures like lists,symbols and numbers. one of the evaluation rules handles evaluating lists that start with a symbol naming a macro. in that case, (simplifying a bit) it passes the rest of that list to the macro function without evaluating it
2016-11-23T06:36:06Z |3b|: so to evaluate the list (b (quote (+ 1 1))) it passes the list (quote (+ 1 1)) containing the symbol quote and the list (+ 1 1) to the macro named by B
2016-11-23T06:36:58Z |3b|: your macro just returns that list (quote (+ 1 1)) back to the evaluator unmodified
2016-11-23T06:37:18Z beach: |3b|: Wow, excellent explanation.
2016-11-23T06:37:20Z leb quit
2016-11-23T06:37:46Z jusss: if I want to eval '(+ 1 1), how should I do? use (eval ...)?
2016-11-23T06:38:45Z setheus quit (Ping timeout: 244 seconds)
2016-11-23T06:39:05Z |3b|: the evaluator then tries to evaluate the result, using the rule for list starting with a symbol naming a special operator, QUOTE in this case, which has a special rule saying to return its argument unmodified
2016-11-23T06:39:28Z setheus joined #lisp
2016-11-23T06:39:39Z |3b|: if you mean unrelated to that macro, you can evaluate forms with EVAL
2016-11-23T06:41:03Z |3b|: eval is a function, so you would probably want to quote the argument, so (eval '(+ 1 1)) would pass the list (+ 1 1) to EVAL, which would evaluate it and return 2
2016-11-23T06:41:51Z |3b|: if you mean in the context of the macro, EVAL is usually the wrong thing. in that case you would probably want to just pass (+ 1 1) to the macro instead of (quote (+ 1 1)), so (b (+ 1 1)) would also evaluate to 2
2016-11-23T06:41:58Z jusss: I try to make a function or macro A, that I pass a data like '(+ 1 1) to A, then A will eval it, but I don't like to use EVAL, so I'm thinking that's possible?
2016-11-23T06:42:22Z |3b|: if the list (+ 1 1) is runtime input, then you might need to use EVAL
2016-11-23T06:42:38Z |3b|: if not, then we'd need to know more context to say what is the best option
2016-11-23T06:43:11Z Amplituhedron quit (Remote host closed the connection)
2016-11-23T06:43:25Z jusss: not runtime input
2016-11-23T06:43:26Z Amplituhedron joined #lisp
2016-11-23T06:44:58Z jusss: pass data to A, and data will be evaluated, turn data to code
2016-11-23T06:46:28Z heurist`_ joined #lisp
2016-11-23T06:46:28Z troydm quit (Ping timeout: 250 seconds)
2016-11-23T06:46:42Z |3b|: where does the data come from?
2016-11-23T06:47:46Z heurist` quit (Ping timeout: 265 seconds)
2016-11-23T06:47:57Z jusss: generate by procedure
2016-11-23T06:48:18Z |3b|: at runtime?
2016-11-23T06:48:28Z |3b|: and from what sort of input?
2016-11-23T06:48:54Z |3b|: "generate code by procedure" is more of less the definition of a macro, so possibly your generation could be done by a macro
2016-11-23T06:48:58Z jusss: at runtime,
2016-11-23T06:49:09Z |3b|: ok, so probably not a macro then
2016-11-23T06:49:40Z |3b|: next option would be if you usually generate similar things, like adding 2 numbers, you might be able to use closures instead of building code from scratch
2016-11-23T06:58:21Z shka_ joined #lisp
2016-11-23T07:00:30Z jusss: |3b|: in repl, input: '(+ 1 1), output is '(+ 1 1) or (+ 1 1), I'm confused
2016-11-23T07:01:03Z axion: You'll also probably want gensyms and a once-only implementation :)
2016-11-23T07:01:14Z jusss: (eval '(+ 1 1)) will return 2, but input '(+ 1 1) to repl, return (+ 1 1)
2016-11-23T07:01:28Z |3b|: the set of 8 characters '(+ 1 1) is READ (the R in Repl) as the 2-element list (quote (+ 1 1))
2016-11-23T07:01:32Z Guest2_ joined #lisp
2016-11-23T07:02:16Z |3b|: that list is evaluated (the E in rEpl) using the special rules for QUOTE which just returns the next element in the list unmodified, which is the 3 element list (+ 1 1)
2016-11-23T07:02:42Z |3b|: the P in rePl prints that as the sequence of 7 characters (+ 1 1)
2016-11-23T07:02:42Z Karl_Dscc joined #lisp
2016-11-23T07:02:46Z gniourf quit (Ping timeout: 250 seconds)
2016-11-23T07:03:02Z jusss: so input (eval '(+ 1 1)) will evaluate twice?
2016-11-23T07:03:03Z |3b|: (and then the L for LOOP sens it back to READing again)
2016-11-23T07:03:21Z jusss: and '(+ 1 1) will evaluate once in repl
2016-11-23T07:03:31Z |3b|: if you type that into the repl, it is read as (EVAL (QUOTE (+ 1 1)))
2016-11-23T07:03:57Z |3b|: then the repl evaluates that, and since EVAL is a normal function, it evaluates the rest of the list to get arguments to pass to EVAL
2016-11-23T07:04:36Z |3b|: so it evaluates the list (QUOTE (+ 1 1)) to get the list (+ 1 1) and passes that to eval, which then evaluates it to get 2 and returns that to the repl to be printed
2016-11-23T07:05:28Z |3b|: so it would be reasonable to count that as 2 evaluations or 3, depending on whether you include evaluating arguments as part of evaluating a function call or not
2016-11-23T07:07:31Z Guest2_ left #lisp
2016-11-23T07:07:45Z alexherbo2 joined #lisp
2016-11-23T07:07:50Z |3b|: (and sorry if i'm being overly verbose, this stuff depends on some subtle distinctions to understand correctly, so i'm trying to be precise about what is happening)
2016-11-23T07:08:02Z mishoo quit (Ping timeout: 252 seconds)
2016-11-23T07:10:07Z shka_ quit (Ping timeout: 260 seconds)
2016-11-23T07:10:40Z deank quit (Ping timeout: 260 seconds)
2016-11-23T07:10:51Z beach: |3b|: I'll say this again, you are doing a great job.
2016-11-23T07:12:19Z jusss: I should save this conversation :)
2016-11-23T07:13:08Z Guest2_ joined #lisp
2016-11-23T07:13:47Z troydm joined #lisp
2016-11-23T07:14:06Z deank joined #lisp
2016-11-23T07:14:13Z nowhere_man quit (Remote host closed the connection)
2016-11-23T07:14:39Z nowhere_man joined #lisp
2016-11-23T07:15:49Z gniourf joined #lisp
2016-11-23T07:15:55Z Karl_Dscc quit (Remote host closed the connection)
2016-11-23T07:16:51Z Harag quit (Quit: Harag)
2016-11-23T07:17:04Z neoncontrails quit (Remote host closed the connection)
2016-11-23T07:17:30Z Harag joined #lisp
2016-11-23T07:17:41Z neoncontrails joined #lisp
2016-11-23T07:18:15Z Harag quit (Client Quit)
2016-11-23T07:19:37Z scymtym quit (Ping timeout: 240 seconds)
2016-11-23T07:21:45Z Josh_2 joined #lisp
2016-11-23T07:22:15Z neoncontrails quit (Ping timeout: 260 seconds)
2016-11-23T07:22:46Z Harag joined #lisp
2016-11-23T07:23:01Z yeticry quit (Quit: leaving)
2016-11-23T07:28:16Z NeverDie quit (Quit: http://radiux.io/)
2016-11-23T07:28:37Z lexicall joined #lisp
2016-11-23T07:29:08Z moei quit (Quit: Leaving...)
2016-11-23T07:31:46Z robotoad quit (Quit: robotoad)
2016-11-23T07:31:50Z jusss: does lisp always auto evalate the parameters to function? like (defun c (x) x)  (c '(+ 1 1))  the parameter '(+ 1 1) will evalate to (+ 1 1) then pass it to function c ?
2016-11-23T07:32:45Z |3b|: right
2016-11-23T07:37:10Z jusss: evaluate or not, make brain twist
2016-11-23T07:38:47Z robotoad joined #lisp
2016-11-23T07:38:56Z jusss: and why other language don't have macro support like lisp? it's too hard to write?
2016-11-23T07:39:07Z |3b|: evaluation rules are pretty simple once you have the right model of what is happening, but getting to that point isn't always obvious (which is why i was trying to be precise about it)
2016-11-23T07:39:10Z flamebeard joined #lisp
2016-11-23T07:39:21Z beach left #lisp
2016-11-23T07:39:36Z |3b|: more work to get something comparable in other languages
2016-11-23T07:40:21Z |3b|: for one thing other languages are defined more in terms of the text of the source, while CL separates converting the text into data, then evaluating that data
2016-11-23T07:40:53Z lnostdal quit (Read error: Connection reset by peer)
2016-11-23T07:41:10Z |3b|: and then the form of that data is fairly simple and easy to work with in CL
2016-11-23T07:41:27Z lnostdal joined #lisp
2016-11-23T07:42:14Z jusss: use eval function, other languages can do something like lisp's macro?
2016-11-23T07:42:55Z |3b|: well, most languages are turing complete, so can technically all do the exact same set of things
2016-11-23T07:44:07Z |3b|: since CL macros are expanded during compilation, probably a better comparison would be running a preprocessor on the source (which is exactly what C does)
2016-11-23T07:45:08Z jusss: the scope, eval function's weakness
2016-11-23T07:46:34Z |3b|: i guess the way CL does loading/reading/compilation/running all as updating the state of a running process rather than C's style of batch processing compilation also helps (talking about common implementations rather than the language itself, though some of that is more or less specified in CL language)
2016-11-23T07:46:58Z |3b|: since you can more easily compile a bit of code then use it to compile the next bit of code in same file
2016-11-23T07:47:59Z |3b|: while typical C toolchain using C for its macro language would have to compile each macro definition separately, then load that to processes remainder of file (and probably implement some sort of caching so it isn't doing that for every file when a .h file includes a macro)
2016-11-23T07:48:57Z Davidbrcz joined #lisp
2016-11-23T07:49:27Z |3b|: then there would be the problem that those hypothetical CL style C macros would probably be working on some tree of structs representing the parse of the file, rather than just being lists, symbols,etc as in CL
2016-11-23T07:50:04Z sellout- quit (Quit: Leaving.)
2016-11-23T07:50:24Z jusss: (defmacro b (x) `(+ ,x 1))  (f 3) return 4, I suppose (+ 3 1), I'm confused again
2016-11-23T07:50:46Z |3b|: so would probably need an entire library of extra functions to work with, while lists are one of the main types inCL so it already has lots of ways to work with them
2016-11-23T07:51:33Z jusss: (b 3) not (f 3)...
2016-11-23T07:51:44Z |3b|: assuming you meant (b 3), it expands to the 3-element list (+ 3 1), which happens during evaluation of the form (b 3). that evaluation continues by evaluating the expansion, to get 4
2016-11-23T07:51:53Z |3b|: try (macroexpand '(b 3))
2016-11-23T07:52:16Z jusss: `(+ ,x 1)  `is quote or not?
2016-11-23T07:52:50Z jusss: ` is not quote? and what it means
2016-11-23T07:52:54Z |3b|: ` is usually called "quasiquote"
2016-11-23T07:53:23Z |3b|: it is sort of like quote but lets you use , and ,@ (and some others) to modify the form as it is READ
2016-11-23T07:53:52Z |3b|: , inside ` means approximately "read the next form, evaluate it and put the result in its place"
2016-11-23T07:54:14Z |3b|: so `(,x) returns a list containing the value of X
2016-11-23T07:54:21Z Davidbrcz quit (Ping timeout: 260 seconds)
2016-11-23T07:55:05Z |3b|: actually, i got that definition of , wrong
2016-11-23T07:55:35Z |3b|: it is more like "read the next form and put something there that will evaluate to the value of X when the ` form is evaluated"
2016-11-23T07:55:56Z |3b|: ` is defined in terms of what the ` form evaluates to, not what you get from READing it
2016-11-23T07:56:21Z |3b|: so `(,x) READs as something that evaluates to a list containing the value of X
2016-11-23T07:57:19Z |3b|: in your macro example, when (b 3) is expanded, the value of X is 3, so `(+ ,x 1) evaluates to the list (+ 3 1), which is returned as the expansion of the macro
2016-11-23T07:57:38Z jusss: (b 3) will return `(+ 3 1) to repl or (+ 3 1)?
2016-11-23T07:57:43Z mishoo joined #lisp
2016-11-23T07:58:26Z jusss: if it return (+ 3 1) to repl, but I don't use eval to evaluate quasiquote, and why it's gone
2016-11-23T07:58:31Z |3b|: (b 3) evaluates to 4. that evaluation involves the expansion of the macro B with 3 for the value of X
2016-11-23T07:58:41Z |3b|: (b 3) expands to the list (+ 3 1)
2016-11-23T07:58:50Z White_Flame: `(+ ,x 1) is roughly equivalent to (list '+ x '1)
2016-11-23T07:59:38Z jusss: why quasiquote is gone? I don't use eval
2016-11-23T07:59:53Z stepnem joined #lisp
2016-11-23T08:00:16Z |3b|: the ` disappears when the macro definition is being READ, replaced with something that evaluates to the specified results
2016-11-23T08:00:46Z White_Flame: jusss: macros transform your source code.  The REPL evaluates the given source code
2016-11-23T08:01:01Z |3b|: so if ` were implemented as White_Flame suggested, the result of READing (defmacro b (x) `(+ ,x 1)) would be the list (defmacro b (x) (list '+ x '1))
2016-11-23T08:01:29Z |3b|: which would them be evaluated to define the macro as a side effect of the evaluation
2016-11-23T08:02:10Z White_Flame: and that would mean that typing (b 3) at the REPL is equivalent to typing (+ 3 1).  The macro transformed what you typed before the REPL eval'd it
2016-11-23T08:02:22Z |3b|: (in practice it might not be implemented like that, in particular if the implementation wants to be able to print it out like `(+ ,x 1) if that was the input)
2016-11-23T08:03:02Z |3b| would say it transforms it while the repl evals it
2016-11-23T08:03:26Z White_Flame: yes, and though you were implying that it happens during READ, which isn't quite correct either :)
2016-11-23T08:03:48Z lexicall quit (Quit: Ah, my macbook is gonna sleep!)
2016-11-23T08:03:48Z |3b|: ` is the part that happens during read
2016-11-23T08:03:54Z angavrilov joined #lisp
2016-11-23T08:03:55Z White_Flame: but in general, during evaluation if the head of a form is a macro, the form gets transformed, and then reevaluated
2016-11-23T08:04:22Z |3b|: it is hard to get the subtleties right when explaining this stuff :/
2016-11-23T08:04:35Z White_Flame: you as the user generally don't ever "see" the result of a macro
2016-11-23T08:05:07Z White_Flame: it just performs the (b 3) => (+ 3 1) transformation inside the evaluation, because 'b' was defined as a macro
2016-11-23T08:05:19Z MoALTz joined #lisp
2016-11-23T08:05:34Z White_Flame: macros receive source code as their parameter, and the return value is source code, in the form of generally a list.  Sometimes a symbol or value
2016-11-23T08:05:39Z White_Flame: *parameters
2016-11-23T08:06:28Z White_Flame: so a lot of times people get tripped up that the parameters don't have their final values.  In your instance, in calling (b 3), inside the defmacro body you'll never have access to the value 3
2016-11-23T08:06:46Z White_Flame: wait, scratch that... :)
2016-11-23T08:07:06Z |3b|: (let ((x 3)) (b x)) is where you have that problem
2016-11-23T08:07:07Z White_Flame: if somebody called (b x), where X happens to be 3, you don't see the 3 at all
2016-11-23T08:07:15Z White_Flame: you just get the literal symbol X
2016-11-23T08:07:32Z jusss: completely confused...
2016-11-23T08:07:34Z White_Flame: and you return the transformed (+ X 1)
2016-11-23T08:07:46Z White_Flame: jusss: what's the case in which you're using a macro?
2016-11-23T08:08:05Z White_Flame: in cases like this, where the equivalent functionality can be expressed in a function, macros aren't of any use and seem pointless
2016-11-23T08:08:06Z moei joined #lisp
2016-11-23T08:08:24Z White_Flame: because (defun b (x) (+ x 1)) basically does what you want
2016-11-23T08:09:01Z |3b|: i guess (let ((y 3)) (b y)) is a better example, since it won't be confused with the parameter of the macro
2016-11-23T08:09:56Z |3b|: (b y) is evaluated by passing the symbol y to the macro, which expands to (+ y 1), which is evaluated as a function, by evaluating its arguments y and 1 to get 3 and 1, passing them to + to get 4
2016-11-23T08:10:14Z |3b|: (+ y 1) is evaluated as a function call
2016-11-23T08:10:23Z jusss: White_Flame: (b 3) expand to (+ 3 1) then pass (+ 3 1) to repl and get 4, I know this, and I don't know why (b 3) expand to (+ 3 1) not '(+ 3 1)
2016-11-23T08:10:23Z |3b|: (or function application if you prefer that term)
2016-11-23T08:10:44Z jusss: so I don't know why repl eat `
2016-11-23T08:10:56Z White_Flame: same thing happens with normal quote
2016-11-23T08:11:01Z White_Flame: '(1 2) => (1 2)
2016-11-23T08:11:14Z |3b|: ` and ' are processed while the form is being READ
2016-11-23T08:11:17Z White_Flame: or expanded, (quote (1 2)) => (1 2)
2016-11-23T08:11:24Z jusss: but repl eval '(1 2) then return (1 2)
2016-11-23T08:11:42Z |3b|: '(1 2) READs as (quote (1 2)), a 2 element list starting with the symbol QUOTE
2016-11-23T08:12:05Z |3b|: type (quote (1 2)) into the repl, and you will see it evaluates to the list (1 2)
2016-11-23T08:12:26Z mishoo_ joined #lisp
2016-11-23T08:12:35Z jusss: so you mean repl eat ` of the macro, then evaluate macro's expand expression and return the value
2016-11-23T08:12:37Z jusss: ?
2016-11-23T08:12:55Z White_Flame: REPL is 4 steps.
2016-11-23T08:13:08Z White_Flame: READ converts the characters in the string you typed in to a list form
2016-11-23T08:13:11Z White_Flame: (usually)
2016-11-23T08:13:17Z |3b|: `(1 2) is similarly processed when those 6 characters are READ, but CL doesn't specify exactly what you get from READing `(1 2), only that the result evaluates to the list (1 2)
2016-11-23T08:13:21Z White_Flame: so the _string_ "(b 3)" gets converted to the list (b 3)
2016-11-23T08:14:01Z |3b|: you can try doing (read-from-string "'(1 2)") and similar to see how READing works
2016-11-23T08:14:04Z Guest2_ quit (Quit: My MacBook has gone to sleep. ZZZzzz…)
2016-11-23T08:14:06Z mishoo quit (Ping timeout: 256 seconds)
2016-11-23T08:14:34Z jusss: it returns '(1 2)
2016-11-23T08:14:40Z jusss: with '
2016-11-23T08:14:41Z |3b|: (possibly with *print-pretty* set to nil)
2016-11-23T08:15:00Z |3b|: now try (car (read-from-string "'(1 2)))
2016-11-23T08:15:07Z MrMc joined #lisp
2016-11-23T08:15:31Z White_Flame: (read-from-string "`(+ ,x 1)")  =>  (SB-INT:QUASIQUOTE (+ #S(SB-IMPL::COMMA :EXPR X :KIND 0) 1))
2016-11-23T08:15:34Z |3b|:  (car (read-from-string "'(1 2)")) i mean
2016-11-23T08:15:40Z jusss: it returns quote
2016-11-23T08:15:58Z White_Flame: but yeah, (setf *print-pretty* nil) to really see the guts of what's going on
2016-11-23T08:16:00Z |3b|: right, so you see where the ' goes when the form is READ
2016-11-23T08:16:36Z |3b|: it is returning a list starting with the symbol QUOTE
2016-11-23T08:16:39Z varjag joined #lisp
2016-11-23T08:16:55Z jusss: so you mean repl's READ eat QUOTE of macro?
2016-11-23T08:16:59Z |3b|: ` does something similar, CL just doesn't specify exactly what you get from READing it
2016-11-23T08:17:09Z |3b|: READ turns the ' into QUOTE
2016-11-23T08:17:45Z jusss: yes I know ' is quote, so where's quote when (b 3) expand to (+ 3 1)
2016-11-23T08:18:12Z jusss: it should be (quote (+ 3 1))?
2016-11-23T08:18:13Z raydeejay: heh
2016-11-23T08:18:34Z LogenKain joined #lisp
2016-11-23T08:18:38Z raydeejay: the B macro expands into (QUOTE so and so)
2016-11-23T08:18:47Z |3b|: in the macro it is using ` so it doesn't end up with QUOTE in the macro
2016-11-23T08:19:08Z raydeejay: oh, now it's about backtick, sorry ^^
2016-11-23T08:19:30Z |3b|: (sorry, it is hard to explain well since it isn't specified how ` works internally, so trying to generalize from QUOTE)
2016-11-23T08:20:27Z |3b|: but thinking about it as getting (list '+ ,x '1) when you READ `(+ ,x 1) should give you some idea what it is doing
2016-11-23T08:21:11Z |3b|: if you write the macro as (defmacro b (x) (list '+ x 1)) does it make more sense what it is doing?
2016-11-23T08:21:33Z loke: |3b|: Actually, more like (list '+ x 1). While `(1 a ,b) gives something analogous to (list 1 'a b)
2016-11-23T08:21:59Z mishoo_ quit (Ping timeout: 260 seconds)
2016-11-23T08:22:33Z |3b|: loke: i think it is specified more like (list '1 'a b), though they happen to be equivalent since '1 and 1 evaluate to same thing
2016-11-23T08:22:53Z jusss: I know (defmacro b (x) (list '+ x 1)) should expand to ('+ x 1) then pass it to eval and it will be evaluated to 4
2016-11-23T08:22:56Z shka joined #lisp
2016-11-23T08:23:40Z loke: |3b|: Ah yes. I see what you mean.
2016-11-23T08:23:41Z |3b|: jusss: not quite, LIST is a normal function, so the '+ (which is (quote +)) is evaluated to get just the symbol + which is passed to LIST
2016-11-23T08:24:10Z |3b|: and X in that case is also evaluated, to whatever you passed to the macro
2016-11-23T08:24:13Z jusss: but (defmacro b (x) `(+ ,x 1)) expand to (+ 3 1) not '(+ 3 1), I don't know where's quote gone
2016-11-23T08:24:24Z |3b|: so if you did (b 3), it would expand to (+ 3 1)
2016-11-23T08:24:28Z LogenKain quit (Quit: leaving)
2016-11-23T08:24:37Z mishoo joined #lisp
2016-11-23T08:24:56Z |3b|: the `(+ ,x 1) turned into something like (list '+ x '1)
2016-11-23T08:25:32Z |3b|: when it is READ
2016-11-23T08:26:06Z |3b|: so the macro definition is the same in both cases, since the evaluation of the macro definition happens after it is READ
2016-11-23T08:26:14Z jusss: (quote (+ 3 1)) turned into (list '+ '3 '1) by READ?
2016-11-23T08:26:34Z |3b|: no, '(+ 3 1) turns into (quote (+ 3 1)) by read
2016-11-23T08:27:23Z raydeejay: I don't think you can explain quasiquote in terms of the reader and so without the other party knowing well about the reader-and-so
2016-11-23T08:27:30Z smokeink joined #lisp
2016-11-23T08:27:45Z raydeejay: s/knowing well/being familiar/
2016-11-23T08:27:48Z |3b|: or more precisely, READ turns the characters in the string "'(+ 3 1)" into the list (quote (+ 3 1)) containing the symbol QUOTE and the list (+ 3 1), containing the symbol + and numbers 3 and 1
2016-11-23T08:27:58Z jusss: (quote (+ 3 1)) is equal to ('+ '3 '1) ?
2016-11-23T08:28:08Z raydeejay: almost
2016-11-23T08:28:38Z White_Flame: quote's functionality when evaluated is to return its parameter raw
2016-11-23T08:28:47Z White_Flame: it's a special form
2016-11-23T08:30:19Z |3b|: (quote (+ 3 1)) returns the exact list (+ 3 1) created by the READer when it processed the characters in "'(+ 3 1)"
2016-11-23T08:30:34Z White_Flame: in your source code, the string "(defun x () '(1 2))" gets read into the unevaluated list (CL:DEFUN CL:X () (CL:QUOTE (1 2))
2016-11-23T08:31:03Z White_Flame: inside that form of the source code is a literal sub-list (1 2).  That gets returned by quote
2016-11-23T08:31:11Z |3b|: ('+ '3 '1) would READ as the 3 element list ((quote +) (quote 3) (quote 1)), which wouldn't evaluate since (quote +) is not the name of a function
2016-11-23T08:32:12Z jusss: so (quote (+ 3 1)) is not ('+ '3 '1)
2016-11-23T08:32:33Z raydeejay: the problem there, jusss, is the word "is"
2016-11-23T08:32:36Z White_Flame: quote returns literal source code
2016-11-23T08:32:42Z White_Flame: (list ...) builds a new list every time it's called
2016-11-23T08:33:08Z White_Flame: (defun x () (list 1 2 3)) creates a new list every time.  (defun y () '(1 2 3)) returns the exact same literal list object every time
2016-11-23T08:33:40Z Ven_ joined #lisp
2016-11-23T08:36:15Z scymtym joined #lisp
2016-11-23T08:36:35Z jusss: (defmacro b (x) (+ x 1))  (b 3) will expand to 4?
2016-11-23T08:36:49Z White_Flame: yes
2016-11-23T08:36:51Z jusss: and pass 4 to repl then get 4 again
2016-11-23T08:37:13Z White_Flame: but (let ((y 3)) (b y)) will error out, because you can't add 1 to the symbol Y
2016-11-23T08:37:29Z White_Flame: so that style of macro is kind of dangerous
2016-11-23T08:37:53Z White_Flame: since the parameters of the macro are literal source code, you want to shuffle it around and return source code, not try to grab the final numeric values themselves there
2016-11-23T08:38:06Z White_Flame: the only way the macro you wrote would work is if you pass in a literal number
2016-11-23T08:38:22Z attila_lendvai joined #lisp
2016-11-23T08:38:29Z jusss: (defmacro b (x) x)  (b '(+ 3 1)) will expand to ?
2016-11-23T08:38:47Z jusss: (+ 3 1)?
2016-11-23T08:39:05Z White_Flame: it will expand to (QUOTE (+ 3 1))
2016-11-23T08:39:32Z jusss: why this time quote don't go...
2016-11-23T08:39:38Z White_Flame: typing (b '(+ 3 1)) at the repl woudl then be equivalent to typing '(+ 3 1) or (QUOTE (+ 3 1)) and evaluated to (+ 3 1)
2016-11-23T08:40:44Z White_Flame: inside the macro, the variable X would be equal to the list (QUOTE (+ 3 1)), because that's the source code that was at that parameter to B
2016-11-23T08:42:52Z White_Flame: "(b '(+ 3 1))" reads to (CL-USER::B (CL:QUOTE (CL:+ 3 1))).  Then B is evaluated.  Because it's a macro, it gets transformed first.  It calls B with the first parameter being (CL:QUOTE (CL:+ 3 1)), and B returns that.  Then, still evaluating that call to B, that return value is further evaluated, returning the list (CL:+ 3 1)
2016-11-23T08:43:00Z White_Flame: which gets printed as the string "(+ 3 1)"
2016-11-23T08:44:41Z White_Flame: QUOTE is a way to leave source code as data
2016-11-23T08:44:58Z White_Flame: it generally doesn't stick around, except when wrangling macro bodies
2016-11-23T08:45:50Z White_Flame: do those steps at least make some sense?  :)
2016-11-23T08:46:25Z White_Flame: honestly, you dont' need to know much about macros while initially learning the language. You should get normal function evaluation and how symbols work understood first
2016-11-23T08:46:41Z White_Flame: then, you can build off what you know and start transforming the source code with macros
2016-11-23T08:47:36Z jusss: and I'm stuck in evaluate stuff
2016-11-23T08:48:11Z White_Flame: evaluation does a few things, depending on what it evaluates
2016-11-23T08:48:44Z White_Flame: numbers, keywords, arrays, and some other things just evaluate to themselves.  So their literal form passes through
2016-11-23T08:48:55Z White_Flame: evaluating (head ...params...) depends on the head
2016-11-23T08:49:11Z White_Flame: if head is a function, it calls that named function, given the parameters
2016-11-23T08:49:28Z White_Flame: (evaluating the parameters first)
2016-11-23T08:49:51Z arbv joined #lisp
2016-11-23T08:49:52Z White_Flame: if head is a macro, it will first call the function, given the parameters as raw source code, and evaluate what the macro returns.
2016-11-23T08:51:06Z White_Flame: as you see, macros behave just like functions, taking parameters and returning a new value.  They just happen with source code before actual evaluated parameters are calculated
2016-11-23T08:51:14Z jusss: yes, evaluate what the macro returns
2016-11-23T08:51:33Z Dan1973 joined #lisp
2016-11-23T08:51:50Z White_Flame: so (defmacro b (x) (+ x 1)),  (eval '(b (+ 1 2))
2016-11-23T08:52:00Z jusss: (defmacro b (x) x) macro return x, (defmacro b (x) `(+ ,x 1)) macro return `(+ ,x 1)
2016-11-23T08:52:17Z White_Flame: (b (+ 1 2)), the macro returns (+ (+ 1 2) 1), right?
2016-11-23T08:52:32Z jusss: yes
2016-11-23T08:52:37Z White_Flame: ARGH, (defmacro b (x) `(+ ,x 1)) :-P
2016-11-23T08:52:51Z White_Flame: it creates a list, inserts X as the second parameter, and returns that list
2016-11-23T08:53:23Z hjudt: i need advice for how to deal with classes and packages. i have a lot of classes with a lot of slotsthat i put in a package and i need to access these slots from another package. so i need to export the classes and accessors. this seems a lot of work (though i can delegate that to a macro). is using classes here the wrong way perhaps?
2016-11-23T08:53:37Z White_Flame: jusss: does that make more sense then?
2016-11-23T08:53:53Z White_Flame: (+ (+ 1 2) 1) is now evaluated "instead of" (b (+ 1 2))
2016-11-23T08:54:06Z |3b|: hjudt: you export /symbol/ not the things they name
2016-11-23T08:54:07Z White_Flame: which does normal function alls
2016-11-23T08:54:19Z jusss: White_Flame: return that list with quote or without?
2016-11-23T08:54:40Z hjudt: |3b|: i do not understand. what do you mean?
2016-11-23T08:54:45Z White_Flame: hjudt: many people make a custom defclass* macro which exports slot names and accessors for you
2016-11-23T08:54:48Z |3b|: but usually, yeah, you just list them (slime has shortcuts to export a symbol with a few keystrokes)
2016-11-23T08:54:59Z White_Flame: jusss: notice there weren't any quotes inside the source code
2016-11-23T08:55:09Z |3b|: hjudt: packages contain symbols, not classes, accessors, variables, or anything else
2016-11-23T08:55:34Z White_Flame: jusss: (b (+ 1 2)) is what's being evaluated, no quotes
2016-11-23T08:55:37Z jusss: White_Flame: (defmacro b (x) `(+ ,x 1))
2016-11-23T08:55:46Z |3b|: so if you export a symbol named FOO, that symbol is what is exported. whether it names nothing or names a few things
2016-11-23T08:56:07Z White_Flame: jusss: okay, yes.  That's generally equivalent to (defmacro b (x) (list '+ x 1)).  The backquote form is basically a template expansion
2016-11-23T08:56:21Z hjudt: |3b|: ok, i see, but it actually does not change the amount of work i have to do ;-)
2016-11-23T08:56:23Z White_Flame: but it returns a list of 3 elements, +, (+ 1 2), and 1
2016-11-23T08:56:27Z |3b|: right :)
2016-11-23T08:56:34Z White_Flame: jusss: there's no quotes in what's returned; it's just a list of source code
2016-11-23T08:56:47Z jusss: White_Flame: but `(+ ,x 1) isn't (list '+ x '1)
2016-11-23T08:57:13Z White_Flame: jusss: it evaluates to the same thing.   A list of +, what was passed, and 1
2016-11-23T08:57:26Z White_Flame: a _new_ list, that is
2016-11-23T08:57:29Z loke: jusss: It is, but X in this case is not the result of 1+2, but rather the form (+ 1 2) itself.
2016-11-23T08:57:41Z White_Flame: (at the toplevel)
2016-11-23T08:57:46Z robotoad quit (Quit: robotoad)
2016-11-23T08:58:09Z hjudt: |3b|: i want to use model/view/controller and am trying to split up the stuff i have now because it really got a bit too big. the problem is simply that i have a lot of different data and want to access it in the view.
2016-11-23T08:58:17Z cmatei joined #lisp
2016-11-23T08:58:51Z |3b|: hjudt: slime has slime-export-class to export accessors etc associated with a class, which might help
2016-11-23T08:58:55Z hjudt: probably i need another layer because there is data gathering, storing it in a model and presenting it in the view.
2016-11-23T08:59:24Z przl joined #lisp
2016-11-23T08:59:40Z hjudt: |3b|: thanks. my data classes are generated by macros, so i can put the export there.
2016-11-23T08:59:59Z |3b|: (in the slime-package-fu contrib, which is loaded by the slime-fancy contrib)
2016-11-23T09:00:00Z hjudt: but thanks for the hint with slime-export.
2016-11-23T09:00:31Z |3b|: yeah, if you are generating the classes from macros, exporting them there as well might be easiest solution
2016-11-23T09:01:11Z |3b|: (there are some complications with redefining the package for example when you reload the code, but possibly worth putting up with them in that case)
2016-11-23T09:01:58Z jusss: White_Flame: as you said, (defmacro b (x) (list '+ x 1)) will return what?
2016-11-23T09:02:02Z mishoo quit (Ping timeout: 258 seconds)
2016-11-23T09:02:22Z carenz joined #lisp
2016-11-23T09:02:32Z jusss: return (list '+ x 1) or ('+ x 1)?
2016-11-23T09:02:48Z White_Flame: (+ <the value of x from the macro> 1)
2016-11-23T09:03:10Z mishoo joined #lisp
2016-11-23T09:03:16Z White_Flame: when evaluating (list '+ x 1), the function LIST is called, with the literal symbol +, the value of X, and the literal 1
2016-11-23T09:03:29Z jusss: so (list '+ x 1) is evaluated in macro?
2016-11-23T09:03:37Z White_Flame: a macro body is just another function
2016-11-23T09:04:16Z White_Flame: from with in a macor, you can call anything that exists in the Lisp image at the time
2016-11-23T09:04:19Z White_Flame: *macro
2016-11-23T09:04:33Z smokeink quit (Ping timeout: 265 seconds)
2016-11-23T09:04:44Z White_Flame: helper functions, logging functions, set values, etc.  Setting stuff from inside a macro can be iffy, though
2016-11-23T09:05:14Z jusss: (list '+ x 1) is evaluated  in macro and return ('+ x 1) to repl and evaluate again, I'm right?
2016-11-23T09:05:28Z White_Flame: LIST is not a macro.  It's a function
2016-11-23T09:05:40Z White_Flame: so when (list '+ x 1) is reached, its parameters are evaluated
2016-11-23T09:05:46Z White_Flame: (efval (QUOTE X)) => X
2016-11-23T09:05:57Z White_Flame: erm, (eval (QUOTE +)) => +
2016-11-23T09:06:01Z przl quit (Ping timeout: 250 seconds)
2016-11-23T09:06:08Z White_Flame: (eval X) => <whatever source code was passed to the macro)
2016-11-23T09:06:11Z White_Flame: (eval 1) => 1
2016-11-23T09:06:26Z White_Flame: note that the EVAL takes place within the local context where X is valid
2016-11-23T09:06:32Z White_Flame: and refers to a local variable
2016-11-23T09:06:53Z Amplituhedron quit (Remote host closed the connection)
2016-11-23T09:08:04Z Amplituhedron joined #lisp
2016-11-23T09:08:08Z jusss: (defmacro b (x) x) (b '(+ 3 1)) x will evaluate to what in macro?
2016-11-23T09:08:32Z White_Flame: you already asked that
2016-11-23T09:08:42Z White_Flame: what will X be?
2016-11-23T09:08:53Z White_Flame: oh wait, this is new.  You added the quote, right?
2016-11-23T09:08:56Z jusss: (quote (+ 3 1))
2016-11-23T09:09:03Z White_Flame: yep.  So what is returned?
2016-11-23T09:09:11Z jusss: return X
2016-11-23T09:09:15Z White_Flame: (from the macro, to the evaluator)
2016-11-23T09:09:43Z jusss: return X
2016-11-23T09:10:13Z White_Flame: and what value will that return?  X doesn't exist outside the macro
2016-11-23T09:10:39Z mishoo quit (Ping timeout: 244 seconds)
2016-11-23T09:10:43Z jusss: (quote (+ 3 1)) I suppose
2016-11-23T09:11:18Z White_Flame: So that's what the macro transformed (b (quote (+ 3 1))) into, which will then be evaluated.  What does that evaluate into?
2016-11-23T09:12:18Z jusss: transformed (b (quote (+ 3 1))) into (quote (+ 3 1)) and it will be evaulted to (+ 3 1)
2016-11-23T09:12:56Z White_Flame: so there's your answer
2016-11-23T09:13:28Z White_Flame: the addition is never performed.  You returned a list that has + in front
2016-11-23T09:13:32Z mishoo joined #lisp
2016-11-23T09:16:06Z Amplituhedron quit (Remote host closed the connection)
2016-11-23T09:16:33Z Amplituhedron joined #lisp
2016-11-23T09:17:35Z jusss: White_Flame: thanks, and I will think it again
2016-11-23T09:19:39Z jusss: White_Flame: (+ 1 1) can be code also data, I'm right?
2016-11-23T09:19:50Z White_Flame: that's the strength of Lisp, yes
2016-11-23T09:20:21Z loke: Very few things in Lisp can be code but not data.
2016-11-23T09:20:31Z White_Flame: that list of 3 elements can be evaluated into 2, or be transformed around before evaluating, or injected somewhere else as custom code into other code bodies, etc.
2016-11-23T09:21:22Z White_Flame: macros can access the source code so it's nice to be able to log out the actual source code.  Can't do that easily in most languages
2016-11-23T09:22:43Z Ven_ quit (Read error: No route to host)
2016-11-23T09:23:15Z Ven_ joined #lisp
2016-11-23T09:24:46Z bogdanm joined #lisp
2016-11-23T09:26:10Z hhdave joined #lisp
2016-11-23T09:27:01Z quazimodo quit (Ping timeout: 248 seconds)
2016-11-23T09:32:55Z pierpa joined #lisp
2016-11-23T09:37:39Z cibs quit (Ping timeout: 268 seconds)
2016-11-23T09:38:50Z przl joined #lisp
2016-11-23T09:39:01Z cibs joined #lisp
2016-11-23T09:40:44Z rashmirathi joined #lisp
2016-11-23T09:45:11Z HeyFlash joined #lisp
2016-11-23T09:46:53Z rashmirathi quit (Remote host closed the connection)
2016-11-23T09:47:12Z przl quit (Ping timeout: 246 seconds)
2016-11-23T09:47:27Z rashmirathi joined #lisp
2016-11-23T09:48:57Z Ven_ quit (Quit: Textual IRC Client: www.textualapp.com)
2016-11-23T09:49:17Z Ven_ joined #lisp
2016-11-23T09:49:27Z przl joined #lisp
2016-11-23T09:50:06Z alexherbo2 quit (Quit: WeeChat 1.6)
2016-11-23T09:51:28Z rashmirathi quit (Ping timeout: 244 seconds)
2016-11-23T09:59:52Z macdavid313 joined #lisp
2016-11-23T10:03:30Z Grue` joined #lisp
2016-11-23T10:03:45Z macdavid313 quit (Read error: Connection reset by peer)
2016-11-23T10:05:18Z macdavid313 joined #lisp
2016-11-23T10:09:50Z sz0 joined #lisp
2016-11-23T10:13:53Z attila_lendvai quit (Ping timeout: 260 seconds)
2016-11-23T10:15:05Z Ven_ quit (Quit: My MacBook has gone to sleep. ZZZzzz…)
2016-11-23T10:16:47Z defaultxr quit (Ping timeout: 244 seconds)
2016-11-23T10:17:15Z attila_lendvai joined #lisp
2016-11-23T10:27:04Z nowhereman joined #lisp
2016-11-23T10:27:25Z nowhere_man quit (Ping timeout: 260 seconds)
2016-11-23T10:30:03Z EvW joined #lisp
2016-11-23T10:30:30Z shrdlu68 joined #lisp
2016-11-23T10:31:38Z przl quit (Ping timeout: 250 seconds)
2016-11-23T10:32:24Z shrdlu68: Anyone here used cl-nettle? https://github.com/orthecreedence/cl-nettle
2016-11-23T10:35:34Z shrdlu68: Never mind, found cl-ecc
2016-11-23T10:39:08Z rumbler31 joined #lisp
2016-11-23T10:40:48Z shrdlu68: Seems cl-ecc is no longer available on quicklisp, or never was to begin with.
2016-11-23T10:42:02Z MrMc quit (Remote host closed the connection)
2016-11-23T10:42:15Z MrMc joined #lisp
2016-11-23T10:43:38Z rumbler31 quit (Ping timeout: 265 seconds)
2016-11-23T10:47:18Z jusss:  /quit
2016-11-23T10:47:20Z jusss quit (Quit: ERC (IRC client for Emacs 24.5.1))
2016-11-23T10:48:27Z nullniverse joined #lisp
2016-11-23T10:50:52Z quazimodo joined #lisp
2016-11-23T10:51:38Z ducasse joined #lisp
2016-11-23T10:55:43Z Harag1 joined #lisp
2016-11-23T10:55:57Z nostoi joined #lisp
2016-11-23T10:57:10Z Harag quit (Ping timeout: 256 seconds)
2016-11-23T10:57:11Z Harag1 is now known as Harag
2016-11-23T11:01:16Z freehck quit (Ping timeout: 250 seconds)
2016-11-23T11:05:33Z sjl joined #lisp
2016-11-23T11:11:19Z madbub joined #lisp
2016-11-23T11:12:06Z d4ryus quit (Ping timeout: 250 seconds)
2016-11-23T11:15:05Z d4ryus joined #lisp
2016-11-23T11:16:12Z przl joined #lisp
2016-11-23T11:16:43Z macdavid313 quit (Quit: macdavid313)
2016-11-23T11:18:48Z groovy2shoes quit (Remote host closed the connection)
2016-11-23T11:19:42Z macdavid313 joined #lisp
2016-11-23T11:31:53Z Ven_ joined #lisp
2016-11-23T11:33:11Z sdelic joined #lisp
2016-11-23T11:38:21Z przl quit (Ping timeout: 260 seconds)
2016-11-23T11:49:13Z EvW quit (Ping timeout: 245 seconds)
2016-11-23T11:52:14Z sdelic quit (Ping timeout: 258 seconds)
2016-11-23T12:04:49Z przl joined #lisp
2016-11-23T12:04:57Z shdeng quit (Ping timeout: 260 seconds)
2016-11-23T12:05:46Z Fare joined #lisp
2016-11-23T12:10:03Z przl quit (Ping timeout: 268 seconds)
2016-11-23T12:11:12Z cibs quit (Ping timeout: 268 seconds)
2016-11-23T12:12:31Z cibs joined #lisp
2016-11-23T12:16:42Z ovenpasta joined #lisp
2016-11-23T12:19:18Z macdavid313 quit (Remote host closed the connection)
2016-11-23T12:19:42Z macdavid313 joined #lisp
2016-11-23T12:24:28Z al-damiri joined #lisp
2016-11-23T12:26:05Z m00natic joined #lisp
2016-11-23T12:30:07Z freehck joined #lisp
2016-11-23T12:30:34Z mykon: mm.. Is lisp console capable of sed operations? Even better does lisp have 1:1 list of sed features built in?
2016-11-23T12:31:11Z Cymew: What "lisp console" are you referring to? The REPL?
2016-11-23T12:31:14Z SlashLife quit (Ping timeout: 250 seconds)
2016-11-23T12:31:26Z Xach: mykon: no.
2016-11-23T12:31:43Z mykon: Cymew: sbcl console
2016-11-23T12:32:20Z Xach: mykon: I don't mind the sbcl repl that much, but most people don't use it directly, they do so via slime in emacs.
2016-11-23T12:32:30Z mykon: all right, a really dumb exercise, can I append X to an array of digits?
2016-11-23T12:32:44Z mykon: Xach: yeah that.
2016-11-23T12:33:01Z mykon: I am trying to think if what I wanna do can be made in lisp
2016-11-23T12:33:16Z Xach: mykon: Yes, it can be done. It might take a lot of work.
2016-11-23T12:33:20Z Cymew: I wasn't even aware you start a REPL that way.
2016-11-23T12:34:25Z Xach: mykon: if the array is adjustable, you can adjust it and setf the new index at the end.
2016-11-23T12:34:27Z ski quit (Ping timeout: 260 seconds)
2016-11-23T12:35:03Z Xach: well, you can use adjust-array anyway. it just might cons.
2016-11-23T12:35:09Z SlashLife joined #lisp
2016-11-23T12:35:27Z White_Flame: clhs vector-push
2016-11-23T12:35:27Z specbot: http://www.lispworks.com/reference/HyperSpec/Body/f_vec_ps.htm
2016-11-23T12:35:47Z Cymew: mykon: http://clqr.boundp.org/ is a very good reference if you want to know what's built in, array wise, list wise and so on.
2016-11-23T12:36:08Z Xach: vector-push is good if you have a fill-pointer.
2016-11-23T12:37:37Z Dan1973 quit (Ping timeout: 260 seconds)
2016-11-23T12:38:59Z vap1 joined #lisp
2016-11-23T12:39:20Z vaporatorius joined #lisp
2016-11-23T12:41:02Z rashmirathi joined #lisp
2016-11-23T12:41:05Z mykon: crazy
2016-11-23T12:41:40Z mykon: so let's say, I want to process a string and return an array. Is this doable in lisp?
2016-11-23T12:42:14Z mykon: this is the equivalent awk --> awk -v N=4 '{a[((NR-1)%N)+1]=$0} NR%N == 0 { for(i=1; i<=N; i++) { printf "%s%s", s, "X"a[i]; s=OFS }; print ""; s=""}' file.txt
2016-11-23T12:43:12Z Cymew: I can't read that mess, but of course is it doable. It's a turing complete language.
2016-11-23T12:44:46Z mykon: lisp is a language I would like to learn
2016-11-23T12:44:46Z igam joined #lisp
2016-11-23T12:44:53Z rashmirathi quit (Client Quit)
2016-11-23T12:45:06Z z0d: ,pclbook
2016-11-23T12:45:27Z z0d: mykon: start here: http://www.gigamonkeys.com/book/
2016-11-23T12:45:31Z mykon: what are the easy features to learn?
2016-11-23T12:45:33Z z0d: mykon: the full book is online for free
2016-11-23T12:46:30Z mykon: can I create a console like in "parted"?
2016-11-23T12:46:49Z z0d: mykon: yes, you can. please read the link, I've pasted
2016-11-23T12:48:06Z White_Flame: mykon: awk is a pretty specific programming language for dealing with text formatting.  Like in any other general purpose language, if you want utilities focused on that, you'll have to look at libraries
2016-11-23T12:48:14Z Cymew: I really need to get my lispbox project done...
2016-11-23T12:48:51Z Cymew: ...or remember the URL to Shinmera's one.
2016-11-23T12:49:12Z mykon: how does it look in lisp the operation of appending X to a, b, c, ? I am curious
2016-11-23T12:49:46Z Cymew: mykon: https://shinmera.github.io/portacle/ might be helpful to get an environment up and play along with the book link mentioned above.
2016-11-23T12:50:26Z White_Flame: (vector-push x some-vector), or (push x some-list), or many other things depending on what your chosen datastructures are and what features you want
2016-11-23T12:51:23Z White_Flame: but it's not a text processing language; it's a general purpose language
2016-11-23T12:51:28Z mykon: arrays are called vectors in lisp?
2016-11-23T12:51:40Z White_Flame: so don't expect heavy syntax for fiddling with such operations
2016-11-23T12:51:42Z Cymew: If you're working with lists, you can use APPEND.
2016-11-23T12:51:42Z mykon: White_Flame: I know, but I gotta start somewhere right?
2016-11-23T12:51:47Z White_Flame: Arrays are n-dimensional.  Vectors are 1-dimensional
2016-11-23T12:52:03Z igam: (let ((a '(1 2 3)) (b '(4 5 6)) (c '(7 8 9)) (x '(a b c)))   (mapcar (lambda (head) (append head x)) (list a b c))) #| --> ((1 2 3 . #1=(a b c)) (4 5 6 . #1#) (7 8 9 . #1#)) |#
2016-11-23T12:52:04Z White_Flame: ...Vectors are 1-dimensional arrays
2016-11-23T12:52:27Z mykon: wow, it looks way cleaner than the awk line above.
2016-11-23T12:52:28Z igam: strings are vectors.
2016-11-23T12:52:30Z igam: bit-vectors are vectors.
2016-11-23T12:52:30Z White_Flame: but lists (which are singly-linked lists) are the most commonly used
2016-11-23T12:52:31Z Cymew: igam: Congratulations. That was almost as scary as awk! ;)
2016-11-23T12:52:53Z igam: lists are sequences.  vectors are sequences.
2016-11-23T12:53:08Z mykon: Cymew: I disagree, it looks much more pleasant.
2016-11-23T12:53:28Z Cymew: mykon: Oh, I agree! Just still scary...
2016-11-23T12:53:32Z White_Flame: lisp has a shockingly regular syntax
2016-11-23T12:53:48Z White_Flame: every operation tends to be (op ..params...) form, no infix syntax
2016-11-23T12:53:53Z igam: With the right library you can even write: (mapcar (lcurry append x) (list a b c))
2016-11-23T12:54:09Z mykon: wow I need to get my hands on this asap
2016-11-23T12:54:37Z ovenpasta quit (Ping timeout: 240 seconds)
2016-11-23T12:54:45Z mykon: screw gurls, tits and pussy, I am gonna dovout my time to lisp.
2016-11-23T12:54:47Z Cymew: I really prefer to read code properly indented.
2016-11-23T12:56:23Z nostoi quit (Quit: Verlassend.)
2016-11-23T12:57:40Z mykon: where can I find a repository with small utilities in lisp? I'd like to peek at the sauce.
2016-11-23T12:58:34Z antoszka: mykon: for every package you download via quicklisp, you're able to browse the sauce
2016-11-23T12:58:50Z shrdlu68: mykon: https://common-lisp.net/project/alexandria/
2016-11-23T12:58:51Z antoszka: mykon: it'll be under your ~/quicklisp/dists/quicklisp/ directory
2016-11-23T12:59:53Z macdavid314 joined #lisp
2016-11-23T13:00:21Z rpg joined #lisp
2016-11-23T13:00:21Z Xach: mykon: Keep nasty comments to yourself.
2016-11-23T13:00:53Z macdavid314 quit (Client Quit)
2016-11-23T13:02:50Z macdavid314 joined #lisp
2016-11-23T13:02:54Z not-a-doctor joined #lisp
2016-11-23T13:03:01Z macdavid313 quit (Ping timeout: 248 seconds)
2016-11-23T13:03:01Z macdavid314 quit (Read error: Connection reset by peer)
2016-11-23T13:03:09Z rpg_ joined #lisp
2016-11-23T13:05:09Z carenz quit (Ping timeout: 260 seconds)
2016-11-23T13:05:32Z rpg quit (Ping timeout: 252 seconds)
2016-11-23T13:05:40Z przl joined #lisp
2016-11-23T13:06:18Z igam: Cymew: of course, but then in emacs you already have written a nice little command that identifies any sexp in erc, copies it in *scratch* and insert newlines and pretty-print it, haven't you?
2016-11-23T13:06:59Z knobo: When I start slime after opening a file with tramp or sudo, slime is started on remote computer or as root
2016-11-23T13:07:06Z knobo: How can I prevent emacs for doing that?
2016-11-23T13:07:21Z igam: mykon: or you can redirect nasty comments to #lispcafe, there we can take stronger beverages and speach ;-)
2016-11-23T13:07:39Z igam: knobo: change the current buffer first.
2016-11-23T13:07:52Z igam: (it's a feature of tramp).
2016-11-23T13:07:57Z Grue` quit (Ping timeout: 260 seconds)
2016-11-23T13:08:17Z cyraxjoe joined #lisp
2016-11-23T13:08:25Z knobo: with sudo, it does not help
2016-11-23T13:08:54Z MightyJoe quit (Ping timeout: 258 seconds)
2016-11-23T13:09:17Z macdavid313 joined #lisp
2016-11-23T13:09:36Z knobo: Slime asks for password when it starts.
2016-11-23T13:10:18Z przl quit (Ping timeout: 252 seconds)
2016-11-23T13:10:49Z sdothum joined #lisp
2016-11-23T13:12:05Z macdavid313 quit (Remote host closed the connection)
2016-11-23T13:12:31Z macdavid313 joined #lisp
2016-11-23T13:12:37Z Xach: igam: If that's the kind of discussion you want in #lispcafe, do not advertise it here.
2016-11-23T13:13:23Z knobo: But now the issue is gone for this time..
2016-11-23T13:13:45Z mykon: whoa! nasty? it was meant to be humorous!
2016-11-23T13:14:13Z przl joined #lisp
2016-11-23T13:14:20Z varjag: guess that didn't work
2016-11-23T13:15:46Z igam: Xach: I don't advertize, I redirect, as you should.
2016-11-23T13:15:53Z vaporatorius quit (Remote host closed the connection)
2016-11-23T13:15:53Z vap1 quit (Remote host closed the connection)
2016-11-23T13:15:58Z igam: Xach: instead of being repressive, be deflective!
2016-11-23T13:16:34Z Cymew: igam: I'm a bad person, with so many tasks undone! ;)
2016-11-23T13:17:16Z Xach: igam: I disagree. If you encourage people who talk that way to join #lispcafe, do not advertise #lispcafe on #lisp.
2016-11-23T13:18:00Z vap1 joined #lisp
2016-11-23T13:18:10Z vaporatorius joined #lisp
2016-11-23T13:18:58Z vaporatorius quit (Remote host closed the connection)
2016-11-23T13:18:58Z vap1 quit (Remote host closed the connection)
2016-11-23T13:19:11Z yrk joined #lisp
2016-11-23T13:19:30Z jfe joined #lisp
2016-11-23T13:19:30Z igam: Xach: how will they know where to talk like you don't like if you don't tell them where to go?
2016-11-23T13:19:42Z Cymew: Yeah, chill.
2016-11-23T13:19:43Z yrk quit (Changing host)
2016-11-23T13:19:43Z yrk joined #lisp
2016-11-23T13:20:28Z Xach: igam: That is not my concern. That kind of talk is not welcome here, and advertising a forum where it is welcome is not welcome here either.
2016-11-23T13:21:02Z Josh_2 quit (Quit: ERC (IRC client for Emacs 25.1.1))
2016-11-23T13:21:33Z igam: Well, for the next 12 hours, then you'll go back to sleep anyways.
2016-11-23T13:27:46Z xuxuru joined #lisp
2016-11-23T13:29:54Z jfe: "true tolerance tolerates the intolerant" - barak obama
2016-11-23T13:30:03Z Harag quit (Quit: Harag)
2016-11-23T13:30:03Z jfe: or was that donald trump? i don't know anymore... :)
2016-11-23T13:30:27Z Cymew: Let's take that conversation somewhere else.
2016-11-23T13:30:58Z splittist: moar lisp!
2016-11-23T13:32:44Z jackdaniel: splittist: at your service: (map () #'princ "Hello World!")
2016-11-23T13:32:57Z xuxuru quit (Quit: WeeChat 1.6)
2016-11-23T13:33:08Z jfe: "any discussion that is sufficiently meta is indistinguishable from off-topic banter." - jamie zawinski
2016-11-23T13:33:49Z absolut joined #lisp
2016-11-23T13:33:49Z JuanDaugherty: wouldn't it be great if minion could monitor and admonish the way bots on wiki autorevert?
2016-11-23T13:34:06Z NaNDude joined #lisp
2016-11-23T13:34:56Z Cymew: I could see that being ripe with false positives, and probably very tempting to "game" as well.
2016-11-23T13:35:03Z NNaNDude quit (Ping timeout: 246 seconds)
2016-11-23T13:35:37Z absolut left #lisp
2016-11-23T13:40:54Z Ven_ quit (Quit: My MacBook has gone to sleep. ZZZzzz…)
2016-11-23T13:44:01Z splittist: jackdaniel: Thanks. I wonder what the prevalence of the various CL printing forms is in, say, the default quicklisp distro...
2016-11-23T13:44:45Z igam: (format t "~A: We could probably also ~A it with ~:[false~;true~] ~:*~:[negative~;positive~]~p." "Cymew" "trick" nil 2)
2016-11-23T13:45:14Z igam: splittist: stats easily done, but I'd bet for format.
2016-11-23T13:45:30Z igam: Given that most lisp code is modern lisp code.
2016-11-23T13:48:43Z jusss joined #lisp
2016-11-23T13:49:21Z manuel__ joined #lisp
2016-11-23T13:49:30Z jusss: http://paste.ubuntu.com/23522176/    I wrote a simple nth-eval macro, and it doesn't work
2016-11-23T13:49:39Z carenz joined #lisp
2016-11-23T13:49:58Z jusss: I mean like (nth-eval (+ 1 1) 2)
2016-11-23T13:50:40Z dlowe: jusss: what are you expecting to happen?
2016-11-23T13:50:48Z dlowe: your macro isn't returning code.
2016-11-23T13:51:24Z dlowe: macros are compiler-helpers that take in code as an argument and emit code as a return value.
2016-11-23T13:51:27Z shrdlu68 quit (Ping timeout: 260 seconds)
2016-11-23T13:52:15Z jusss: dlowe: it returns 'expression '
2016-11-23T13:53:48Z dlowe: you're expecting it to return the string "expression "?
2016-11-23T13:53:48Z Ven_ joined #lisp
2016-11-23T13:53:52Z jusss: dlowe: (nth-eval (+ 1 1) 1) should return (+ 1 1) to repl, and (nth-eval (+ 1 1) 2) should return 2 to repl
2016-11-23T13:54:08Z jusss: not string "expression"
2016-11-23T13:54:23Z jusss: return code
2016-11-23T13:54:34Z dlowe: "code" can be another word for "expressions"
2016-11-23T13:55:25Z ak5 joined #lisp
2016-11-23T13:55:33Z jackdaniel: splittist: I'm using mostly format, but after seeing its implementation I'm terrified each time I use it ;-)
2016-11-23T13:56:19Z jackdaniel: like, you know, calling some sacred words moving seven spiritual spheres to get your dishes cleaned up ^_^
2016-11-23T13:56:21Z dlowe: jusss: I think you probably want to split the eval part into an nth-eval-helper function
2016-11-23T13:57:21Z EvW joined #lisp
2016-11-23T13:57:40Z test1600 quit (Quit: Leaving)
2016-11-23T13:57:56Z jusss: dlowe: how do you write a macro like nth-eval?
2016-11-23T13:58:06Z dlowe: jusss: http://paste.lisp.org/display/332285
2016-11-23T13:59:14Z dlowe: wow, botched that.
2016-11-23T13:59:19Z dlowe: check the annotation instead.
2016-11-23T13:59:33Z dlowe: serves me right for trying to write code in a text field.
2016-11-23T13:59:47Z zeissoctopus joined #lisp
2016-11-23T14:00:12Z dlowe: I don't see the use of it, but there you go
2016-11-23T14:01:18Z jusss: your expression is a (quote ...) list
2016-11-23T14:02:59Z jusss: wait, you miss a )
2016-11-23T14:04:07Z dlowe: yes, reload the page
2016-11-23T14:04:12Z dlowe: I also missed a ,
2016-11-23T14:04:14Z macdavid314 joined #lisp
2016-11-23T14:04:38Z macdavid313 quit (Ping timeout: 244 seconds)
2016-11-23T14:06:19Z macdavid314 quit (Read error: Connection reset by peer)
2016-11-23T14:07:04Z jusss: dlowe: (nth-eval (+ 1 1) 1) return (+ 1 1),
2016-11-23T14:07:16Z jusss: I suppose 2
2016-11-23T14:07:18Z dlowe: dlowe: (nth-eval (+ 1 1) 1) should return (+ 1 1) to repl, and (nth-eval (+ 1 1) 2) should return 2 to repl
2016-11-23T14:07:31Z dlowe: that is, in fact, what you specified.
2016-11-23T14:07:33Z macdavid313 joined #lisp
2016-11-23T14:07:59Z jusss: dlowe: do you see, return (+ 1 1) to repl, and repl will return 2
2016-11-23T14:08:43Z sdothum quit (Quit: ZNC - 1.6.0 - http://znc.in)
2016-11-23T14:09:37Z dlowe: the repl Reads an expression, Evaluates it, Prints the result of the evaluation, and Loops back to the beginning.
2016-11-23T14:10:16Z sdothum joined #lisp
2016-11-23T14:10:33Z dlowe: So if you wanted the macro to return (+ 1 1) to be evaluated, then the repl would print 2 regardless of n
2016-11-23T14:10:46Z jusss: yes, that's what I want
2016-11-23T14:10:53Z jusss: my bad English
2016-11-23T14:11:02Z dlowe: just change (= n 1) to (zerop n)
2016-11-23T14:11:21Z dlowe: then (nth-eval (+ 1 1) 0) will return '(+ 1 1), which sounds more reasonable, anyway
2016-11-23T14:12:51Z jusss: and what's wrong with my code?
2016-11-23T14:13:23Z y2c quit (Ping timeout: 268 seconds)
2016-11-23T14:13:37Z igam: jusss: what's wrong is that you call eval.
2016-11-23T14:13:37Z jusss: http://paste.ubuntu.com/23522176/
2016-11-23T14:13:47Z igam: This will lead to very bad scope problems.
2016-11-23T14:13:58Z dlowe: igam: let's not get into real programming
2016-11-23T14:14:05Z LiamH joined #lisp
2016-11-23T14:14:06Z igam: jusss: and we really prefer lisppaste.
2016-11-23T14:14:23Z jusss: if I dno't use eval, so how I can eval a expression some times?
2016-11-23T14:14:32Z igam: jusss: WHEN?
2016-11-23T14:14:33Z sjl: is there a function that does the inverse of clhs digit-char
2016-11-23T14:14:36Z dlowe: here's a macro-only solution: http://paste.lisp.org/display/332285#2
2016-11-23T14:14:37Z sjl: clhs digit-char
2016-11-23T14:14:37Z specbot: http://www.lispworks.com/reference/HyperSpec/Body/f_digit_.htm
2016-11-23T14:15:00Z sjl: I want to take a char and turn it into a number, given a particular radix
2016-11-23T14:15:01Z jusss: I mean eval a expression then get another expression, then eval again
2016-11-23T14:15:07Z igam: jusss: the question is when you want to evaluate? At macroexpansion time? At runtime?
2016-11-23T14:15:15Z dlowe: sjl: digit-char-p returns the digit
2016-11-23T14:15:30Z sjl: oh
2016-11-23T14:15:34Z sjl: I
2016-11-23T14:15:39Z dlowe: sjl: it's not obvious :)
2016-11-23T14:15:50Z sjl foolishly assumes anything ending in -p returns t or nil
2016-11-23T14:16:06Z jusss: igam: prefer macroexpansion time, that's possible?
2016-11-23T14:18:08Z rumbler31 joined #lisp
2016-11-23T14:18:23Z EvW quit (Ping timeout: 245 seconds)
2016-11-23T14:18:30Z igam: jusss: at macroexpansion time you won't have access to the function and to the variables.
2016-11-23T14:19:02Z igam: (defun f (x) (+ 42 x)) (let ((y 33))   (nth-eval (f y) 1) ; won't work.
2016-11-23T14:20:18Z pipping is having issues pushing/pulling to/from gitlab.common-lisp.net over SSH (HTTPS works)
2016-11-23T14:20:26Z pipping: (just hangs)
2016-11-23T14:21:26Z JuanDaugherty quit (Quit: Hibernate, reboot, exeunt, etc.)
2016-11-23T14:23:08Z pipping: (seems to work again now)
2016-11-23T14:23:55Z jusss: what about runtime?
2016-11-23T14:24:39Z White_Flame: jusss: if you want to work with runtime values, then use functions, not macros.  If you want to generate new source code, use macros
2016-11-23T14:24:47Z macdavid314 joined #lisp
2016-11-23T14:25:12Z djh quit (Quit: leaving)
2016-11-23T14:25:20Z White_Flame: if you want to statically transform source code into a more optimized state, then look at compiler macros, not regular macros
2016-11-23T14:25:24Z igam: jusss: you can generate a new expression.
2016-11-23T14:25:26Z dlowe is a believer in letting newbies do all the impractical things they want so they can explore.
2016-11-23T14:25:32Z djh joined #lisp
2016-11-23T14:25:34Z macdavid313 quit (Ping timeout: 258 seconds)
2016-11-23T14:25:36Z igam: `(- ,expression 1) for example.
2016-11-23T14:25:36Z macdavid314 is now known as macdavid313
2016-11-23T14:27:12Z igam: jusss: also, it would help if we knew what you want to do with your macro.
2016-11-23T14:27:25Z MrMc quit (Ping timeout: 265 seconds)
2016-11-23T14:27:48Z jusss: igam: eval a expression serval times,
2016-11-23T14:28:25Z EvW joined #lisp
2016-11-23T14:28:45Z jusss: like (+ 1 1) eval once, get 2, eval twice, get 2
2016-11-23T14:29:05Z White_Flame: (defmacro three-times (x) `(progn ,x ,x ,x))
2016-11-23T14:29:26Z dlowe: What I eval three times is T.
2016-11-23T14:29:29Z jusss: if there's an expression, eval it and get another expression, then you can eval it and then eval it, again and again
2016-11-23T14:29:50Z dlowe: jusss: you know, I did just give you how to do it a while back.
2016-11-23T14:29:54Z dlowe: jusss: with just a macro
2016-11-23T14:30:04Z dlowe: http://paste.lisp.org/display/332285#2
2016-11-23T14:30:33Z jusss: yes, I see, and I don't know the problem within my code
2016-11-23T14:30:53Z cromachina quit (Read error: Connection reset by peer)
2016-11-23T14:31:05Z dlowe: jusss: there are a few problems. One is that you can't really recurse with macros. You can emit code that calls the macro again.
2016-11-23T14:31:07Z White_Flame: you need to think about what the generated code should be
2016-11-23T14:31:14Z igam: So (defmacro eval-n-times (n expression) `(loop repeat ,n do ,expression))  (eval-n-times 3 (princ 'hi)) #| hihihi --> nil |#
2016-11-23T14:31:36Z igam: Here the generated code looks like: (macroexpand-1 '(eval-n-times 3 (princ 'hi))) #| --> (loop repeat 3 do (princ 'hi)) ; t |#
2016-11-23T14:31:42Z White_Flame: so if you have (foo x 3), and that should generate (eval (eval (eval x))), then try constructing a form like that from code.  Then put that code into the macro body
2016-11-23T14:32:02Z dlowe: jusss: anyway, if you want a learning-only CL channel, there's #clnoobs
2016-11-23T14:33:47Z alexherbo2 joined #lisp
2016-11-23T14:34:03Z Tarap joined #lisp
2016-11-23T14:35:01Z igam: (defmacro eval* (expression n) (let ((r (gensym))) `(loop for ,r := ,expression :repeat ,n :do (setf ,r (eval ,r)) :finally (return ,r))))  (macroexpand-1 '(eval* x 3))  #| --> (loop for #1=#:g6903 := x :repeat 3 :do (setf #1# (eval #1#)) :finally (return #1#)) ; t |#
2016-11-23T14:35:51Z rszeno joined #lisp
2016-11-23T14:37:31Z igam: Now, you can optimize it when n is an integer:   (defmacro eval* (expression n) (if (integerp n) (wrap-calls n 'eval expression) (let ((r (gensym))) `(loop for ,r := ,expression :repeat ,n :do (setf ,r (eval ,r)) :finally (return ,r)))))  (defun wrap-calls (n fun val) (if (zerop n) val (wrap-calls (1- n) fun `(,fun ,val))))  (macroexpand-1 '(eval* x 3)) #| --> (eval (eval (eval x))) ; t |#
2016-11-23T14:40:26Z Grue` joined #lisp
2016-11-23T14:46:16Z FreeBirdLjj joined #lisp
2016-11-23T14:48:13Z oleo joined #lisp
2016-11-23T14:49:59Z manuel__ quit (Quit: manuel__)
2016-11-23T14:50:37Z FreeBirdLjj quit (Ping timeout: 260 seconds)
2016-11-23T14:51:33Z Ioann joined #lisp
2016-11-23T14:51:41Z zeissoctopus quit (Quit: Leaving)
2016-11-23T14:52:13Z zeissoctopus joined #lisp
2016-11-23T14:53:35Z mishoo quit (Ping timeout: 256 seconds)
2016-11-23T14:53:56Z Dan1973 joined #lisp
2016-11-23T14:54:31Z Xach: What does a bare ":" read as in allegro CL?
2016-11-23T14:55:01Z mrottenkolber joined #lisp
2016-11-23T14:57:12Z jusss quit (Quit: ERC Version 5.3 (IRC client for Emacs))
2016-11-23T14:57:32Z ovenpasta joined #lisp
2016-11-23T14:58:33Z Xach: CLISP reads it as :||, ccl and sbcl signal an error.
2016-11-23T14:58:55Z vaporatorius joined #lisp
2016-11-23T14:59:36Z oleo: try |:|
2016-11-23T14:59:57Z Xach: oleo: Why?
2016-11-23T15:00:03Z rpg_ quit (Quit: Textual IRC Client: www.textualapp.com)
2016-11-23T15:00:10Z oleo: well the bars are for escaping
2016-11-23T15:00:17Z oleo: if you want a literal :
2016-11-23T15:00:31Z Xach: oleo: I would like to know what allegro does, not how to achieve a symbol named ":".
2016-11-23T15:00:53Z PuercoPop: oleo: he doesn't want the symbol :, but wonders how every implementation treats the package marker
2016-11-23T15:00:54Z Xach: e.g. what does (:foo : :bar) read as.
2016-11-23T15:01:06Z oleo: otherwise a keyword designator without a keyname is an error afaik.....
2016-11-23T15:01:11Z oleo: oh
2016-11-23T15:01:45Z PuercoPop: ECL prints Unknown top level command :||
2016-11-23T15:01:53Z dlowe: seems like if you can make a || symbol, you should be able to make a keyword::||
2016-11-23T15:02:07Z dlowe: ah, it's :|| in sbcl
2016-11-23T15:02:07Z jackdaniel: PuercoPop: only in repl from cli
2016-11-23T15:02:11Z jackdaniel: it's generally :||
2016-11-23T15:02:15Z jackdaniel: the same with ABCL
2016-11-23T15:02:20Z oleo: (:foo :bar) a function, and it's argument, to be looked up in the keyword package ?
2016-11-23T15:02:25Z oleo: dunno
2016-11-23T15:02:50Z PuercoPop: jackdaniel: my ABCL returns the keyword :||
2016-11-23T15:02:55Z jackdaniel: same as ECL
2016-11-23T15:03:01Z splittist: what errors do ccl and sbcl signal?
2016-11-23T15:03:52Z jackdaniel: splittist: sbcl has "illegal terminating character after a colon: #\Newline"
2016-11-23T15:04:05Z PuercoPop: which in retrospect seems, at least intuitively, the correct behavior.
2016-11-23T15:04:17Z rippa joined #lisp
2016-11-23T15:04:20Z PuercoPop: me wonders if this would be considered a bug in the reader of the other implementations
2016-11-23T15:04:40Z PuercoPop: */me
2016-11-23T15:04:47Z jackdaniel: (make-symbol "") returns #:||, so its not illegal to have symbol with empty string as name
2016-11-23T15:05:56Z Xach: oleo: I asked what it reads as, not what it evaluates to.
2016-11-23T15:06:21Z Xach: PuercoPop: abcl returns :|| in the middle of (:foo : :bar)?
2016-11-23T15:06:52Z manuel__ joined #lisp
2016-11-23T15:07:20Z jackdaniel: CL-USER(1): (list :b : :c) ; => (:B :|| :C) ; <- abcl's
2016-11-23T15:07:24Z PuercoPop: Xach: yes, their reader appears to treat : as a keyword with the empty string as its name consistently
2016-11-23T15:07:45Z oleo: Xach: ya in mine too ': -> :||, (type-of *) -> KEYWORD
2016-11-23T15:07:50Z splittist: 2.3.5 doesn't seem dispositive
2016-11-23T15:07:58Z Xach: Thanks. I wonder if this is undefined/implementation-defined or a violation.
2016-11-23T15:08:06Z Xach: oleo: in what implementation?
2016-11-23T15:08:17Z oleo: sbcl
2016-11-23T15:08:48Z oleo: sbcl-1.3.11, in my clim-listener session
2016-11-23T15:09:39Z PuercoPop: oleo: but you shoudn't need to quote it, keywords are self-evaluating
2016-11-23T15:09:46Z jackdaniel: clim-listener doesn't share a reader with the underlying implementation
2016-11-23T15:10:03Z oleo: welp, in my normal repl it doesn't evaluate, it waits for more input or so....
2016-11-23T15:11:17Z Xach: splittist: what do you mean by that?
2016-11-23T15:12:54Z oleo: Xach: i have linedit in my normal repl..... that's why, i tried it on a bare sbcl --no-sysinit --no-userinit it errors with "illegal terminating character after a colon"
2016-11-23T15:13:33Z splittist: Xach: I mean it doesn't rule in or out a bare : . Neither does the reader algorithm, on my (quick) reading.
2016-11-23T15:13:34Z Xach: sounds like another riveting tale of Bob Murmanek, Proctologist/Coroner/Sleuth!
2016-11-23T15:13:46Z oleo: PuercoPop: ya, you right i don't need to quote it
2016-11-23T15:14:50Z Xach: anyway, I have a source file with a bare ":" that I think is unintentional.
2016-11-23T15:15:16Z warweasle joined #lisp
2016-11-23T15:15:20Z Xach: It's part of an html generation syntax, so it may actually have significant value as a keyword.
2016-11-23T15:15:47Z Xach: It's also at least 16 years old, so it certainly doesn't pose a problem for the host Lisp.
2016-11-23T15:18:02Z warweasle: Hello. I'm off work today!
2016-11-23T15:19:22Z Dan1973 quit (Ping timeout: 268 seconds)
2016-11-23T15:19:37Z Xach: More time for clinch!
2016-11-23T15:20:13Z warweasle: Xach: YES!
2016-11-23T15:20:35Z warweasle: Xach: I'm working on my GUI stuff now. I can't figure out the renderplanning
2016-11-23T15:20:44Z oleo: http://paste.lisp.org/+74EA
2016-11-23T15:21:36Z Ioann quit (Quit: WeeChat 1.6)
2016-11-23T15:21:43Z PuercoPop: My understanding of the reader algorithm is that ":" should be read as a keyword with the empty string as its name
2016-11-23T15:25:08Z mishoo joined #lisp
2016-11-23T15:27:10Z splittist: PuercoPop: the algo itself just says that a token will be returned unless it's not of valid syntax.
2016-11-23T15:28:19Z zeissoctopus quit (Quit: Leaving)
2016-11-23T15:28:55Z rpg joined #lisp
2016-11-23T15:28:55Z rpg quit (Client Quit)
2016-11-23T15:29:07Z rpg joined #lisp
2016-11-23T15:29:39Z oleo: (SB-IMPL::READ-TOKEN #<SB-IMPL::STRING-INPUT-STREAM {1002A98B13}> #\:)
2016-11-23T15:29:54Z oleo: after trying to read it in via (read-froms-string ":")
2016-11-23T15:30:07Z oleo: unexpected end of file on #<SB-IMPL::STRING-INPUT-STREAM {1002A98B13}> after reading a colon
2016-11-23T15:32:09Z ak5 quit (Quit: WeeChat 1.6)
2016-11-23T15:32:25Z ak5 joined #lisp
2016-11-23T15:32:36Z rszeno quit (Quit: Leaving.)
2016-11-23T15:33:03Z EvW quit (Remote host closed the connection)
2016-11-23T15:33:07Z igam: oleo: : alone is an implementation specific token.
2016-11-23T15:33:27Z igam: as are :: and anything:::anything etc.
2016-11-23T15:33:35Z robotoad joined #lisp
2016-11-23T15:33:44Z oleo: it's not the reader which is at fault........
2016-11-23T15:33:48Z rpg quit (Ping timeout: 258 seconds)
2016-11-23T15:33:49Z oleo: that much is clear....
2016-11-23T15:34:19Z oleo: when you backtrace it you see that it is read via (read-preserving-whitespace) (read-maybe-nothing) (read-token)....
2016-11-23T15:34:36Z oleo: where it errors is in the context of a stream......
2016-11-23T15:35:09Z EvW joined #lisp
2016-11-23T15:35:46Z ak5 quit (Client Quit)
2016-11-23T15:36:00Z sjl quit (Ping timeout: 250 seconds)
2016-11-23T15:36:21Z oleo: what does a space in the context of a stream designate ?
2016-11-23T15:36:27Z oleo: isn't that like the end of the stream ?
2016-11-23T15:38:22Z splittist: As a programmer, rather than an implementor, using :|| (in analogy to ||) seems best practice if you really want to refer to the symbol in the KEYWORD package with the empty string as a name.
2016-11-23T15:38:47Z igam: splittist: indeed.
2016-11-23T15:40:18Z MoALTz_ joined #lisp
2016-11-23T15:40:28Z varjag quit (Quit: ERC Version 5.3 (IRC client for Emacs))
2016-11-23T15:42:58Z BusFactor1 joined #lisp
2016-11-23T15:43:33Z MoALTz quit (Ping timeout: 248 seconds)
2016-11-23T15:46:49Z manuel__ quit (Quit: manuel__)
2016-11-23T15:46:50Z carenz quit (Ping timeout: 250 seconds)
2016-11-23T15:48:54Z Ven_ quit (Quit: My MacBook has gone to sleep. ZZZzzz…)
2016-11-23T15:48:55Z robotoad quit (Quit: robotoad)
2016-11-23T15:49:05Z rpg joined #lisp
2016-11-23T15:52:54Z flamebeard quit (Quit: Leaving)
2016-11-23T15:53:50Z robotoad joined #lisp
2016-11-23T15:54:00Z Ven_ joined #lisp
2016-11-23T15:54:12Z ovenpasta quit (Ping timeout: 252 seconds)
2016-11-23T15:54:28Z quazimodo quit (Quit: leaving)
2016-11-23T15:54:45Z quazimodo joined #lisp
2016-11-23T16:00:31Z robotoad quit (Quit: robotoad)
2016-11-23T16:04:53Z Ven_ quit (Quit: My MacBook has gone to sleep. ZZZzzz…)
2016-11-23T16:06:26Z sjl joined #lisp
2016-11-23T16:07:53Z eivarv joined #lisp
2016-11-23T16:07:57Z HeyFlash quit (Ping timeout: 265 seconds)
2016-11-23T16:11:30Z y2c joined #lisp
2016-11-23T16:11:49Z y2c quit (Max SendQ exceeded)
2016-11-23T16:11:51Z robotoad joined #lisp
2016-11-23T16:12:17Z karswell` quit (Ping timeout: 260 seconds)
2016-11-23T16:12:52Z shka quit (Quit: Konversation terminated!)
2016-11-23T16:16:09Z macdavid313 quit (Quit: macdavid313)
2016-11-23T16:20:54Z manuel__ joined #lisp
2016-11-23T16:23:03Z eivarv quit (Quit: Sleep)
2016-11-23T16:29:18Z ovenpasta joined #lisp
2016-11-23T16:30:45Z rlatimore joined #lisp
2016-11-23T16:32:01Z sellout- joined #lisp
2016-11-23T16:33:10Z mishoo quit (Quit: (save-lisp-and-die))
2016-11-23T16:33:48Z EvW quit (Ping timeout: 245 seconds)
2016-11-23T16:34:42Z eivarv joined #lisp
2016-11-23T16:39:00Z mishoo joined #lisp
2016-11-23T16:40:44Z TDT joined #lisp
2016-11-23T16:40:46Z sellout- quit (Quit: Leaving.)
2016-11-23T16:43:08Z gingerale joined #lisp
2016-11-23T16:43:19Z w37 joined #lisp
2016-11-23T16:46:39Z FreeBirdLjj joined #lisp
2016-11-23T16:47:47Z rpg quit (Ping timeout: 258 seconds)
2016-11-23T16:48:38Z NeverDie joined #lisp
2016-11-23T16:50:48Z defaultxr joined #lisp
2016-11-23T16:51:40Z FreeBirdLjj quit (Ping timeout: 260 seconds)
2016-11-23T16:51:59Z varjag joined #lisp
2016-11-23T16:55:00Z shrdlu68 joined #lisp
2016-11-23T16:55:14Z mrf3000 joined #lisp
2016-11-23T16:56:24Z shrdlu68: In emacs, is there a way to select a region enclosed in matching parens?
2016-11-23T16:57:01Z shrdlu68: i.e by placing the cursor on one of the parens, the region up to the matching paren is selected.
2016-11-23T16:59:12Z m_zr0 joined #lisp
2016-11-23T17:00:02Z PuercoPop: shrdlu68: ctrl-space
2016-11-23T17:00:02Z igam: Move to the openning parenthesis, C-SPC C-M-f
2016-11-23T17:00:21Z igam: Alternatively, Move to the closing parenthesis and C-SPC C-M-b
2016-11-23T17:03:22Z minion quit (Disconnected by services)
2016-11-23T17:03:25Z minion joined #lisp
2016-11-23T17:03:28Z AntiSpamMeta quit (Killed (sinisalo.freenode.net (Nickname regained by services)))
2016-11-23T17:03:47Z PuercoPop: igam: from the closing parenthesis I prefer C-- C-SPC
2016-11-23T17:05:58Z safe joined #lisp
2016-11-23T17:06:05Z safe quit (Remote host closed the connection)
2016-11-23T17:08:34Z AntiSpamMeta joined #lisp
2016-11-23T17:11:10Z vlatkoB quit (Remote host closed the connection)
2016-11-23T17:13:59Z vlatkoB joined #lisp
2016-11-23T17:15:06Z eivarv quit (Quit: Quit)
2016-11-23T17:16:33Z m_zr0 quit (Quit: leaving)
2016-11-23T17:16:35Z eivarv joined #lisp
2016-11-23T17:17:40Z EvW joined #lisp
2016-11-23T17:19:24Z m_zr0 joined #lisp
2016-11-23T17:21:21Z Davidbrcz joined #lisp
2016-11-23T17:24:37Z Grue` quit (Ping timeout: 260 seconds)
2016-11-23T17:26:49Z shka_ joined #lisp
2016-11-23T17:32:03Z algae joined #lisp
2016-11-23T17:32:03Z eivarv quit (Quit: Sleep)
2016-11-23T17:32:33Z Davidbrcz quit (Ping timeout: 260 seconds)
2016-11-23T17:34:21Z eivarv joined #lisp
2016-11-23T17:34:37Z Karl_Dscc joined #lisp
2016-11-23T17:39:17Z hhdave quit (Ping timeout: 248 seconds)
2016-11-23T17:46:02Z xuxuru joined #lisp
2016-11-23T17:47:36Z macdavid313 joined #lisp
2016-11-23T17:48:59Z quazimodo quit (Ping timeout: 260 seconds)
2016-11-23T17:49:02Z przl quit (Ping timeout: 250 seconds)
2016-11-23T17:50:16Z macdavid314 joined #lisp
2016-11-23T17:50:20Z ASau joined #lisp
2016-11-23T17:50:26Z macdavid313 quit (Read error: Connection reset by peer)
2016-11-23T17:52:28Z CEnnis91 joined #lisp
2016-11-23T17:53:28Z macdavid313 joined #lisp
2016-11-23T17:54:28Z macdavid314 quit (Ping timeout: 252 seconds)
2016-11-23T17:55:15Z ovenpasta quit (Ping timeout: 265 seconds)
2016-11-23T17:57:09Z macdavid313 quit (Remote host closed the connection)
2016-11-23T17:57:36Z macdavid313 joined #lisp
2016-11-23T17:59:38Z MrMc joined #lisp
2016-11-23T18:00:53Z mrf3000 quit
2016-11-23T18:01:29Z m00natic quit (Remote host closed the connection)
2016-11-23T18:01:41Z Fare quit (Ping timeout: 260 seconds)
2016-11-23T18:08:31Z NeverDie quit (Ping timeout: 256 seconds)
2016-11-23T18:12:40Z y2c joined #lisp
2016-11-23T18:16:36Z ovenpasta joined #lisp
2016-11-23T18:29:09Z NeverDie joined #lisp
2016-11-23T18:29:30Z neoncontrails joined #lisp
2016-11-23T18:30:03Z rlatimore quit (Ping timeout: 256 seconds)
2016-11-23T18:30:41Z redcedar joined #lisp
2016-11-23T18:32:57Z scymtym quit (Ping timeout: 240 seconds)
2016-11-23T18:37:25Z bogdanm quit (Ping timeout: 258 seconds)
2016-11-23T18:38:24Z django_ joined #lisp
2016-11-23T18:38:49Z django_: so what have you guys built with lisp?
2016-11-23T18:39:58Z marusich quit (Quit: Leaving)
2016-11-23T18:40:04Z rpg joined #lisp
2016-11-23T18:41:59Z EvW quit (Remote host closed the connection)
2016-11-23T18:42:59Z nullniverse quit (Quit: Leaving)
2016-11-23T18:43:11Z sweater joined #lisp
2016-11-23T18:46:30Z rlatimore joined #lisp
2016-11-23T18:47:03Z BlueRavenGT joined #lisp
2016-11-23T18:50:43Z crupizkas joined #lisp
2016-11-23T18:51:15Z EvW1 joined #lisp
2016-11-23T18:53:37Z ovenpasta quit (Ping timeout: 240 seconds)
2016-11-23T18:54:40Z ovenpasta joined #lisp
2016-11-23T18:56:34Z rlatimore quit (Read error: Connection reset by peer)
2016-11-23T18:57:20Z BlueRavenGT quit (Read error: Connection reset by peer)
2016-11-23T19:00:37Z django_ quit (Quit: Leaving)
2016-11-23T19:01:47Z NeverDie quit (Ping timeout: 260 seconds)
2016-11-23T19:01:49Z NeverDie_ joined #lisp
2016-11-23T19:02:45Z pipping: flip214: I'm confident that the asdf-3.2.0 release will happen this week.
2016-11-23T19:03:13Z MrWoohoo quit (Ping timeout: 268 seconds)
2016-11-23T19:03:29Z pipping quit (Quit: WeeChat 1.5)
2016-11-23T19:07:11Z bobo joined #lisp
2016-11-23T19:10:30Z klltkr joined #lisp
2016-11-23T19:10:35Z klltkr: Hello
2016-11-23T19:10:43Z klltkr quit (Changing host)
2016-11-23T19:10:43Z klltkr joined #lisp
2016-11-23T19:13:55Z rpg quit (Read error: Connection reset by peer)
2016-11-23T19:14:15Z rpg joined #lisp
2016-11-23T19:16:28Z NeverDie_ is now known as NeverDie
2016-11-23T19:17:24Z dddddd joined #lisp
2016-11-23T19:21:17Z dilated_dinosaur quit (Ping timeout: 265 seconds)
2016-11-23T19:22:47Z bocaneri quit (Read error: Connection reset by peer)
2016-11-23T19:25:24Z karswell` joined #lisp
2016-11-23T19:26:40Z phoe: klltkr: Hey
2016-11-23T19:32:22Z karswell` is now known as karswell
2016-11-23T19:38:18Z dilated_dinosaur joined #lisp
2016-11-23T19:38:34Z scymtym joined #lisp
2016-11-23T19:40:11Z jfe quit (Remote host closed the connection)
2016-11-23T19:42:21Z pierpa quit (Remote host closed the connection)
2016-11-23T19:43:22Z travv0 joined #lisp
2016-11-23T19:44:52Z mathrick joined #lisp
2016-11-23T19:45:59Z terpri quit (Remote host closed the connection)
2016-11-23T19:47:34Z rippa quit (Quit: {#`%${%&`+'${`%&NO CARRIER)
2016-11-23T19:49:51Z mvilleneuve joined #lisp
2016-11-23T19:50:35Z warweasle is now known as warweasle_bbib
2016-11-23T19:53:09Z papachan joined #lisp
2016-11-23T19:53:28Z EvW1 quit (Quit: EvW1)
2016-11-23T19:53:50Z EvW joined #lisp
2016-11-23T19:56:12Z shrdlu68 quit (Ping timeout: 252 seconds)
2016-11-23T19:57:32Z madbub quit (Remote host closed the connection)
2016-11-23T19:57:35Z NeverDie_ joined #lisp
2016-11-23T19:58:10Z sjl quit (Read error: Connection reset by peer)
2016-11-23T19:59:02Z NeverDie quit (Ping timeout: 250 seconds)
2016-11-23T20:02:24Z macdavid314 joined #lisp
2016-11-23T20:02:54Z macdavid313 quit (Ping timeout: 258 seconds)
2016-11-23T20:02:55Z macdavid314 is now known as macdavid313
2016-11-23T20:04:54Z Oladon1 joined #lisp
2016-11-23T20:07:16Z Oladon quit (Ping timeout: 250 seconds)
2016-11-23T20:08:30Z NeverDie_ is now known as NeverDie
2016-11-23T20:08:56Z mingus joined #lisp
2016-11-23T20:13:09Z grublet joined #lisp
2016-11-23T20:19:46Z mishoo_ joined #lisp
2016-11-23T20:21:32Z stux|RC-only quit (Ping timeout: 268 seconds)
2016-11-23T20:21:35Z mishoo quit (Ping timeout: 260 seconds)
2016-11-23T20:22:46Z MrWoohoo joined #lisp
2016-11-23T20:24:05Z stux|RC-only joined #lisp
2016-11-23T20:30:52Z shka_: hey folks
2016-11-23T20:31:01Z shka_: what is opinion on ABCL?
2016-11-23T20:31:08Z shka_: is it worth a try?
2016-11-23T20:31:31Z Xach: abcl is great
2016-11-23T20:31:46Z Xach: it is actively developed by people who use it for work projects
2016-11-23T20:32:51Z Xach: I don't use it because SBCL works for me for my tasks. SBCL is faster and more mature. But no other CL runs on the JVM like ABCL does.
2016-11-23T20:33:09Z Xach: All active CLs are pretty great in their own ways.
2016-11-23T20:33:38Z younder: whatever
2016-11-23T20:34:26Z akkad: abcl is quite nice. as long as you have the full maven install, things work quite well.
2016-11-23T20:35:06Z akkad: younder: you have a preference?
2016-11-23T20:35:16Z vlatkoB quit (Remote host closed the connection)
2016-11-23T20:35:16Z akkad runs out of troll food
2016-11-23T20:35:55Z akkad: options are nice
2016-11-23T20:37:56Z Davidbrcz joined #lisp
2016-11-23T20:37:58Z swflint quit (Ping timeout: 245 seconds)
2016-11-23T20:37:58Z itruslove quit (Ping timeout: 245 seconds)
2016-11-23T20:41:29Z younder: akkad, we have had a long and heated discussion about this before. Suffice it to say that among the free alternatives I prefer SBCL.
2016-11-23T20:42:26Z flip214: I can't tell the reader that symbols interned into one specific package shouldn't be case-inverted, right?
2016-11-23T20:42:36Z mvilleneuve left #lisp
2016-11-23T20:42:37Z shka_: Xach: thanks!
2016-11-23T20:42:58Z rpg quit (Ping timeout: 265 seconds)
2016-11-23T20:43:05Z Xach: flip214: no, that is controlled by a special variable that is not tied to a package object.
2016-11-23T20:43:21Z jackdaniel: flip214: each time you set in-package set also readtable-case
2016-11-23T20:43:49Z jackdaniel: *package* and *readtable* are both file-local
2016-11-23T20:43:51Z xuxuru quit (Quit: WeeChat 1.6)
2016-11-23T20:44:16Z younder: I might have prefered LispWorks but I find it's pricing on a personal 64 bit version to high for my uses.
2016-11-23T20:45:32Z jackdaniel: (but that will affect every read symbol of course)
2016-11-23T20:48:45Z flip214: jackdaniel: no, I'm using one package to uniquify strings.
2016-11-23T20:49:05Z flip214: but the string being read/written to the outside world is eg. "name";
2016-11-23T20:49:22Z flip214: now I'd like to _not_ need to write §::|name| each time I'm using that in my code.
2016-11-23T20:50:07Z flip214: so, for that one package, I'd like to have a readtable-case of :preserve ...
2016-11-23T20:50:12Z flip214: but of course not for other packages.
2016-11-23T20:50:22Z flip214: perhaps the easiest thing would be to make § a reader macro ;)
2016-11-23T20:50:29Z younder: Case sensitivity tends to mess with compatabillity when you try to share a module and is generally more troble than it is worth in my experience.
2016-11-23T20:51:25Z younder: You can get it to display downcase, if that is what you want.
2016-11-23T20:51:31Z flip214: younder: yeah, thanks for the heads-up.
2016-11-23T20:51:47Z flip214: I'd like to avoid upcase/downcase etc.... that just messing around.
2016-11-23T20:52:11Z flip214: guess I'll go the reader macro way if it really bothers me.
2016-11-23T20:53:37Z ovenpasta quit (Ping timeout: 240 seconds)
2016-11-23T20:56:27Z younder: What do you mean with the reader macro way?
2016-11-23T20:56:54Z bogdanm joined #lisp
2016-11-23T20:57:51Z warweasle_bbib is now known as warweasle
2016-11-23T20:58:30Z Xach: younder: you could make $foo read as a symbol named "foo" rather than one named "$FOO".
2016-11-23T20:58:59Z Xach: You install a reader macro on $ that reads the subsequent symbol syntax and interns it the way you want.
2016-11-23T20:59:33Z PinealGlandOptic joined #lisp
2016-11-23T21:00:06Z younder: Xach, I think he means readtable-case (:ipdate, :downcase,or :preserve)
2016-11-23T21:00:14Z younder: update
2016-11-23T21:00:55Z Xach: younder: No, I think that is a means to an end, and a read macro is a separate one that may work better for his use-case.
2016-11-23T21:01:31Z BlueRavenGT joined #lisp
2016-11-23T21:02:17Z FreeBirdLjj joined #lisp
2016-11-23T21:03:23Z crupizkas quit (Remote host closed the connection)
2016-11-23T21:04:22Z younder: flip214, Xach has a point you could do  (let  (*readtable* (copy-readtable nil)) and then locally do a (readtable-case ..)
2016-11-23T21:05:48Z younder: Remember special variables work for all function calls in that scome. It is not lexical.
2016-11-23T21:05:58Z younder: scope
2016-11-23T21:06:55Z FreeBirdLjj quit (Ping timeout: 258 seconds)
2016-11-23T21:07:09Z Guest2 joined #lisp
2016-11-23T21:07:21Z BlueRavenGT quit (Read error: Connection reset by peer)
2016-11-23T21:07:35Z mathrick quit (Ping timeout: 256 seconds)
2016-11-23T21:07:46Z akkad: younder: ahh pooor. understood
2016-11-23T21:09:59Z stepnem quit (Ping timeout: 258 seconds)
2016-11-23T21:11:24Z MrMc quit (Ping timeout: 244 seconds)
2016-11-23T21:11:24Z develope1 joined #lisp
2016-11-23T21:12:10Z NeverDie quit (Quit: http://radiux.io/)
2016-11-23T21:13:45Z ovenpasta joined #lisp
2016-11-23T21:17:40Z develope1 quit (Quit: leaving)
2016-11-23T21:20:04Z younder: Special variables have been used to great effect in format where the behaviour is 'what you want'. In this region let all format command behave in this way. However I feel changing the case sensitivity of the read tabe 'for some parts' really doesn't work.
2016-11-23T21:24:12Z younder: Again :lowercase and :uppercase are fine. :preserve is tha djinn that promises more than it can deliver.
2016-11-23T21:27:47Z Xach: rob warnock advocated for :invert from time to time.
2016-11-23T21:28:44Z aeth: I prefer inverting the case of things because it can go round trip, but otherwise for the msot common use case of UPPER->lower looks as expected when e.g. writing to files and then reading them back
2016-11-23T21:28:48Z macdavid313 quit (Remote host closed the connection)
2016-11-23T21:29:05Z aeth: If it's just UPPER->lower and then lower->UPPER, data's lost in the rare case that someone actually did use lower case
2016-11-23T21:29:16Z aeth: iirc
2016-11-23T21:29:53Z younder: I feel the major reason for this is estetic. UPPERCASE feels to much like shouting.
2016-11-23T21:30:14Z algae quit (Quit: leaving)
2016-11-23T21:30:38Z redcedar quit (Quit: Connection closed for inactivity)
2016-11-23T21:31:22Z travv0 quit (Disconnected by services)
2016-11-23T21:33:12Z aeth: I don't think inverting has this proprety when using unicode, though. The Greek sigma has two lower case forms and only one upper case one, and that's probably not the only case of that.
2016-11-23T21:33:17Z Ricchi joined #lisp
2016-11-23T21:35:18Z travv0 joined #lisp
2016-11-23T21:35:40Z fiddlerwoaroof: /join #postgresql
2016-11-23T21:35:41Z fiddlerwoaroof:  
2016-11-23T21:35:47Z fiddlerwoaroof: :) ...
2016-11-23T21:35:59Z younder: aeth, I never considered unicode.
2016-11-23T21:36:48Z mrottenkolber quit (Ping timeout: 250 seconds)
2016-11-23T21:37:08Z aeth: People are increasingly considering Unicode now that software is increasingly using Emoji fonts instead of image-based emoticons/smilies.
2016-11-23T21:37:20Z aeth: It's sad that Emoji is driving decent Unicode support in places.
2016-11-23T21:37:33Z younder: Lisp is a lod lanuage so it predates unicode and it is probaly the reason it shouts it's resposes in uppercase.
2016-11-23T21:37:36Z younder: old
2016-11-23T21:38:25Z aeth: There are plenty of other old languages that dropped that behavior. CL should have gotten rid of that more than 15 years ago... but it hasn't had a new spec in a long time...
2016-11-23T21:38:57Z younder: No, and it probaly never will, as far as I can see.
2016-11-23T21:39:06Z aeth: Like the US switching to metric, the longer it takes to switch the more painful switching will become.
2016-11-23T21:39:18Z aeth: So naturally like the US switching to metric, it'll be procrastinated as long as possible :p
2016-11-23T21:40:01Z younder: All I can say is to best of my knowlege there is no incentive to create a new standard.
2016-11-23T21:40:35Z aeth: there isn't afaik.
2016-11-23T21:40:56Z aeth: We're stuck with portability libraries over implementation-specific implementations of de facto standards.
2016-11-23T21:41:23Z younder: If you wan't to change that I am sure  many people here would welcome it.
2016-11-23T21:42:15Z younder: The last standard is from 22 years ago.
2016-11-23T21:42:51Z aeth: And it'll probably be at least 10 until another, if ever.
2016-11-23T21:43:32Z prxq joined #lisp
2016-11-23T21:44:58Z younder: Well it has to start somewhere. So far noone has done anything. Thake paralell program support. I notice SBCL has added this, as has ACL and LispWorks, but there is no standard.
2016-11-23T21:45:21Z aeth: Afaik you'd only get a new standard if either the major implementations like SBCL and CCL push it, or if the major industrial users of CL push it (which are?)
2016-11-23T21:45:50Z aeth: Well, I mean, you could get another standard otherwise, but it'd be like r6rs Scheme that everyone ignores and that the next standard would mostly not care about
2016-11-23T21:45:53Z fiddlerwoaroof: younder: what would the advantage of a standard over something like bordeaux-threads be?
2016-11-23T21:46:06Z younder: Sort of fine, perhaps we sould have addendums to standards. Small smipplets that all agree to implement.
2016-11-23T21:46:14Z sweater quit (Read error: Connection reset by peer)
2016-11-23T21:46:15Z younder: should
2016-11-23T21:46:20Z aeth: and then the question is, do you want to break some things?
2016-11-23T21:46:40Z sweater joined #lisp
2016-11-23T21:46:47Z travv0 quit (Quit: leaving)
2016-11-23T21:47:00Z gingerale quit (Remote host closed the connection)
2016-11-23T21:47:03Z younder: aeth, No, I would prefer if it didn't affect old code.
2016-11-23T21:47:29Z aeth: Some argument orders contradict other argument orders, e.g. (nth 0 foo) should be (nth foo 0) to match the other sequence functions (and it has to go in that order because of the way getting the aref of multiple dimension arrays work)
2016-11-23T21:47:47Z aeth: And some function names don't reflect current naming practices, and some functions are de facto deprecated.
2016-11-23T21:47:49Z sweater quit (Read error: Connection reset by peer)
2016-11-23T21:48:02Z m_zr0 quit (Ping timeout: 252 seconds)
2016-11-23T21:48:09Z aeth: The things a standard could most fix are probably the things that'd be fought the most because of breakage
2016-11-23T21:48:23Z aeth: Unless you had a compatibility mode or something
2016-11-23T21:48:31Z prxq: the main reason we need a new satandard is (imo) to show that "we" are alive.
2016-11-23T21:48:35Z travv0 joined #lisp
2016-11-23T21:48:57Z prxq: Fortran and Ada get new standards every couple of years.
2016-11-23T21:49:06Z prxq: (draw your own conclusions :-) )
2016-11-23T21:49:12Z aeth: Even *Scheme* gets new standards, and it's less thriving than CL imo
2016-11-23T21:49:15Z ecraven: prxq: I was just going to say...
2016-11-23T21:49:33Z younder: aeth, I would suggest for now at least to limit it to adding new features. And to sticking as closely as possible to existing practices.
2016-11-23T21:49:35Z ecraven: aeth: and r7rs-large is talking longer than CL ever took :P
2016-11-23T21:49:35Z m_zr0 joined #lisp
2016-11-23T21:49:57Z aeth: younder: right
2016-11-23T21:50:49Z aeth: younder: The safest approach would mostly just be standardizing features that are already standard... i.e. taking things like alexandria and bordeaux-threads etc. and parts of UIOP
2016-11-23T21:51:11Z stux|RC-only quit (Ping timeout: 260 seconds)
2016-11-23T21:51:23Z aeth: The advantage of making certain alexandria functions part of the standard would be performance... implementations can do more than alexandria itself can (and alexandria itself doesn't really optimize that much, for the most part)
2016-11-23T21:52:04Z antoszka: I would love to see lparallel in the standard too (if it were to change for which I don't care much)
2016-11-23T21:52:11Z aeth: There would also be some borrowing from Scheme and the FP languages, probably.
2016-11-23T21:52:12Z younder: Well learning CL 10 years ago is the same as learning it now, even the same books. In haskell if you have a 5 year old compiler and 5 year old knowlege it won't work. There is a allure to both approaches. But I think for lisp I recomend the first.
2016-11-23T21:52:18Z antoszka: and perhaps Optima
2016-11-23T21:52:40Z fiddlerwoaroof: Yeah, the language itself is so flexible, I don't really see much benefit to an updated standard
2016-11-23T21:52:41Z fiddlerwoaroof:  
2016-11-23T21:52:44Z stux|RC-only joined #lisp
2016-11-23T21:53:00Z fiddlerwoaroof: It's not like Python, or something, where you have to redo everything to get synctactic support for generators.
2016-11-23T21:53:08Z aeth: fiddlerwoaroof: a lot of things are implemented at the implementation level, and not consistently. e.g. how do you get NaN or positive-infinity?
2016-11-23T21:53:27Z fiddlerwoaroof: write trivial-floats
2016-11-23T21:53:37Z prxq: aeth: no sane implementation uses non-ieee floats.
2016-11-23T21:53:39Z aeth: fiddlerwoaroof: and some things you probably need to do at the langauge standard level, like improving the type system, which I am nowhere near qualified enough to say how
2016-11-23T21:53:41Z ovenpasta quit (Ping timeout: 248 seconds)
2016-11-23T21:53:45Z prxq: not even the insane ones
2016-11-23T21:53:52Z fiddlerwoaroof: And define a protocol that can be supported by all the major implementations
2016-11-23T21:54:08Z aeth: prxq: yeah, but e.g. in SBCL getting NaN is not easy
2016-11-23T21:54:15Z aeth: if for some reason you need it
2016-11-23T21:54:18Z prxq: aeth: it isn't?
2016-11-23T21:54:24Z aeth: there is no sb-ext:nan or something
2016-11-23T21:54:42Z aeth: there are sb-ext:double-float-negative-infinity etc
2016-11-23T21:54:55Z aeth: and there's a float-nan-p
2016-11-23T21:54:59Z aeth: but no nan itself
2016-11-23T21:55:34Z fiddlerwoaroof: One thing I would like is parse-rational and parse-float, but that's mainly a quibble.
2016-11-23T21:55:42Z aeth: Unicode, threads, IEEE floats, etc. There are quite a few things that could be added uncontroversially... and types would probably need to be improved controversially
2016-11-23T21:56:07Z _death: you are wrong.. any change is controversial
2016-11-23T21:56:15Z shka_ wish he could write classes that can specialize
2016-11-23T21:56:27Z aeth: _death: what I mean is, adding things that are *already* in the major implementations that people use
2016-11-23T21:56:46Z aeth: Just accessed through different ways, and requiring portability libraries, and not 100% implemented in any implementation because it's implementation-specific
2016-11-23T21:56:56Z _death: aeth: and yet, some prefer the stability of the spec
2016-11-23T21:57:35Z aeth: The spec doesn't have to update every year, but maybe every 30 is fine
2016-11-23T21:57:45Z travv0 quit (Quit: leaving)
2016-11-23T21:57:51Z aeth: That's one or two updates in your professional life
2016-11-23T21:58:53Z IAmRasputin joined #lisp
2016-11-23T21:59:08Z travv0 joined #lisp
2016-11-23T21:59:55Z aeth: I personally would like to see better ways to write high-performance CL. I think the proper way to handle writing something like CL is to write it first as a prototype and then refactor it into something faster if it needs to be faster. There are limits to this in CL, though.
2016-11-23T22:00:21Z prxq: I'm not convinced. The problem is that writing standards is a lot of work, so you need a kind of institution to do it.
2016-11-23T22:00:22Z _death: aeth: just saying it's not "uncontroversial".. personally I already have my preference for a stable spec for quite a while, especially with what's going on with other languages I've known and used.. but a spec isn't a'coming anyway
2016-11-23T22:00:44Z prxq: the actual problem is to stop them writing new standards all the time.
2016-11-23T22:00:47Z aeth: e.g. pointers, pointers everywhere... upgraded arrays are afaik one of the few cache friendly things you can do, and you can only upgrade them for a few things.
2016-11-23T22:01:08Z aeth: High performance code these days is all about the cache... So there could be some ways to turn your code more cache friendly, probably.
2016-11-23T22:01:23Z adlai: fiddlerwoaroof: there's parse-float in quicklisp, and you can give it :type 'rational
2016-11-23T22:01:28Z prxq: Java is a bit of an example here. Lots of crazy stuff gets added, and then more the next iteration, etc etc. Same with C++ and Ada
2016-11-23T22:01:57Z fiddlerwoaroof: adlai: yeah, I know about several of these packages, it's just an annoying lacuna in the standard
2016-11-23T22:01:57Z fiddlerwoaroof:  
2016-11-23T22:02:07Z aeth: High performance CL is a niche, but it's a niche that would be nice to have. There's always going to be a CFFI overhead, so the more you can do natively, the easier it makes things imo.
2016-11-23T22:02:16Z fiddlerwoaroof wishes he could figure out how to prevent ERC from sending these blank lines
2016-11-23T22:02:27Z prxq: aeth: sbcl is pretty good - no?
2016-11-23T22:02:36Z LiamH quit (Quit: Leaving.)
2016-11-23T22:02:45Z fiddlerwoaroof: aeth: well, on sbcl, you could write your own assembly in lisp syntax
2016-11-23T22:03:14Z _death: aeth: but high performance is the antithesis for standards
2016-11-23T22:03:33Z younder: Performance can be handled by the compiler. Focus shoud be on function.
2016-11-23T22:03:35Z Guest2 quit (Quit: My MacBook has gone to sleep. ZZZzzz…)
2016-11-23T22:03:38Z aeth: _death: it doesn't need to be high performance, it just needs to be *potentially* high performance
2016-11-23T22:03:48Z aeth: i.e. features that implementations *can* implement in an optimized way if they choose to do so
2016-11-23T22:04:24Z _death: aeth: there's nothing preventing someone from taking an existing implementation and making changes.. that should come before a standard is defined
2016-11-23T22:04:31Z eivarv quit (Quit: Sleep)
2016-11-23T22:05:07Z younder: I find high performance to be less and less relevant in the whole scope of things. Productivity seems to be the the ting of the day.
2016-11-23T22:05:52Z shka_: depends where
2016-11-23T22:06:20Z aeth: younder: Performance in the application level doesn't matter *that* much, but there are definitely things that you should be able to optimize if profiling shows you need to do so
2016-11-23T22:06:24Z fiddlerwoaroof: Yeah, as far as I can tell it's mainly relevant in games and low-level os stuff: in most other places, you just scale horizontally to meet performance demands.
2016-11-23T22:06:38Z shka_: all this big data stuff is example where performance does matter
2016-11-23T22:06:44Z aeth: fiddlerwoaroof: right, and no one uses Lisp to write OSes ;-)
2016-11-23T22:07:15Z fiddlerwoaroof: But, many lisp implementations have their own assemblers, so it's not like you can't write code as optimally as one wants.
2016-11-23T22:07:51Z shka_: good night everyone
2016-11-23T22:07:53Z eivarv joined #lisp
2016-11-23T22:07:56Z aeth: fiddlerwoaroof: often, a library does the low level stuff for you... resorting to implementations that let you write assembly with a native CL code path for the rest is probably not the best way to do things
2016-11-23T22:08:25Z aeth: In other words, a lot of the applications that don't need to be fast really do, it's just that they rely on a library for those things... and that library has to do the work.
2016-11-23T22:08:34Z robotoad quit (Quit: robotoad)
2016-11-23T22:08:35Z prxq: fiddlerwoaroof: nobody stops you from writing in assembly and linking in via an FFI
2016-11-23T22:08:55Z _death: aeth: the process is generally: implement something, gather experience reports, convince other implementors that they need it or be succesful enough that they copy it somehow, gather more experience reports, have enough big players depend on it so that they fund a standardization process
2016-11-23T22:09:14Z sellout- joined #lisp
2016-11-23T22:09:30Z rpg_ joined #lisp
2016-11-23T22:10:36Z cibs quit (Ping timeout: 268 seconds)
2016-11-23T22:10:58Z younder: _death, Sound like a lot of reports.
2016-11-23T22:11:14Z _death: ideally.. otherwise you come up with C++ export :D
2016-11-23T22:11:24Z aeth: I'd like to be able to make an array of structs in CL. Then, optimizing implementations can see that the struct is of a fixed size and the array's of a fixed size, and optimize accordingly.
2016-11-23T22:11:52Z angavrilov quit (Remote host closed the connection)
2016-11-23T22:12:04Z prxq: aeth: what would that be good for?
2016-11-23T22:12:21Z cibs joined #lisp
2016-11-23T22:12:40Z shka_: prxq: fast allocation of structs
2016-11-23T22:12:40Z aeth: prxq: Something that's run in a loop many times a second, such as at the heart of a game engine.
2016-11-23T22:13:07Z younder: _death, I found the new C++ standard to be invigorating. I was expecting the usual bloat, like in Java. Instead it had greatly improved the ease of use.
2016-11-23T22:13:08Z aeth: prxq: It'll allocate before the loop, and then loop over in a fixed size instead of using pointers so it'll use the cache better.
2016-11-23T22:13:09Z shka_: i don't see this working
2016-11-23T22:13:57Z sellout- quit (Ping timeout: 248 seconds)
2016-11-23T22:14:21Z younder: shka_, Alocate on the heap
2016-11-23T22:14:24Z _death: younder: I've not looked at it, as I don't often use C++ nowadays (I used it at my previous workplace but the code-base didn't use the new features)
2016-11-23T22:14:27Z NeverDie joined #lisp
2016-11-23T22:14:46Z shka_: younder: and what i'm doing right now? ;-)
2016-11-23T22:15:49Z younder: shka_,  That was supposed to say *on the stack'
2016-11-23T22:16:12Z aeth: Anyway, I think this would be useful in an Entity Component System but perhaps I'm not understanding it properly, or phrasing it properly.
2016-11-23T22:16:23Z aeth: It's a type of thing that afaik is mostly if not entirely just used in gamedev.
2016-11-23T22:16:27Z shka_: younder: i don't have control over it
2016-11-23T22:16:38Z shka_: i may declare hints
2016-11-23T22:16:40Z Davidbrcz quit (Ping timeout: 250 seconds)
2016-11-23T22:16:42Z shka_: but that's it
2016-11-23T22:16:59Z shka_: compiler is about to decide what it wishes to do anyway
2016-11-23T22:18:36Z shka_: anyway
2016-11-23T22:18:41Z prxq: shka_: the thing is, that kind of thing is very rare. I can understand why it would be interesting, but it is in situations that are performance constriained to the point of asphixia
2016-11-23T22:18:57Z shka_: i agree
2016-11-23T22:19:01Z shka_: anyway
2016-11-23T22:19:05Z prxq: and then, maybe, everyone is better off if you use something else.
2016-11-23T22:19:10Z ovenpasta joined #lisp
2016-11-23T22:19:17Z shka_: lisp is actually passable for high performance code
2016-11-23T22:19:19Z shka_: not ideal
2016-11-23T22:19:28Z shka_: but acceptable
2016-11-23T22:19:56Z aeth: Lisp is sort of afaik in the middle tier of performance. Infinitely better than Python, but not as good as C++.
2016-11-23T22:20:23Z shka_: order of magnitude better than ruby or python, without time required to make anything reasonable in C++
2016-11-23T22:20:26Z _death: there are many quibbles with CL as defined, and many "cool things that'd be nice if standardized".. but the scale for me is still much to the "nope"
2016-11-23T22:20:30Z aeth: What I'd personally like to see is GC overhead as the only necessary overhead (and some techniques to avoid GC where possible.)
2016-11-23T22:20:37Z younder: These days usually god enough
2016-11-23T22:20:42Z younder: good
2016-11-23T22:21:04Z shka_: aeth: this matters the most for real time systems and games i guess
2016-11-23T22:21:17Z shka_: personally i don't consider GC to be a bottle neck for me
2016-11-23T22:21:40Z aeth: shka_: yes, I'd like to see some additions to CL that help with that... implementations with niche GCs could help further, but that doesn't need to be standardized.
2016-11-23T22:22:07Z shka_: well, you probably can do thing everyone is doing
2016-11-23T22:22:15Z shka_: just use memory pool
2016-11-23T22:22:19Z aeth: Even if you never use the lower level stuff (and very few people need to), you can still benefit from stuff written in ways that are more optimized, without having to use CFFI.
2016-11-23T22:22:21Z younder: shka_,  Garbage collection actualy improves performance.
2016-11-23T22:22:45Z xaotuk joined #lisp
2016-11-23T22:22:48Z shka_: younder: sure, at the cost of higher deviation
2016-11-23T22:22:52Z _death: aeth: again, in such systems where gc is a problem, it doesn't matter much whether controlling it is standardized, just that you have the option to control it in the particular implementation that you use
2016-11-23T22:23:01Z younder: reference counting is one of the slowest sceemes out there.
2016-11-23T22:23:02Z aeth: I don't think that anyone should be using cache-friendly data structures over CLOS in the future unless they really need to, but they could use libraries that do so.
2016-11-23T22:23:50Z aeth: What I like about CL is that it's ridiculously multiparadigm, so I'd love to see both lower level stuff and FP stuff added into the standard in the future.
2016-11-23T22:23:57Z shka_: you can actually make clos cache friendly
2016-11-23T22:23:59Z younder: shka_, All that mattters not. In games you want resposiveness, not throughput.
2016-11-23T22:24:08Z aeth: shka_: through the MOP or implementation-specific?
2016-11-23T22:24:26Z zygentoma joined #lisp
2016-11-23T22:24:28Z shka_: MOP
2016-11-23T22:24:41Z shka_: use virtual slots and memory pool
2016-11-23T22:24:44Z aeth: shka_: But I think the problem with cache-friendly data structures in CL is once you have to iterate over them... I'm not sure how to do this without a bunch of pointers somewhere.
2016-11-23T22:24:52Z shka_: a lot of work, but it can be done once, as a library
2016-11-23T22:25:28Z aeth: shka_: It would be interesting if MOP is powerful enough to make an entire Entity Component System out of it... ECSes are basically composition over inheritance taken to an extreme.
2016-11-23T22:25:42Z arbv quit (Read error: Connection reset by peer)
2016-11-23T22:25:50Z shka_: aeth: sure it is
2016-11-23T22:25:54Z younder: Stack allocation is possible, but generally more probem than it is worth.
2016-11-23T22:26:09Z aeth: The entities no longer exist in many of them, it's all about components that belong to entities (usually just an ID) and systems that iterate over those components if all of the necessary components of the system are present for that entity.
2016-11-23T22:26:11Z arbv joined #lisp
2016-11-23T22:26:20Z _death: I implemented a toy ECS the other day.. but threw it away as it didn't have a use case ;)
2016-11-23T22:26:34Z shka_: aeth: it is very much possible, just loads of work
2016-11-23T22:26:34Z aeth: Everyone in #lispgames probably has written at least one ECS
2016-11-23T22:26:42Z aeth: It would be nice to write a final ECS that is the last ECS anyone needs
2016-11-23T22:26:57Z aeth: If only to stop every single person from writing their own
2016-11-23T22:27:14Z aeth: Currently most if not all ECSes avoid CLOS.
2016-11-23T22:27:25Z shka_: well, i don't see why
2016-11-23T22:27:40Z shka_: procedure is as follow
2016-11-23T22:28:03Z aeth: shka_: entities don't really exist in most ECSes, they're just an ID and associated components to that ID. The components are usually something like structs because in theory sbcl/etc. can optimize those more than naive CLOS usage.
2016-11-23T22:28:07Z shka_: 1: defclass slots with additional info about stored size
2016-11-23T22:28:08Z younder: Well there is always GUILE. Not CL but scheeme
2016-11-23T22:28:17Z shka_: 2: defclass metaclass
2016-11-23T22:28:30Z aeth: Usually the components are put in hash tables, though, because it's very hard to beat the hash tables for some reason. Obviously it's not as cache-friendly as the hardcore C/C++ ECSes
2016-11-23T22:28:35Z younder thinks scheeme is a fine language
2016-11-23T22:28:59Z shka_: 3: ensure that instances of metaclass contains offsets to slots
2016-11-23T22:29:01Z eivarv quit (Quit: Sleep)
2016-11-23T22:29:15Z shka_: 4: virtual accessors
2016-11-23T22:29:32Z shka_: 5: memory allocator
2016-11-23T22:29:56Z jmasseo quit (Ping timeout: 244 seconds)
2016-11-23T22:30:22Z aeth: In case it's not clear to anyone, the ECS pattern is basically to loop over entities, check their signature, and if they contain all the components, do that system on those components. Here's one: http://www.gamedev.net/page/resources/_/technical/game-programming/implementing-component-entity-systems-r3382
2016-11-23T22:30:23Z shka_: it could be useful for serialization to binary as well
2016-11-23T22:30:32Z shka_: for network stuff and so one
2016-11-23T22:30:33Z aeth: And yes, a proper ECS is very good to serialize
2016-11-23T22:30:33Z jmasseo joined #lisp
2016-11-23T22:30:39Z aeth: For save games and networking
2016-11-23T22:30:44Z aeth: They're practically the perfect fit for games
2016-11-23T22:30:45Z kartik quit (Quit: Leaving)
2016-11-23T22:30:51Z aeth: There might be some other uses for them, though, idk.
2016-11-23T22:30:54Z shka_: aeth: you can do this with mop
2016-11-23T22:31:06Z shka_: it is not easy
2016-11-23T22:31:15Z younder: Hash tables are a bit overrated in my opinion. Yes they are great for large amounts of data. But for < 100 elements or so symlist's are simpler and give better performance. There is a LARGE k in the linear performance of hashes.
2016-11-23T22:31:19Z shka_: but not something daunting
2016-11-23T22:31:45Z aeth: shka_: yes, now the real question is if it beats a bunch of structs placed into a hash table... for some surprising reason they're hard to beat, iirc a conversation I had with axion led to me finding this surprising result
2016-11-23T22:32:05Z aeth: younder: I think there are usually several thousand entities, I might be slightly off
2016-11-23T22:32:15Z aeth: Also games might have increased the expectation of entities
2016-11-23T22:32:33Z younder: aeth, Depends what yu are doing
2016-11-23T22:32:50Z shka_: aeth: well, you can have your arrays of objects in memory
2016-11-23T22:32:53Z shka_: C style
2016-11-23T22:33:15Z shka_: that would be fast iteration
2016-11-23T22:33:18Z axion: hmm, possibly. i've written a few ECS implementations but do not recall
2016-11-23T22:33:39Z aeth: I hope it was a conversation with axion
2016-11-23T22:33:47Z aeth: I'd hate to have named the wrong person from #lispgames
2016-11-23T22:33:51Z shka_: and if you REALLY care about performance
2016-11-23T22:34:08Z shka_: it's moment where you implement your own hashtable for your overlay objects
2016-11-23T22:34:12Z younder: There is always C
2016-11-23T22:34:25Z robotoad joined #lisp
2016-11-23T22:34:29Z aeth: It looks like games from 15ish years ago had entities in the ballpark of around 1000 so it's probably higher now.
2016-11-23T22:34:31Z travv0 quit (Quit: leaving)
2016-11-23T22:34:38Z shka_: probably as some sort of HAMT
2016-11-23T22:35:01Z aeth: younder: There's a CFFI overhead that will always exist. Something like the ECS should probably be in the language most of the rest of the engine is in.
2016-11-23T22:35:21Z aeth: Plus it makes it easier to e.g. install it off of quicklisp
2016-11-23T22:35:44Z xaotuk quit (Ping timeout: 250 seconds)
2016-11-23T22:35:52Z shka_: well, i should go to sleep
2016-11-23T22:36:01Z shka_: but anyway, yes you can do this in MOP
2016-11-23T22:36:24Z shka_: in fact, it is not that different from ORM in mop
2016-11-23T22:36:28Z xaotuk joined #lisp
2016-11-23T22:36:35Z stux|RC-only quit (Ping timeout: 268 seconds)
2016-11-23T22:37:12Z shka_: in fact clos MOP allows you to redefine pretty much every aspect of clos
2016-11-23T22:37:16Z stux|RC-only joined #lisp
2016-11-23T22:37:22Z aeth: I'm not surprised that ECSes are similar to ORMs
2016-11-23T22:37:50Z shka_: well, same stuff
2016-11-23T22:37:58Z shka_: virtual slot
2016-11-23T22:38:07Z shka_: anyway, take care
2016-11-23T22:38:18Z aeth: I read somewhere that ECSes can be an alternative to ORMs
2016-11-23T22:38:48Z aeth: So there's a use case that's not necessarily games, I guess
2016-11-23T22:39:19Z aeth: Unfortunately, the link looked like it either changed or was to the wrong article, so it didn't go into enough detail
2016-11-23T22:39:39Z aeth: i.e. it was mentioned in passing in an article and the link it linked to also mentioned it in passing
2016-11-23T22:40:49Z younder:  Just found  'Common Lisp Recipes: A Problem-Solution Approach '
2016-11-23T22:40:58Z akkad: ^^ great book
2016-11-23T22:41:00Z younder: by Edmund Weitz
2016-11-23T22:41:02Z akkad: and current
2016-11-23T22:41:14Z aeth: Maybe I'll try to MOP an ECS and find out exactly what language features are missing to make it perform closer to C++
2016-11-23T22:41:16Z vtomole quit (Ping timeout: 260 seconds)
2016-11-23T22:41:17Z younder: Think it might be time for a new lisp book :)
2016-11-23T22:41:19Z aeth: And then I'll come back and complain :-p
2016-11-23T22:42:08Z akkad: big book too
2016-11-23T22:42:13Z axion: aeth: I've been studying ECS's for years, and I wrote several implementations. The truth is, they are big gimmicks. They are not useful in their pure form. Coupling of data is absolutely needed. So, you end up with something far from ECS in the end for any practical uses.
2016-11-23T22:42:47Z shka_ quit (Ping timeout: 256 seconds)
2016-11-23T22:42:57Z aeth: axion: fine then I'll call it an AeCS, an Aeth Component System, and I'll not stick to the purist way of doing it
2016-11-23T22:43:21Z aeth: Because it doesn't need to conform to the platonic Entity Component System form
2016-11-23T22:43:28Z _death: I've actually been thinking about writing another game.. maybe in the coming weeks/months
2016-11-23T22:44:14Z itruslove joined #lisp
2016-11-23T22:45:24Z younder: _death, What kind of game?
2016-11-23T22:45:26Z quazimodo joined #lisp
2016-11-23T22:45:34Z _death: younder: I need to think about it :)
2016-11-23T22:45:43Z swflint_away joined #lisp
2016-11-23T22:46:02Z aeth: axion: I actually hesitated calling the mostly placeholder ECSish thing an "ECS" in my 0.5% complete game engine because I am totally willing to cut any actual rigid following of the ECS pattern when it becomes inconvenient
2016-11-23T22:46:05Z swflint_away is now known as swflint
2016-11-23T22:46:23Z aeth: I've noticed that the purest ECSes tend to be for 2D platformers etc
2016-11-23T22:47:16Z aeth: This suggests it's hard or impossible to use an ECS in something closer to a full game by modern standards
2016-11-23T22:48:42Z axion: Yeah, like how do you do collision detection?
2016-11-23T22:48:49Z younder: I keep think of 'the rest of us' A 3d distopyian future. Naughtydog used lisp under the cover. A C++/lisp integration.
2016-11-23T22:48:52Z axion: It's not very possible with a pure ECS
2016-11-23T22:48:53Z mishoo_ quit (Ping timeout: 252 seconds)
2016-11-23T22:49:01Z axion: amoung other impossibilities
2016-11-23T22:49:36Z younder: common lisp
2016-11-23T22:49:49Z aeth: younder: using C++ and Lisp together is dystopian?
2016-11-23T22:49:51Z aeth: I agree
2016-11-23T22:49:51Z _death: if the game doesn't need to raw performance.. it could be interesting to use something like what Jonathan Amsterdam (of ITERATE fame) did with his adventure game
2016-11-23T22:50:04Z younder: aeth, No the game is
2016-11-23T22:50:09Z younder: lol
2016-11-23T22:50:27Z antoszka: _death: what adventure game are you mentioning?
2016-11-23T22:50:42Z axion: aeth: My implementations get around this by extending ECS with set theory and combinatorics mathematics. But can you even call it an ECS now?
2016-11-23T22:50:43Z rumbler31 quit (Remote host closed the connection)
2016-11-23T22:50:54Z prxq: using C++ is pretty distopian...
2016-11-23T22:51:02Z prxq: dystopian, even
2016-11-23T22:51:47Z prxq: axion: interesting - what do they get around of with set theory and combinatorics?
2016-11-23T22:51:49Z axion: Also, the fact that you must iterate over write-only systems first, followed by read-write, followed by read-only.
2016-11-23T22:52:40Z axion: it would probably be best to show you a gist of how it works...
2016-11-23T22:52:45Z axion: Let me find it on my github
2016-11-23T22:52:46Z _death: antoszka: first post is https://groups.google.com/forum/#!search/jonathan$20amsterdam$20adventure/alt.sources/nQKe5aWcISQ/wQKH3VUteTwJ
2016-11-23T22:53:09Z aeth: axion: Doesn't the iteration order of systems hurt with trying to thread parts of it?
2016-11-23T22:53:53Z antoszka: _death: thx
2016-11-23T22:54:02Z axion: prxq, aeth: I think this simple example answers your questions: https://gist.github.com/mfiano/1141ee65ca86cfe7312bf37e56ea81bd
2016-11-23T22:54:20Z axion: behavior = system. gob = entity. trait = component.
2016-11-23T22:55:07Z rpg_ quit (Ping timeout: 252 seconds)
2016-11-23T22:56:52Z axion: as you can see, a system iterates on combinations of entities. in this example it operates on 2 entities at once, useful for collision detection. the group size can be anything though, and all combinations using the chosen group size will be iterated on
2016-11-23T22:58:21Z rpg joined #lisp
2016-11-23T22:59:37Z varjag quit (Ping timeout: 240 seconds)
2016-11-23T22:59:47Z axion: the :grouping specification in the defbehavior controls this. (e1 e2) will specify that this system iterates on 2 entities simultaneously for each iteration, rather than the traditional 1. e1/e2 can be any symbols to access the entities in the system method, and this can be a list of as many as you want to process in parallel at once
2016-11-23T23:00:23Z Karl_Dscc quit (Remote host closed the connection)
2016-11-23T23:01:15Z aeth: ah, two entities, that's what it's doing there
2016-11-23T23:01:42Z axion: yes, this is useful to compare entities with each other without coupling that data to themselves. collision detection, etc
2016-11-23T23:02:11Z terpri joined #lisp
2016-11-23T23:02:45Z aerique quit (Remote host closed the connection)
2016-11-23T23:09:23Z IAmRasputin quit (Read error: Connection reset by peer)
2016-11-23T23:09:43Z bogdanm quit (Quit: Leaving)
2016-11-23T23:11:08Z prxq quit (Remote host closed the connection)
2016-11-23T23:12:33Z BlueRavenGT joined #lisp
2016-11-23T23:16:55Z manuel__ quit (Quit: manuel__)
2016-11-23T23:19:45Z xaotuk quit (Ping timeout: 268 seconds)
2016-11-23T23:21:59Z quazimodo quit (Ping timeout: 265 seconds)
2016-11-23T23:22:55Z borodust joined #lisp
2016-11-23T23:24:36Z zygentoma quit (Quit: KVIrc 4.2.0 Equilibrium http://www.kvirc.net/)
2016-11-23T23:25:31Z sellout- joined #lisp
2016-11-23T23:28:19Z dyelar quit (Quit: Leaving.)
2016-11-23T23:29:08Z redcedar joined #lisp
2016-11-23T23:39:13Z karswell quit (Remote host closed the connection)
2016-11-23T23:40:25Z karswell joined #lisp
2016-11-23T23:40:45Z switchy quit (Ping timeout: 250 seconds)
2016-11-23T23:43:29Z switchy joined #lisp
2016-11-23T23:44:37Z nullman quit (Ping timeout: 248 seconds)
2016-11-23T23:45:58Z lexicall joined #lisp
2016-11-23T23:46:23Z nullman joined #lisp
2016-11-23T23:47:56Z FreeBirdLjj joined #lisp
2016-11-23T23:48:58Z knobo: http://labs.ariel-networks.com/cl-style-guide.html recommends cl-annot "using it almost always"....
2016-11-23T23:49:08Z quazimodo joined #lisp
2016-11-23T23:49:12Z warweasle quit (Quit: later)
2016-11-23T23:49:26Z knobo: I don't want to use it. I have tried for a while. Because I thought I'd like that..
2016-11-23T23:49:35Z knobo: But I don't.
2016-11-23T23:51:29Z lexicall quit (Remote host closed the connection)
2016-11-23T23:52:00Z travv0 joined #lisp
2016-11-23T23:52:29Z knobo: Several things with this standard I don't like so much.
2016-11-23T23:52:36Z FreeBirdLjj quit (Ping timeout: 260 seconds)
2016-11-23T23:52:57Z knobo: :like.the.wery.long.package.names
2016-11-23T23:53:24Z rpg: not sure what I think about the <classes>, either, but it's actually not unreasonable. Might grow on me
2016-11-23T23:54:33Z rpg quit (Quit: Textual IRC Client: www.textualapp.com)