<aw->
look at the function (de load-routes in his code
<aw->
toward the end
<aw->
it's so funny
<aw->
) # fi
<aw->
) # let
<aw->
) # for
<aw->
) # in
<aw->
to keep track of the parens
<abu[7]>
hihi
<abu[7]>
(when (not (= o T)) ... sigh
<abu[7]>
He never heard or 'unless' or 't?'
<abu[7]>
Also, (= "T" T) wouly give T
<abu[7]>
I should not look deeper. Each line I hit makes me shudder.
<abu[7]>
Thanks for the supporting mail aw-!
pablo_escoberg has joined #picolisp
<pablo_escoberg>
Well, all the above makes me feel a little better, as there are worse offenders than me and at least I try ;-). But I'm pretty sure I'll keep the `)` on it's own line. I'm just used to doing a lot of line-level editing which completely breaks when I close all parens on the same line.
<abu[7]>
Yeah, you also suffered from the lowcVars syndrome, but I think you improved
<abu[7]>
The parens are not dangerous, just ugly
<abu[7]>
Editing lines is not lispy, you edit expressions
<abu[7]>
Lisp is not Fortran or Assembler
<pablo_escoberg>
Yeah, getting the hang of uppercasing the vars. It should probably be made more clear in the docs that pretty much everything in functions should be upper case. It left me with the impression that only argments in the definition need to be uppercase.
<abu[7]>
"pretty much everything in functions" is not uppercased. Globals are not, only locally bound symbols
<pablo_escoberg>
As for editing, I suppose if you're in emacs there are things there that make that kind of thing easier. But vim is language agnostic and offers lots of cool editing features that work on lines. closing parens on their own lines makes using those easier. Though your point is taken. I will play around more with stuff that works at the `%`
<pablo_escoberg>
level and maybe adopt that style.
<pablo_escoberg>
I thought globals were copitalized with a`*` prepended, no?
<abu[7]>
yes, but symbols like 'car' or 'http' are also global, right?
<pablo_escoberg>
yes, but I think of those as builtins, which is to say I shouldn't make any more of them.
<abu[7]>
There is no formal distinction for built-ins
<pablo_escoberg>
oh, but I guess any function I create does create more of them...
<pablo_escoberg>
ok, that also makes sense.
<abu[7]>
See the grid function in simul.l
<abu[7]>
It creates globals a1, a2, ..
<abu[7]>
These are not functions
<abu[7]>
but still global
<pablo_escoberg>
ah, ok.
<abu[7]>
The naming convention are about the binding scope
<pablo_escoberg>
IAC, let me go over the docs again for the naming conventions and make sure. I'll see if I can suggest anything that makes it clearer that all locally bound variables within functions need to be capitalized. It may be that I just missed something obvious, but it could also be unclear. BRB
<abu[7]>
yeah
<abu[7]>
Naming Conventions in ref.html
<abu[7]>
Global variables, Global constants, Functions are kind of global values
<abu[7]>
Locally bound symbols are the ones we were talking about
<pablo_escoberg>
nope, it's pretty clear. my fault.
<abu[7]>
BTW, Local functions have nothing to do with binding
<abu[7]>
This is meant file local
<abu[7]>
the lexical local context
<abu[7]>
It took me a long time to get concious of these separations
<pablo_escoberg>
I don't understand the difference.
<abu[7]>
Some things are static
<pablo_escoberg>
I was curious about that when rereading the section. I guess I haven't run into any local functions yet...
<abu[7]>
ah
<abu[7]>
ok
<abu[7]>
A local function is one that depends on another function
<abu[7]>
Often has free variables defined in another fun
<pablo_escoberg>
oh, so defined inside another function; a closure.
<abu[7]>
So the local function makes sense only when called from the other one
<abu[7]>
No
<abu[7]>
(de _fun () (print X))
<pablo_escoberg>
ah, I see.
<abu[7]>
(de bar () (let X (bla) ... (_fun) ...))
<pablo_escoberg>
no wonder I haven't run into it.
<abu[7]>
It is not so common, and not good style
<abu[7]>
But sometimes more efficient
<pablo_escoberg>
yeah, I NEVER code like that.
<abu[7]>
@lib.l has (de _pretty "Prg"
<pablo_escoberg>
there's always a better way in my experience.
<pablo_escoberg>
but I can definitely see where you would want to mark those out as different...
<pablo_escoberg>
well, I don't understand that stuff anyway, but if the time comes to learn it, I'll bear that in mind.
<abu[7]>
No hurry :)
<pablo_escoberg>
:)
<pablo_escoberg>
so I just got done saying I never code like that, but I am thinking of doing something similar and wonder if it's considered a local function: If I create a function that takes unevaluated args `Args` and do something like `((car Args) (setq foo 'bar) (cdr Args)` are the functions sent to that function considered local functions?
<pablo_escoberg>
oops, forgot to close the last paren...
<abu[7]>
I would say the definition of that function does not matter. It is local if it makes no sense outside the context
<abu[7]>
It is not callable by itself from the outside
<abu[7]>
Like a private symtol, but a local function _foo is accessible for (debug '_foo) etc.
pablo_escoberg has quit [Ping timeout: 246 seconds]
<pablo_escoberg>
yeah, I have to figure out all the differences between `let` `use` `bind` and such. I know it's mostly to do with evaluating vs non-evalutuating, but there's clearly more than that.
<abu[7]>
'let' and 'use' have the symbols hard coded
<abu[7]>
So you are right, the symbols are not evaluabned
<pablo_escoberg>
cool. guess I have that down :)
<abu[7]>
(bind 'A is (use A
<pablo_escoberg>
right, cool.
pablo_escoberg has quit [Quit: Client closed]
pablo_escoberg has joined #picolisp
<beneroth>
a local or inline functions is one which works with non-global variables it didn't receive in its argument list
<beneroth>
that is the definition, I would say
<beneroth>
usually only small helper functions. like parts of a bigger function which are used/called multiple times or which work in a big environment with many local variables which would be unnecessary cumbersome (and costing performance) to put all into the argument list
<pablo_escoberg>
Yeah, I grok that. Regardless of how it ends up that way, it's a function that can only be called in certain scopes and should be marked that way. I will avoid those as much as possible. Trying to do something similar with closures, and I'm pretty close.
<abu[7]>
Yes, well described
<abu[7]>
afp
pablo_escoberg has quit [Ping timeout: 246 seconds]