simbolo dell'attributo design della lingua OOP [chiuso]

Question

simbolo dell'attributo design della lingua OOP [chiuso]

#1 da (2 voti)

0

Sto progettando un linguaggio e mi chiedo quale carattere (o stringa) usare per rappresentare quel qualcosa è un attributo di qualcos'altro.

In tutte le lingue che ho usato, questo è fatto con un punto - my_class_instance.attribute .

Tuttavia, in questa lingua, voglio avere quello che di solito sono i metodi come zucchero sintattico per le normali funzioni, in questo modo:

x.f(y, z).g(a, b).h(p, q)

è la stessa cosa di

x = f(x, y, z)
x = g(x, a, b)
x = h(x, p, q)

Tuttavia, se uso anche . per mostrare che un attributo appartiene a una classe, penso che diventi confuso, quindi sto cercando un altro simbolo a tale scopo (o un'altra soluzione).

Attualmente sto pensando che dovrei usare l'apostrofo - instance'attribute - che mostra la proprietà in modo chiaro, ma significa che non può essere usato per le stringhe, l'apice - instance'attribute - un tipo di aspetto come un apostrofo, che è buono nel senso che mostra proprietà, ma cattivo nel senso che potrebbe essere scambiato per uno, ed è meno tipizzato, e quindi è probabile che sia più lento da digitare (e mancante da alcune tastiere).

In alternativa, ci sono dei simboli che potrei sostituire con il punto utilizzato per la funzione di ricerca della funzione inplace syntatic sugar con?

language-design

posta rlms 12.10.2013 - 21:34

fonte

1 risposta

Leggi altre domande sui tag language-design

Qual è la semantica esatta della riduzione in clojure? Come posso gestire le lancette dell'orologio usando il doppio che soffre al massimo di O (log n) bit corrotti all'ennesimo fotogramma del display?

score 2 · Accepted Answer

Prima di tutto, la sintassi dot-method e dot-attribute non si escludono a vicenda proprio allora quando richiedi paren sulle chiamate di metodo. Considera questa parte di Java:

class Foo {
  int bar = 1;

  int bar() { return 2; }
}

...
Foo foo = new Foo();
foo.bar;   // the attribute
foo.bar(); // the method

Ovviamente, non è possibile utilizzare questa funzione della lingua. Quindi la vera domanda è come si disambigano le chiamate di metodo dalle "funzioni in-place". Probabilmente il modo migliore è usare qualche forma di interpolazione . Considera questo Perl:

my $function = sub {
  my ($object, $arg) = @_;
  return $object + $arg;
};
my $x = 40;
say $x->$function(2); #=> 42

dove $x->$y(@z) è zucchero sintattico per &$y($x, @z) . Questa sintassi è ortogonale alle chiamate di metodo che apparirebbero come $x->y o $x->y() . Perl può escluderlo perché le variabili hanno un prefisso $ .

Utilizzare una sintassi simile potrebbe essere raccomandabile, quindi potresti finire con

foo.bar;            // attribute
foo.bar();          // method
foo.$bar();         // inplace function
foo.{bar || baz}(); // alternative interpolation marker

Hai ragione, questo è confuso. Considerare attentamente quale espressività si ottiene utilizzando le funzioni inplace. Nel caso di Perl, la variabile può contenere il nome del metodo, consentendo così ai dati di decidere quale metodo viene chiamato, che in contrasto con lo zucchero sintattico sopra è effettivamente utile.

$foo->bar;
# the same as
my $meth = "bar";
$foo->$meth;

I tuoi "metodi inplace" lo sovraccaricano con un significato molto diverso. Avrebbe più senso per x.$y(z) per significare y(x, z) (come il Perl equivalente). Il tuo esempio con più catene diventerebbe quindi

x = x.$f(y, z).$g(a, b).$h(p, q)
// the same as
x = h(g(f(x, y, z), a, b), p, q)

Nota che qui .$ apparentemente ha le caratteristiche di un gestore di feed . In Perl6, queste due linee sono equivalenti:

@input ==> grep { $_ % 3 == 0 } ==> map { $_ * 2 } ==> my @processed;
# the same as
my @processed = map({ $_ * 2 }, grep({ $_ % 3 == 0 }, @input));

Riepilogo: viene fornito un ottimo motivo per cui vuoi invocare funzioni come se fossero metodi e scegliere semantica sensibile (in particolare l'assegnazione automatica sembra una cattiva idea se tu? mai programmato funzionale).
Quindi, ci sono varie possibilità sintattiche per chiamare funzioni arbitrarie sui tuoi oggetti, che vanno da "interpolation" x.$y() a operatori che enfatizzano il flusso di dati come ==> .