erkin has quit [Remote host closed the connection]
zakovyrya has joined #picolisp
zakovyrya has quit [Quit: See ya]
mundus201821 has joined #picolisp
mundus201821 has quit [Remote host closed the connection]
emilsp21 has joined #picolisp
emilsp21 has quit [Remote host closed the connection]
Solprefixer has joined #picolisp
Solprefixer has quit [Remote host closed the connection]
_whitelogger has joined #picolisp
<Regenaxer>
razzy: 'mapcar'
<Regenaxer>
yes
foxcookie has joined #picolisp
foxcookie has quit [Remote host closed the connection]
razzy has quit [Ping timeout: 240 seconds]
orivej has joined #picolisp
razzy has joined #picolisp
ubLIX has joined #picolisp
<razzy>
how can i get percantage of function that are written in C/assembly?
<Regenaxer>
Something with (cnt '((S) (num? (getd S))) (all))
ubLIX has quit [Quit: ubLIX]
<razzy>
just the number is not helpfull
<Regenaxer>
I'm sure you can calculate the percentage from numbers
<Regenaxer>
But percentage of what? Depends on what you 'load'ed
<Regenaxer>
Initially it is 100%
<Regenaxer>
So pretty meaningless
<freemint>
Regenaxer What is the symbols like ^ which exist but are empty? Your calculation ignores those, or Pico (which is not a function)
<freemint>
*pico
<freemint>
also initially refers to a pure "picolisp" call
<Regenaxer>
'^' is bound to the current expression while single-stepping
<Regenaxer>
(pretty ^) or (eval ^) etc
<Regenaxer>
or just look at it if it is scrolled off the screen
<Regenaxer>
Ah, the percentage calc
<Regenaxer>
right
<Regenaxer>
It is meaningless, all symbols may change dynamically
<Regenaxer>
But ^ is no function anyway
<Regenaxer>
and 'getd' cannot know for sure
<Regenaxer>
it just says what *looks* like a function
<Regenaxer>
If something is a function or not depends on the dynamic context
razzy has quit [Ping timeout: 246 seconds]
razzy has joined #picolisp
<razzy>
i would make only like 20 functions in C/assembly, rest i would
<razzy>
build on top of that [12:18]
<razzy>
<freemint>
There are reasons why this was not done
<freemint>
If PicoLisp was meant to be an educational software this might make sense, but PicoLisp is for production
<freemint>
If you want to understand why i encourage you to reimplement 'filter without 'make. loop, cons, if should be enough
<freemint>
Then you might want to compare speed
<freemint>
Regenaxer do you recall somebody implementing another lisp interpreter in PicoLisp? I've met him on FrosCon and he claimed the Lisp interpreter on top of picolisp was the fastest.
<freemint>
so far
<razzy>
awesome
<razzy>
is scheme good educational lisp?
<freemint>
Well it was the best publicly available around when Lisp was being teached in America and it got some great learning resources because of that.
<freemint>
SICP
<freemint>
for example
<razzy>
nice
<razzy>
btw, i would think, that resources spend on production language would be better spend making 20 or so function and than make rest of picolisp on top of that
<freemint>
in general there could be Lisps that are better but so far none have surfaced
<freemint>
razzy the code in PicoLisp to implement filter is more complicated than the one in assembly
<razzy>
filter?
<freemint>
(in so far as that code is common in trivial in ask but is hugely different from the common code in Lisp)
<freemint>
also there is speed
<freemint>
(doc 'filter)
<Regenaxer>
ret
<Regenaxer>
freemint, yes, I remember that somebody implemented on top of Pil, but I forgot the details
<freemint>
me too
<freemint>
anyhow just wanted you to know
<Regenaxer>
And, yes, assembly is easier for low-level stuff than Lisp or even C
<Regenaxer>
afp
_whitelogger has joined #picolisp
<razzy>
for interpreter making
<razzy>
and few basic function
libertas has joined #picolisp
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #picolisp
pierpal has quit [Quit: Poof]
pierpal has joined #picolisp
ErrantEgo26 has joined #picolisp
ErrantEgo26 has quit [Remote host closed the connection]
<Regenaxer>
ret
<Regenaxer>
Not few
<Regenaxer>
All primitives
<Regenaxer>
You can easily try. Implement the core functions one after the other in Lisp.
<Regenaxer>
But keep in mind that they will get 10 to 20 times slower
erkin has joined #picolisp
<razzy>
wow
<freemint>
Regenaxer you are giving yourself less credit that you earn for implementing an fast interpreter ... it less that 10 x I'm my experiments
<Regenaxer>
Well, yes, depends on what the function does
freemint has quit [Ping timeout: 246 seconds]
freeemint has joined #picolisp
orivej has quit [Ping timeout: 245 seconds]
TingPing10 has joined #picolisp
TingPing10 has quit [Remote host closed the connection]
<razzy>
Regenaxer: function catalog (i tried core functions and list) suggest one coherent mind behind design, focused on assembly theme
<Regenaxer>
Hmm, what does that mean?
e0 has joined #picolisp
e0 has quit [Remote host closed the connection]
<razzy>
i believe you it is very eficient lisp. high concept are hard to read. and it is hurting new userbase
<razzy>
or more preciselly, i did not get used to the lang yet
<Regenaxer>
The reference is too terse, right
<razzy>
personally i tried and not understood streaming from (in) to (out) in one sexp
<Regenaxer>
Which point do you not understand?
<razzy>
clipping new userbase is not a bad thing, you do not want stupid people in your userbase
<razzy>
buuuuut, being lisp is clipping enough
<razzy>
:)
<Regenaxer>
T
<Regenaxer>
You mean (in A (out B (echo))) ?
<razzy>
i do not have intuitive understanding what is done with multiple functions (in "file" (in_this_area) )
<razzy>
are they run on file?
<Regenaxer>
Any input function read somewhere reads from this stream
<Regenaxer>
"somewhere" means in this dynamic context
<Regenaxer>
afp
<razzy>
i am afraid of "dynamic context" it is imho fine on lisp borderline, like in/out functions, running scripts, etc. should be aproprietly vaguely defined. something like (in) open streams from whatever source. but it is necessary to stick to that description. i than see this (out "c" # Merge the contents of "a"
<razzy>
(while (read) # Read an item from "a",
<razzy>
(in "a"
<razzy>
(in "b" # and "b" into "c"
<razzy>
(println @ (in -1 (read))) ) ) ) ) # print it with an item from "b"
<razzy>
<razzy>
and it makes my head spin, and i loose grip of what its going under the hood
<razzy>
i mean some function feel over-stressed? too much context dependent usability?
<razzy>
there could be separate advanced-user manual, with more magic ussage
<razzy>
or some functionality could be maked to magic-in function
<razzy>
i mean (in* ) functionality
<Regenaxer>
ret
<Regenaxer>
OK. Another way would be to use a coroutine for one input channel
<Regenaxer>
I think such multiple reads are very seldom on files
<Regenaxer>
more typical are sockets and pipes
<Regenaxer>
and there you have an open file descriptor
jlf24 has joined #picolisp
<Regenaxer>
(in ... (while (read) ... (in Fd1 ...) (in Fd2 ...))) etc
jlf24 has quit [Remote host closed the connection]
<razzy>
i am trying to describe feelings of learner.
<razzy>
Regenaxer: do you understand my issue? navigating feels like it is more hussle than it needs to be
<Regenaxer>
Navigating the references?
<razzy>
navigating and uderstanding functions
<razzy>
Regenaxer: i understand that ease-of-understanding and efficiency are mostly opposing goals. i am now at understanding part, maybe it change later
<Regenaxer>
Hmm, for me it all looks easy of course, so I cannot be helpful here
<razzy>
if i spend so much time doing it, i would also consider it easy
<razzy>
or more likely, i would build system that i consider easy
ZexaronS has joined #picolisp
ZexaronS has quit [Remote host closed the connection]
freemint has joined #picolisp
freeemint has quit [Ping timeout: 244 seconds]
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #picolisp
pierpal has quit [Client Quit]
pierpal has joined #picolisp
<razzy>
if there is list of wishes, i would like to abolish unless. seems redundant and hardly used. (while) and (not) should be enough.
<razzy>
it is more important to remove code than add one
ubLIX has joined #picolisp
<razzy>
and more used functions should be shorter
<freemint>
are you proposing changing the which symbols are bound to
<freemint>
razzy i find unless very useful
<freemint>
it makes thinking easier.
<razzy>
(while (not T is worse?
<razzy>
we shall limit number of functions in basic picolisp
<Regenaxer>
'unless' is one of the most often used flow functions
<Regenaxer>
The complement of 'when'
<Regenaxer>
As with 'while' <-> 'until'
<Regenaxer>
(while (not is a *lot* worse
<Regenaxer>
it needs an additinal function call
<Regenaxer>
we need complementary functions like those in my opinion
<Regenaxer>
'if' <-> 'ifn', 'cond' <-> 'nond'
<Regenaxer>
Why are you so picky with these functions? They do no harm
<Regenaxer>
And they are not at all hard to understand
<Regenaxer>
You can delete them and build your own if you (don't) like
<Regenaxer>
Here it would do havoc
<Regenaxer>
I use 'unless' a lot, only in this directory (not counting old projects):
<Regenaxer>
Very stupid to give up such an important function just for obscure reasons
k6ka22 has joined #picolisp
pierpal has quit [Ping timeout: 250 seconds]
k6ka22 has quit [Read error: Connection reset by peer]
<razzy>
Regenaxer: harm is done when newcomer need to build big lookup table in his head.also making bigger lookuptable for interpretter(not significant issue). Regenaxer complementary function are great, love them. should be more marked in
<razzy>
references
alexshendi has joined #picolisp
<Regenaxer>
No. Just ignore functions you don't need at the moment
<razzy>
statistic on rossetta says unless makes 100 hits, while 100 hits. in my view, non significant :] should be in your special or extended library
<Regenaxer>
Don't use it
<Regenaxer>
But stop complaing, build your own version!
<razzy>
and when i find a good way to exclude core functions i will :]
rob_w has joined #picolisp
<Regenaxer>
vi is your friend
<Regenaxer>
delete 17 lines from src64/flow.l and one from src64/glob.l
<Regenaxer>
Sigh, never had such a stupid discussion here
<Regenaxer>
afp
deltab15 has joined #picolisp
deltab15 has quit [Remote host closed the connection]
<freemint>
Regenaxer i take that as a compliment
alexshendi has quit [Quit: Yaaic - Yet another Android IRC client - http://www.yaaic.org]
<razzy>
funny, i was thinking the same thing
alexshendi has joined #picolisp
orivej has joined #picolisp
<razzy>
Regenaxer: for the record, i sometimes find usefull function by random reading. (if i do not know i could look for it) so limited amout of functions is good, because it cut the noise.
orivej has quit [Ping timeout: 240 seconds]
freemint has quit [Remote host closed the connection]
freemint has joined #picolisp
pierpal has joined #picolisp
rob_w has quit [Read error: Connection reset by peer]
pierpal has quit [Ping timeout: 244 seconds]
ubLIX has quit [Ping timeout: 246 seconds]
ubLIX has joined #picolisp
<razzy>
question what is /1 /2 in function name. for example pilog (retract) (retract/1)
<freemint>
number of parameters convention came from prolog
<razzy>
inference tree,.. not binary but propabilistic
<razzy>
i was curious, what lvl of support picolisp gives
<razzy>
i could build NN in picolisp, or build propabilistic module on pilog.
<razzy>
investigating another angle
<razzy>
freemint: i bet number convetion was needed for older machines and for load-predicting and load-distributing?
<freemint>
you mean for prolog?
<razzy>
yop
<freemint>
wrong
<freemint>
function with 2 parameter and function with 3 are different functions. and in case you want to talk about function (for example pass them or documentation) you need to know which function you are talking about
hsiktas5 has joined #picolisp
<razzy>
i think there is no point in talking pprolog here
ubLIX has quit [Quit: ubLIX]
hsiktas5 has quit [Remote host closed the connection]
ManyRaptors26 has joined #picolisp
pierpal has joined #picolisp
ManyRaptors26 has quit [Remote host closed the connection]