Per divertirmi pensavo a come un paradigma di programmazione potesse differire da OOP e si sarebbe inventato questo concetto. Non ho una solida base in informatica, quindi potrebbe essere un luogo comune senza che io lo sappia (più probabilmente è solo un'idea stupida :)
Mi scuso in anticipo per questa domanda piuttosto sconclusionata, comunque qui va:
Nei normali metodi OOP e le classi sono varianti solo su parametri, ovvero se due diverse classi / metodi chiamano lo stesso metodo ottengono lo stesso output.
La mia idea, forse pazza, è che il metodo e la classe di chiamata potrebbero essere una parte "invisibile" della sua firma e la risposta potrebbe variare a seconda di chi chiama un metodo.
Diciamo che abbiamo un oggetto Window con un metodo Break (), ora chiunque (chi ha accesso) potrebbe chiamare questo metodo su Window con lo stesso risultato.
Ora dì che abbiamo due oggetti diversi, Hammer e SledgeHammer. Se Break necessita di produrre risultati diversi in base a questi, li passeremo come parametri Break (IBluntObject bluntObject)
Con un linguaggio di programmazione mutante (mpl) gli oggetti operativi sul metodo sarebbero visibili al metodo di interruzione senza iniziare in modo esplicito e si potrebbe adottare in base a essi. Quindi se SledgeHammer chiama Window.Break () genererebbe risultati molto diversi rispetto a Hammer.
Se le classi sono caselle nere, le classi mutanti sono caselle nere che sanno chi sta provando a premere i pulsanti e ad adattare il loro comportamento di conseguenza.
Potresti anche avere diversi set di autorizzazioni sui metodi a seconda di chi li sta chiamando piuttosto che avere autorizzazioni assolute come pubbliche e private.
Questo ha qualche vantaggio rispetto a OOP? O forse dovrei dire, aggiungerebbe qualcosa in quanto dovresti essere in grado di aggiungere semplicemente questo aspetto ai metodi (basta dare accesso a una variabile CallingMethod e CallingClass nel contesto)
Non sono sicuro, potrebbe essere difficile per avvolgere la testa, sarebbe piuttosto interessante avere classi che si sono adottate da sole a chi le usa però. Eppure è un concetto interessante, cosa ne pensi, è fattibile?
Ecco alcuni potenziali codici fittizi di un gioco in cui un giocatore ha danneggiato qualcosa. Nella normale OOP molte cose sarebbero invece passate come parametri al metodo, mentre qui Damage "tira" le proprietà che usa. Diverso? si, meglio? forse no:)
Class Player
{
[AccessableBy:Terrain,Player]
void Damage
{
if (#CallingClass has property HitPoints)
{
this.health -= #CallingClass.HitPoints;
}
if (this.health < 0 && #CallingClass is Terrain)
{
ShowMessage("was killed by the environment");
}
else if (health < 0 && #CallingClass is Player && #CallingMethod is RocketLauncher)
{
ShowMessage("was killed with a rocketlauncher by player" + #CallingClass.PlayerName);
}
}
}
Per ridurre le istruzioni if-else, è possibile eseguire l'override del metodo in base ai metodi e alle classi del chiamante