invoked object notation enables defining actions & information as observable & encapsulated software objects:
~ { log : '👋🏾👨🏾‍💻' } <= /do transcription/
+ { "json" : "data" } <= /json information/
& ["natural language"] <= /text information/
ion was discovered, defined & developed by michael lee in 2007, and exists & can be implemented within procedural operator overloading languages.
ion combines one or more objects with operators that invoke their action(s) and-or observation.
ion combines the ~ bitwise-not, +, and - unary operators, with operands that can be array, object, or regular expression literals in javascript, or references in javascript and other languages.
ion can be expressed as lion, literal ion:
~{ } +{ } -{ } // 3 object lions
~[ ] +[ ] -[ ] // 3 array lions
~/ / +/ / -/ / // 3 regular-expression lions
and orion, object reference ion:
~obj +obj -obj // 3 prefixed orion
orion can also be expressed with the ++ and – prefix operators, and the ++ and – postfix operators:
++obj, --obj // 2 prefixed orion
obj++, obj-- // 2 postfixed orion
ions can be combined to form larger expressions via arithmetic, bitwise, relational & equality operator punctuation.
this example combines fifteen lions with seventeen ion-compatible bitwise, arithmetic, relational & equality punctuation operators:
~ /example/ - /punctuation/
^ ["aesop"] & / stories / >> {are:"ions"}
* ["these"] + /expressions/ << {are:"too" }
/ ["write"] % /them as you/ | {see:"fit" }
> ["using"] >= / any of / <= [ "these" ]
< 17 == / compatible/ != "operators!"
as shown
arithmetic punctuation can be any of the +, -, *, /, or % operators,
bitwise punctuation can be any of the &, ~, |, [^](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Bitwise_XOR), «, or >> operators,
relational punctuation can be any of the >, >=, <, or <= operators,
and equality punctuation can be the == or != equality operators when comparing ions with basic values.
ion is enabled by operator overloading in multiple languages.
enables ion via hip-hop operator overloading of the valueOf()
& toString()
methods invoked
during an
object’s
conversion
to a basic value.
hip: handled-in-place operator overloading implements the valueOf()
method within an object, which enables observing that single object’s type
conversion whenever it’s expressed with an operator:
~
{ valueOf:
function hip ()
{ console.log ("hip: handled-in-place")
}
}
hop: handled-on-prototype operator overloading implements the valueOf()
method on a prototype
object, which enables observing the type conversions
of all objects sharing that prototype
whenever they’re expressed with an
operator:
Object.prototype.valueOf
= function hop ()
{ console.log ('hop: handled-on-prototype') /*\
| enables observing all invoked objects except |
| BigInts, Booleans, Dates, Numbers, Strings, |
| Symbols & any others that implement their own |
| valueOf() method. \*/
}
~ { hello : "👋🏾👨🏾‍💻world"}
hip-hop operator overloading the valueOf()
method enables expressing &
punctuating
ions with these arithmetic, bitwise, relational & equality operators:
~ /example/ - /punctuation/
^ ["aesop"] & / stories / >> {are:"ions"}
* ["these"] + /expressions/ << {are:"too" }
/ ["write"] % /them as you/ | {see:"fit" }
> ["using"] >= / any of / <= [ "these" ]
< 17 == / compatible/ != "operators!"
hip-hop operator overloading the toString()
method enables expressing sentences &
phrases with ions punctuated by the +
operator, but overloading the valueOf()
method enables even more punctuation, and since it’s less likely than
toString()
to be otherwise overloaded and-or invoked, overloading toString()
is not
recommended:
Object.prototype.valueOf // vs .toString
= function hop ()
{ console.log (this.say) /*\
| or do something more profound! \*/
}
var you = {say:'do you see all the things'}
, can = {say:'we can do' }
, write = {say:'if we write' }
, code = {say:'our code' }
, as = {say:'as groups of'}
, prose = {say:'phrases & sentences?! 🤓'}
'with orion' - you - can - write + code - as -
prose;
during hip-hop operator overloading, an attempt is made to
convert an ion’s object operand to a number.
that conversion attempts to invoke the object operand’s valueOf()
method. if the ion
doesn’t define that method, javascript searches for it along the ion’s
prototype path.
for lions that search begins & ends at their
prototype
; i.e. Object.prototype
, Array.prototype
or RegExp.prototype
. for
orion the search may end similarly but begin with the ion’s inherited
object.
Object
, Array
& RegExp
all define a prototype.valueOf()
method, so for each ion
of those types, their operator causes the ion’s inherited prototype.valueOf()
method
to be invoked to obtain a
basic value
that’s then converted to a number.
defining custom Object
, Array
& RegExp
prototype.valueOf()
methods
enables interfacing with javascript objects’ type conversion flow. that then
enables interacting with all ions without needing access to any of their
identifiers
🤓
Object.prototype.valueOf
= function onObject ()
{ this.ion == "some data" // true on 1st ion!
; this.ion == "more data" // true on 2nd ion!
; this.any == "data kind" // true on 3rd ion!
}
~ {ion:"some data"} // 1st ion
+ {ion:"more data"} // 2nd ion
- {any:"data kind"} // 3rd ion
javascript’s hip-hop operator overloading is a simple & reliable pattern for enabling ion observation & notification. it can be implemented manually, as shown, or via ionify: invoked object notation implemented for you, a flexible & unobtrusive natural-language api that implements & provides vocabulary for: ion observation, notification & interaction, for you.
enables orion via hot: handled-on-type operator overloading by
implementing an object type’s toString()
method, which enables overloading the
+
operation for objects of that type.
here’s an in-depth proof-of-concept:
class AnION
{ public String
ion = null,
any = null;
public AnION
(String ion)
{ this.ion = ion;
}
public String
toString ()
{ ion == "some data"; // true on invoke ion!
ion == "more data"; // true on these ion!
any == "data kind"; // true on ions ion!
return ion || any ; // or do something else!
}
}
class ActIONs
{ public static void
main (String [] args)
{ AnION invoke = new AnION ("some data"),
these = new AnION ("more data"),
ions = new AnION ( ),
now = new AnION ( );
ions.any = "data kind" ;
"let's" + invoke + these + ions + now ;
}
}
enables orion by applying hot: handled-on-type operator overloading via numeric type emulation.
here’s a proof-of-concept:
class Ion:
def getName(self):
return 'python.hip.ion!'
def __repr__(self):
return '<hip.ion>'
def __str__(self):
return 'hip.ion!'
def __add__(self, other):
print ('hip.ion + something!')
return 'hip.ion + something!'
def __neg__(self):
print ('-hip.ion!')
return '-hip.ion!'
def __pos__(self):
print ('+hip.ion!')
return '+hip.ion!'
def __invert__(self):
print ('~' + self.getName())
return '~hip.ion!'
ion = Ion()
~ ion
+ ion
- ion
ion + 777
repr (ion)
print (ion)
enable orion via procedural operator overloading of arithmetic, bitwise, relational & equality operators.
orion & hip-hop operator overloading are compatible with all javascript environments. lion is compatible with all environments implementing any edition of the ecmascript specification since 1999.
javascript environments include all web browsers, web views & runtimes implementing any ecmascript specification.
####
🙇🏾‍♂️ through * יהוה * impossible -is- nothing || 🇬🇾👨🏾‍💻🇺🇸 mike lee & team 🤲🏾