10.2: adda/lexicon/!:
. if (!) means {unique, constant},
it can also mean the literals of a type-def;
because literals are symbolic constants;
eg, type = <
!:{...}, oper's: ...,
>
. here are parameterized enum's
(ie, functions can name const values (enums)):
!{.(x in ..., y in ...), f(x), g(x,y), ... } .
mis.adda/lexicon/!!:
10.2:
. the first draft of the above had thought they had opposite meanings,
so then I thought [!!] should be a shorthand for [causes variation] .
10.16:
. use exponents like x!!y
-- wanted x!y but may want to keep x! as postfix for factorial .
adda/lexicon/!!:
10.4:
. following the example of unix,
where [//] is related to [/]:
{root of internet, root of local network};
and, [..] is related to [.]:
{ parent.directory, current.directory }
what is related to constant [!]
such that [!!] would be meaningful?
. it could mean constant at a higher level,
where if a type implies the use of a pointer,
then a [!] would simply mean that the paramater is not out.mode,
while a [!!] reassures you that
if the parameter provides access to externals,
then none of those externals will be modified either .
10.23:
. with (x)! having a sort of power function, (1*2* ... x),
(x!!y) could make sense as the binary power function x*^y .
adda/lexicon/[?!]
10.9: adda/syntax/absolutely:
. many times you want to insure
that a condition exists;
so you test for it;
and, make it so, if needed .
. that routine can symbolized by
following a question with an exclamation point .
eg,
var = value ?! --. no? var`= value .
file exist?! --. no? create it .
10.8:
adda/lexicon/taking double-quotes literally:
. rather than use "("()) or ""() to indicate string literal,
use '() to represent single nestable quotes;
then use "() as a short hand for '('()) .
10.9: adda/lexicon/num`log#base:
. try to recall various intuitive ways of representing log symbol:
log#b(x) should be x//b ?
if x**b = x*^b means x* x* ...* x#b ,
then doesn't x//b = x/^b rather than log#b(x) ?
better was a later idea of [b*^?=](x) .
adda/lexicon/num`modulus:
. remainder or modulus = x ~| y --. the complement of div .
10.11: adda/lexicon/xor operator:
. xor was once thought to be the ~=,
but generalizing to sets of any universe,
xor is the unique existence operator, (aka the multiop"[or!]);
so, if or's symbol is \() -- short for \/,
then xor could be \! .
. for a multiop ~= to be true,
each arg must have a unique value,
so in the case of truth.var's,
it's defined only as a biop, not a multiop .
10.11: adda/shift operations:
. to follow exponent example,
shift is should use ^ for the number of shiftings .
. like 10**-1 = 1/10,
there should be one shift operator,
and it's param's sign should determine the shift's direction .
10.12:
adda/lexicon/[don't eval] vs [don't parse]:
if "() is the same as '('()) can you mix them?
. say you're working with unicode where there are real quotes,
ie, they different left and right symbols
which we can simulate in ascii with "( )" and '( )' .
so then,
can you do "( ... ') ... )' ?
. no, the ' and " have 2 diffn't jobs:
'() says
[parse this character string into symbols but don't eval it],
"() says
[don't even parse this; leave it as a character string] .
eg,
a function`literal is '()
and it may include a nested function`literal,
so there is an example of '( '(...) ...)
not being the same as "() .
. if, however, you have only one quote character
because for instance you want to reserve ' as the apostrophe,
then you could reuse the double-quote for both:
"(don't eval)
""(don't parse) .
adda/lexicon/[?] as truth.type`symbol:
. why not use ?.type as type truth? ...
adda/lexicon/[.!] constant of type specified by init:
. x.! can mean the type isn't known until init',
but whatever it is, it's constant after that .
10.20: adda/lexicon/[::]:
. operator"[::] may be useful as a filename clarifier;
eg, filename::owner`create-time
. it looks like a colon -- which adda reserves as the label indicator
and param'association by labeling .
. it says a filename can be identified by owner`create-time,
and that the id is labeled by the given filename .
--
. c++ uses it to show class membership: class::attribute,
which is really a possessive relation eg, class`attribute .
--
. math uses it to show a relational equality:
a:b :: c:d
[9.21: . what this really does is clarify how [:].symbol is used;
it really means
relationship(a,b) = relationship(c,d) . ]
10.20: adda/lexicon/[:]/breaks from url syntax:
. I'm trying to stay with url syntax,
but url uses [:].symbol like it's a field separator
as for time format: (hour:minutes) .
. here is the full url:
protocol://pass@domain:port/
where pass is (username:password)
. the port is optional because although both a domain and port are needed,
there are default ports per protocol .
. the domain identifies only a network node address,
but the actual data also needs a mailbox number
as each service provided by the node needs its own mail box .
"( 65,535 TCP Ports and another 65,535 UDP ports.
each app running a service on the same internet node
needs a binding to its own port,
. hearsay has it that designer of url regrets the choice of syntax,
later preferring
com/serverroute/www/
to
//www.serverroute.com/
[10.21:
. it treats the internet as if it was a superfolder
where each node is a file,
with file`type being somewhat similar to datatype
in telling you what services you can expect to get
from objects of that type .
. the later way treats a node as if it were
a mounted volume; just like in unix,
where you can have multiple drives look like
one filesystem
by equating each with some subfolder
of the system's filesystem .
so that the new sytem belonging to the whole world,
would have a root of ( protocol:node`type/)
while the root node would be (/) .
. I do agree partially:
//serverroute.com/www/ ... or
//serverroute.com#www/
so that nodes are completely like files
with all the type info being part of the dotted suffix
and then dotted prefixes get treated like the
subfolders or array selectors they actually are .
] .
10.21: adda/lexicon/decimal point as abbreviation:
. notice how the dot as decimal is like the period as abbreviator:
int.frac = int + frac/10*^n for frac`length = n .
mis.adda/lexicon/string single.quotes not nestable:
10.24:
. notice that one reason english will use "" for quotes,
is that single quotes are mismatched,
with the the closing.single-quote being reused as an apostrophe .
12.9: adda/syntax/apply:
. arg @ f @ g -- syntax like pipes and the familiar email .
. how is email like a function?
name @ [set of id's] returns a named id .
12.13: adda/syntax/why pointers use subfolder notation:
. how is pointer concept equal to a subfolder?
root points at item can be record or single
ptr/ -- returns all items;
then if ptr is a superfoldr and points at a subfolder
it returns a record,
and if you mention a record member name,
then that works like a function,
it returns just the object that was named .
No comments:
Post a Comment