```
@Retention(CLASS)
@Target(METHOD)
public @interface Fallback
```
A method annotated with Fallback is treated as a Specialization that implicitly links all the guards of all other declared Specialization annotated methods of the operation in a negated form. As a consequence it cannot declare any other guards. The expected signature of the method must match to the signature of a Specialization with the additional limitation that only generically executable argument types are allowed. A generically executable argument is a an argument hat can be executed from the child Node using an execute method without UnsupportedOperationException. In many cases the generically executable type is Object. An operation is limited to just one Fallback specialization which is always ordered at the end of the specialization chain.

A simple example showing the use of the Fallback annotation in a DSL operation:
```
 @Specialization int doInt(int a) {..}
 @Specialization int doDouble(double a) {..}
 @Fallback int orElse(Object a) {..}
 
```
The previous example could be redeclared just using Specialization annotated methods as follows:
```
 @Specialization int doInt(int a) {..}
 @Specialization int doDouble(double a) {..}
 @Specialization(guard={"!isInt(a)", "!isDouble(a)"})
 int orElse(Object a) {..}
 
```
Performance note: For operations with a lot of Specialization annotated methods the use of Fallback might generate a guard that is very big. Try to avoid the use of Fallback for specializations that are significantly important for peak performance.
See Also:

Specialization, NodeChild

Annotation Type Fallback