ChanServ changed the topic of #picolisp to: PicoLisp language | Channel Log: | Check also for more information
_whitelogger has joined #picolisp
orivej has quit [Ping timeout: 248 seconds]
_whitelogger has joined #picolisp
razzy has quit [Ping timeout: 246 seconds]
razzy has joined #picolisp
rob_w has joined #picolisp
<tankf33der> i would like to try again and again use vip
<tankf33der> vim -> vip
<tankf33der> no special documentations and tutorials, right?
<tankf33der> morning all
<Regenaxer> Good morning tankf33der!
<Regenaxer> Yeah, no dedicated Vim doc yet
<Regenaxer> Similar, but different from Vim
<tankf33der> i see
<Regenaxer> and restrictions (e.g. only UTF-8)
<Regenaxer> Very big files are also not good for Vip, as it uses a lot of space internally
<razzy> i gave up 8klisp on android.
<Regenaxer> I never tried on Android
<razzy> i am on a move a lot. so i want everything on android :)
<Regenaxer> Me too, but I log into my servers via SSH and do some things there
<Regenaxer> eg this IRC too
<Regenaxer> I do *all* from my phone
<razzy> possible.
<Regenaxer> T
<Regenaxer> One has to adjust one's brain, to keep more in memory due to the reduced screen size
<Regenaxer> This is also something Vip oes better (a least for me) than Vip, it supports better horizontal navigation
<Regenaxer> "than Vip" -> "than Vim" I meant
<razzy> seems plausible.
beneroth|idle has quit [Quit: Verlassend]
beneroth has joined #picolisp
<beneroth> tankf33der, look at
<beneroth> it leaves out the standard vim things though
<tankf33der> wow
<Regenaxer> Another important point is backups. I syncronize modified files several times per hour to my server, as a mobile device is easy to lose or destroy
<Regenaxer> Thanks beneroth! I forgot about that one
<Regenaxer> haha, the "less than 1000 lines" is no longer true
<beneroth> I tried vip again recently, I believe I grokked it. but I'm missing syntax highlighting and paredit, so for now I'm back to emacs. I consider adding this things to vip - or creating a kind of picolisp web IDE... but not soon.
<beneroth> Regenaxer, aye, I saw that xD
<Regenaxer> well, it is 1394 now
<Regenaxer> not soo very much :)
<Regenaxer> I should update that wiki article as soon as I have time
clacke_movim has left #picolisp [#picolisp]
clacke_movim has joined #picolisp
clacke_movim has left #picolisp [#picolisp]
clacke_movim has joined #picolisp
clacke_movim has left #picolisp [#picolisp]
clacke_movim has joined #picolisp
jibanes has quit [Ping timeout: 248 seconds]
jibanes has joined #picolisp
clacke_movim has left #picolisp [#picolisp]
clacke_movim has joined #picolisp
clacke_movim has left #picolisp [#picolisp]
clacke_movim has joined #picolisp
clacke_movim has left #picolisp [#picolisp]
clacke_movim has joined #picolisp
xkapastel has joined #picolisp
ubLIX has joined #picolisp
razzy` has quit [Ping timeout: 248 seconds]
orivej has joined #picolisp
rob_w has quit [Quit: Leaving]
ubLIX has quit [Quit: ubLIX]
orivej has quit [Ping timeout: 272 seconds]
razzy2 has joined #picolisp
razzy2 has quit [Changing host]
razzy has joined #picolisp
razzy2 is now known as razzy
razzy has quit [Killed ( (Nickname regained by services))]
orivej has joined #picolisp
<beneroth> Regenaxer, why is (list? X) not implemented as (not (fin X)) ?
<beneroth> I have regularly a hard time to separate cons pairs and lists
<Regenaxer> Hmm, where did you find 'list?'?
<Regenaxer> not 'lst?'?
<beneroth> T, I meant lst?
<beneroth> afaik the only difference of (pair) and (lst?) is the handling of NIL
<Regenaxer> yes, lst? is also true for NIL
<Regenaxer> which is not a pair
<beneroth> so what is the best way to check if an argument is a cons pair and definitely not a list?
<beneroth> or is definitely a list and not a "pure" cons pair consisting of only 2 cells
<Regenaxer> "list" is not clearly defined. You mean a NIL-terminated list, right?
<beneroth> I go with (not (fin)) for now, as this is only true for lists (NIL in the last cell, else its a 2-cell-cons-pair or symbol or number
<beneroth> yeah, I would say list is clearly defined as a cons pair consisting of two or more cells with NIL in the last cdr
<Regenaxer> (not (fin X)) for a general lst? check is too expensive
<beneroth> as the built-in list functions usually assume NIL in the last cdr
<Regenaxer> one cell is also a list (1)
<beneroth> (1) has two cells, no?
<Regenaxer> no, only one
<beneroth> oh I see
<Regenaxer> (1 . NIL)
<beneroth> yeah, NIL in cdr :P
<Regenaxer> built-in list functions often check just for pair
<Regenaxer> ie. the last CDR (atomic) is ignored
<beneroth> exactly
<Regenaxer> 'append', map etc
<Regenaxer> alse evaluator
<Regenaxer> thats for efficiency
<Regenaxer> jusy a single bit check
<beneroth> my use case is the hStyle / html attribute handling. those attributes can be a symbol (html class) or a 2-cell-cons-pair (html attribute) or list (of symbols and cons pair)
<beneroth> for handling those properly, I have to distinct between list and 2-cell-cons-pair
<Regenaxer> yes
<Regenaxer> lst? is seldom used I think
<Regenaxer> atom, pair, not perhaps
<beneroth> I would find lst? more usable if it would check for NIL in last cdr...
<beneroth> (I'm not arguing for change, would break too much)
<Regenaxer> well, 'fin' does that
<Regenaxer> or 'cddr' if 2 cells
<Regenaxer> "would check for NIL in last cdr." is too expensive
<Regenaxer> the list might be long
<Regenaxer> lst? means "pair or NIL"
<beneroth> yes. I need "not a 2 cell cons pair and not an atom"
<beneroth> to distinguish between usual lists and 2 cell cons pairs and everything else
<Regenaxer> what if 3 cells?
<beneroth> then handle as it is a list
<beneroth> or well
<beneroth> invalid argument, in my context :)
<beneroth> but I don't want check for that :)
<Regenaxer> (and (pair X) (pair (cdr X)) (cddr X)) :D
<Regenaxer> Cant probably be easier
<Regenaxer> (cddr X) might else crash
<beneroth> so for my use case "is X a 2 cell cons pair, yes or no" ? cddr errors when argument is not a list!
<Regenaxer> "a 2 cell cons pair" is the wrong term
<Regenaxer> a pair is always 1 cell
<beneroth> a right
<beneroth> <Regenaxer> a pair is always 1 cell <-- wrong
<beneroth> : (pair (1 2 3))
<beneroth> -> (1 2 3)
<Regenaxer> yes, but the pair is only the first cell of that list
<Regenaxer> a pair is a CAR and a CDR
<beneroth> so for my "is X only a car and a cdr, not a list" I do (and (pair X) (not (pair (cdr X)))) ?
<Regenaxer> (and (pair X) (atom (cdr X)))
<Regenaxer> pair and atom are complimentary
<Regenaxer> "list" is not really a data type
<beneroth> T
<beneroth> cons pair is the data type, list is a duck-data-type based on it (similar to how classes are symbols)
<Regenaxer> right
<beneroth> but the picolisp documentation conflates pair and list :P
<Regenaxer> for example?
<Regenaxer> Well, "list" is pair or NIL
<beneroth> hehe
<Regenaxer> but in many cases this can be ignored
<beneroth> oh it is correct in the tractatus, I misrembered
<beneroth> yes in many, but not in all :D
<Regenaxer> yep
<Regenaxer> Sometimes I talk of "NIL-terminated lists"
<Regenaxer> *if* it is important
<beneroth> well the start of the reference has data types. Numbers, Symbols, Lists
<Regenaxer> yeah
<beneroth> should be Numbers, Symbols, Cons Pair to be purist
<Regenaxer> "pairs" would confuse
<beneroth> T
<Regenaxer> Lisp books introduce pairs usually in later chapters
<beneroth> should stay as it is. though maybe a short paragraph making the relationship between lists and pairs more obvious/clear would be good. in the tutorial/explaining, or maybe in the reference to (pair) and (lst?)
<beneroth> I see
<beneroth> well for the programmer, pair is a special case of list and list the normal (because more often used) thing. even when technically it's kinda the other way round :)
<Regenaxer> yeah
<beneroth> NIL-terminated list brings up ugly C thoughts
<beneroth> :D
<Regenaxer> C strings?
<beneroth> aye
<Regenaxer> I like them :)
<beneroth> T, the concept is not bad
<beneroth> simple and flexible
<Regenaxer> yes, and no limit
<Regenaxer> just \0 is prohibited (as we discussed already)
<beneroth> on the other hand maybe a bit too flexible, a great number of bugs and especially security bugs are caused by programmers not correctly handling this
<Regenaxer> T
<Regenaxer> It is the fault of C in general, as mem allocation is in the hand of the programmer
<Regenaxer> very efficient though
<beneroth> in that regard I like C++ a bit more. in C++ you don't really have to care about mem allocation beside strictly keeping to the "declaration is initialization" rule/pattern. and still you have low-level control when you want it. unfortunately, most code doesn't properly use this.
<beneroth> all in all C is likely a lot more beautiful, as it is shorter and simpler. C++ is too broad (as discussed before)
<Regenaxer> agreed
<beneroth> I haven't yet had a closer look at Rust
<Regenaxer> Me neither, also not Ruby
<beneroth> I tried out some Ruby, more strictly its Webstack Ruby on Rails which made it famous and used for a while.
<beneroth> it's pretty comparable to python I think, in style and target use
ubLIX has joined #picolisp
<beneroth> Ruby on Rails I didn't like, full of magic. everything works well and easy if you keep to some conventions, but if you go away, things go sideways.
<beneroth> and not so much control for the programmer, not without going deep into the stack and redo whole portions yourself. therefore I left it and seeked further (ending up here)
<Regenaxer> I see
<beneroth> Ruby itself is probably a lot nicer and elegant than just this Rails stack
<beneroth> I think it has some niche in scripting still, but largely Ruby is going down as Ruby on Rails went out of favour, afaik
clacke_movim has left #picolisp [#picolisp]
freemint has joined #picolisp
freemint has quit [Client Quit]
freemint has joined #picolisp
freemint has quit [Quit: Leaving]
orivej has quit [Ping timeout: 272 seconds]
ubLIX has quit [Quit: ubLIX]
<viaken> If I wanted to have multiple clients interacting with The same data set and receiving updates from each other, could I do that with a prefix class using (serverSentEvent)?
<viaken> Or would +Auto be more reliable?