Scala DSL: metodo di concatenazione con metodi parametrici

Question

Sto creando una piccola scala DSL e sto correndo il seguente problema a cui non ho davvero una soluzione. Un piccolo esempio concettuale di ciò che voglio raggiungere:

(Compute 
write "hello" 
read 'name 
calc() 
calc() 
write "hello" + 'name 
) 

il codice che definisce questo dsl è più o meno questo:

Object Compute extends Compute{ 
    ... 
implicit def str2Message:Message = ... 
} 
class Compute{ 
def write(msg:Message):Compute = ... 
def read(s:Symbol):Compute = ... 
def calc():Compute = { ... } 
} 

Ora la domanda: come posso liberarmi di queste parentesi dopo calc ? È possibile? se é cosi, come? semplicemente ometterli nella definizione non aiuta a causa di errori di compilazione.

Answer 1

Ok, penso, ho trovato una soluzione accettabile ... io ora raggiunto questo possibile sintassi

| write "hello" 
| read 'name 
| calc 
| calc 
| write "hello " + 'name 

utilizzando un oggetto denominato "|", io sono in grado di scrivere quasi dsl che volevo . normale, un ";" è necessario dopo calc se è senza parametri. Il trucco qui è accettare l'oggetto DSL stesso (qui, è il "|" sulla riga successiva). rendendo implicito questo parametro è inoltre possibile specificare calc come ultima istruzione in questo codice. beh, sembra che non sia assolutamente possibile averlo nel modo che voglio, ma anche questo è ok

Answer 2

Prima prova a rimuovere le parentesi dalla definizione di calc. In secondo luogo, provare a utilizzare le parentesi graffe intorno all'intero anziché le parentesi. Parentesi graffe e parentesi graffe non significano la stessa cosa e trovo che la parentesi funzioni meglio nel codice a riga singola (a meno che non si utilizzi il punto e virgola). Vedi anche What is the formal difference in Scala between braces and parentheses, and when should they be used?

Answer 3

Non è possibile eliminare la parentesi, ma è possibile sostituirla. Per esempio:

object it 

class Compute { 
def calc(x: it.type):Compute = { ... } 

(Compute 
write "hello" 
read 'name 
calc it 
calc it 
write "hello" + 'name 
) 

Per espandere un po ', ogni volta che Scala vede qualcosa di simile:

object method 
non-reserved-word 

Si presuppone che significa object.method(non-reserved-word). Viceversa, quando vede qualcosa di simile:

object method object 
method2 object2 

Assume questi sono due istruzioni indipendenti, come in object.method(object); method2.object, aspettando method2 essere un nuovo oggetto, e object2 un metodo.

Questi presupposti fanno parte della grammatica di Scala: è destinato a essere in questo modo apposta.