Home » Modeling » TMF (Xtext) » Extend xtend with more extension methods
|
| Re: Extend xtend with more extension methods [message #922235 is a reply to message #922052] |
Mon, 24 September 2012 21:23   |
 Sebastian Zarnekow
Messages: 3109
Registered: July 2009 |
Senior Member |
|
|
You can define a class with a method
operator_doubleArrow(ITreeAppendable, CharSequence) and use that one as
an extension, e.g.
extension MyTreeAppendableUtil
That should do the trick. No recompilation, no altering of the language,
just a library / an API in your project
Regards,
Sebastian
--
Looking for professional support for Xtext, Xtend or Eclipse Modeling?
Go visit: http://xtext.itemis.com
Am 24.09.12 19:34, schrieb Hallvard Trætteberg:
> Hi,
>
> I'm generating code with xtend2 and wonder if I could make the code
> nicer by defining some extra operator_doubleArrow method, so the =>
> operator can be used with an ITreeAppendable on the left hand side.
>
> E.g. instead of append("something") newLine // it is an ITreeAppendable
> I could write it => "something" => '\n'
>
> Is it possible to add such extra methods without rebuilding xtend2? E.g.
> by defining an extension class in your xtext project and using some
> extension point, thus extending xtend?
>
> Hallvard
|
|
| |
| Re: Extend xtend with more extension methods [message #925330 is a reply to message #923018] |
Thu, 27 September 2012 16:10 |
Hallvard Traetteberg
Messages: 673
Registered: July 2009
Location: Trondheim, Norway |
Senior Member |
|
|
On 25.09.12 07.42, Aaron Digulla wrote:
> I suggest to use the left-shift operator, though:
>
> out << "something" << '\n'
>
> is used my most other languages and shows the intent better (if you
> forget for a moment that it also means "shift") since it "points" the
> data into the right direction.
Yes, I came to the same conclusion after looking at the available
operators. I now use the following extension class. Note how the injects
allow serialization of expressions and types.
BTW, I also tried to use operators (extension methods) for higher order
functions like filter, map and reduce, but it seemed the type inference
had problems with the Procedure sublasses and their extensive use of
type parameters.
Hallvard
----8<-----------------------------
package org.ptolemy.xtext.generator;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.xtext.common.types.JvmTypeReference;
import org.eclipse.xtext.xbase.XExpression;
import org.eclipse.xtext.xbase.compiler.TypeReferenceSerializer;
import org.eclipse.xtext.xbase.compiler.XbaseCompiler;
import org.eclipse.xtext.xbase.compiler.output.ITreeAppendable;
import org.eclipse.xtext.xbase.lib.Inline;
import org.eclipse.xtext.xbase.lib.IterableExtensions;
import org.eclipse.xtext.xbase.lib.Pair;
import org.eclipse.xtext.xbase.lib.Functions.Function1;
import org.eclipse.xtext.xbase.lib.Functions.Function2;
import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
import org.eclipse.xtext.xbase.lib.internal.BooleanFunctionDelegate;
import org.eclipse.xtext.xbase.lib.internal.FunctionDelegate;
import com.google.common.collect.Iterables;
import com.google.inject.Inject;
public class TreeAppendableUtil {
@Inject private XbaseCompiler xbaseCompiler;
@Inject private TypeReferenceSerializer typeReferenceSerializer;
public ITreeAppendable operator_doubleLessThan(ITreeAppendable
appendable, CharSequence content) {
if (content.length() > 0) {
preAppend(appendable, content.charAt(0));
}
appendable.append(content);
if (content.length() > 0) {
postAppend(appendable, content.charAt(content.length() - 1));
}
return appendable;
}
public Pair<ITreeAppendable,? extends EObject>
operator_doubleLessThan(Pair<ITreeAppendable,? extends EObject>
appendable, CharSequence content) {
operator_doubleLessThan(appendable.getKey(), content);
return appendable;
}
public ITreeAppendable preAppend(ITreeAppendable appendable, char c) {
switch (c) {
case '}': {
appendable.decreaseIndentation(); appendable.newLine(); break;
}
}
return appendable;
}
public ITreeAppendable postAppend(ITreeAppendable appendable, char c) {
switch (c) {
case '\n': {
appendable.newLine(); break;
}
case '{': {
appendable.increaseIndentation(); appendable.newLine(); break;
}
case ';': {
appendable.newLine(); break;
}
case '}': {
appendable.newLine(); break;
}
}
return appendable;
}
public ITreeAppendable operator_doubleLessThan(ITreeAppendable
appendable, char c) {
preAppend(appendable, c);
appendable.append(String.valueOf(c));
postAppend(appendable, c);
return appendable;
}
public Pair<ITreeAppendable,? extends EObject>
operator_doubleLessThan(Pair<ITreeAppendable,? extends EObject>
appendable, char c) {
operator_doubleLessThan(appendable.getKey(), c);
return appendable;
}
public ITreeAppendable operator_doubleLessThan(ITreeAppendable
appendable, XExpression expression) {
xbaseCompiler.toJavaExpression(expression, appendable);
return appendable;
}
public Pair<ITreeAppendable,? extends EObject>
operator_doubleLessThan(Pair<ITreeAppendable,? extends EObject>
appendable, XExpression expression) {
operator_doubleLessThan(appendable.getKey(), expression);
return appendable;
}
public Pair<ITreeAppendable,? extends EObject>
operator_doubleLessThan(Pair<ITreeAppendable,? extends EObject>
appendable, JvmTypeReference type) {
typeReferenceSerializer.serialize(type, appendable.getValue(),
appendable.getKey());
return appendable;
}
}
|
|
|
| Re: Extend xtend with more extension methods [message #927674 is a reply to message #925330] |
Sat, 29 September 2012 23:19 |
Sebastian Zarnekow
Messages: 3109
Registered: July 2009 |
Senior Member |
|
|
Hi Hallvard,
please file tickets with your findings about Procedures, their type
arguments and the type inferrence.
Thanks,
Sebastian
--
Looking for professional support for Xtext, Xtend or Eclipse Modeling?
Go visit: http://xtext.itemis.com
Am 27.09.12 09:12, schrieb Hallvard Trætteberg:
> On 25.09.12 07.42, Aaron Digulla wrote:
>> I suggest to use the left-shift operator, though:
>>
>> out << "something" << '\n'
>>
>> is used my most other languages and shows the intent better (if you
>> forget for a moment that it also means "shift") since it "points" the
>> data into the right direction.
>
> Yes, I came to the same conclusion after looking at the available
> operators. I now use the following extension class. Note how the injects
> allow serialization of expressions and types.
>
> BTW, I also tried to use operators (extension methods) for higher order
> functions like filter, map and reduce, but it seemed the type inference
> had problems with the Procedure sublasses and their extensive use of
> type parameters.
>
> Hallvard
>
> ----8<-----------------------------
>
> package org.ptolemy.xtext.generator;
>
> import org.eclipse.emf.ecore.EObject;
> import org.eclipse.xtext.common.types.JvmTypeReference;
> import org.eclipse.xtext.xbase.XExpression;
> import org.eclipse.xtext.xbase.compiler.TypeReferenceSerializer;
> import org.eclipse.xtext.xbase.compiler.XbaseCompiler;
> import org.eclipse.xtext.xbase.compiler.output.ITreeAppendable;
> import org.eclipse.xtext.xbase.lib.Inline;
> import org.eclipse.xtext.xbase.lib.IterableExtensions;
> import org.eclipse.xtext.xbase.lib.Pair;
> import org.eclipse.xtext.xbase.lib.Functions.Function1;
> import org.eclipse.xtext.xbase.lib.Functions.Function2;
> import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
> import org.eclipse.xtext.xbase.lib.internal.BooleanFunctionDelegate;
> import org.eclipse.xtext.xbase.lib.internal.FunctionDelegate;
>
> import com.google.common.collect.Iterables;
> import com.google.inject.Inject;
>
> public class TreeAppendableUtil {
>
> @Inject private XbaseCompiler xbaseCompiler;
> @Inject private TypeReferenceSerializer typeReferenceSerializer;
>
> public ITreeAppendable operator_doubleLessThan(ITreeAppendable
> appendable, CharSequence content) {
> if (content.length() > 0) {
> preAppend(appendable, content.charAt(0));
> }
> appendable.append(content);
> if (content.length() > 0) {
> postAppend(appendable, content.charAt(content.length() - 1));
> }
> return appendable;
> }
> public Pair<ITreeAppendable,? extends EObject>
> operator_doubleLessThan(Pair<ITreeAppendable,? extends EObject>
> appendable, CharSequence content) {
> operator_doubleLessThan(appendable.getKey(), content);
> return appendable;
> }
>
> public ITreeAppendable preAppend(ITreeAppendable appendable, char c) {
> switch (c) {
> case '}': {
> appendable.decreaseIndentation(); appendable.newLine();
> break;
> }
> }
> return appendable;
> }
>
> public ITreeAppendable postAppend(ITreeAppendable appendable, char
> c) {
> switch (c) {
> case '\n': {
> appendable.newLine(); break;
> }
> case '{': {
> appendable.increaseIndentation(); appendable.newLine();
> break;
> }
> case ';': {
> appendable.newLine(); break;
> }
> case '}': {
> appendable.newLine(); break;
> }
> }
> return appendable;
> }
>
> public ITreeAppendable operator_doubleLessThan(ITreeAppendable
> appendable, char c) {
> preAppend(appendable, c);
> appendable.append(String.valueOf(c));
> postAppend(appendable, c);
> return appendable;
> }
> public Pair<ITreeAppendable,? extends EObject>
> operator_doubleLessThan(Pair<ITreeAppendable,? extends EObject>
> appendable, char c) {
> operator_doubleLessThan(appendable.getKey(), c);
> return appendable;
> }
>
> public ITreeAppendable operator_doubleLessThan(ITreeAppendable
> appendable, XExpression expression) {
> xbaseCompiler.toJavaExpression(expression, appendable);
> return appendable;
> }
> public Pair<ITreeAppendable,? extends EObject>
> operator_doubleLessThan(Pair<ITreeAppendable,? extends EObject>
> appendable, XExpression expression) {
> operator_doubleLessThan(appendable.getKey(), expression);
> return appendable;
> }
>
> public Pair<ITreeAppendable,? extends EObject>
> operator_doubleLessThan(Pair<ITreeAppendable,? extends EObject>
> appendable, JvmTypeReference type) {
> typeReferenceSerializer.serialize(type, appendable.getValue(),
> appendable.getKey());
> return appendable;
> }
> }
>
|
|
|
Goto Forum:
Current Time: Tue Apr 20 01:56:15 GMT 2021
Powered by FUDForum. Page generated in 0.02374 seconds |
Search
Help
Register
Login
Home
