mySet = new HashSet(empty);
void setup() {
mySet.add(PVector.random3D(this));
println(empty, mySet);
exit();
}
```
---
### Author:  [@jeremydouglass](https://discourse.processing.org/u/jeremydouglass)
#### Post date: [April 21, 2019, 8:48pm UTC](https://discourse.processing.org/t/why-does-type-inference-not-work-in-the-processing-editor/10467/12 "2019-04-21T20:48:49Z")
What the preprocessor reads and writes is (largely) documented in the reference – if not, there is some [documentation of the compiling process](https://processing.org/reference/environment/) and then it is straight to the preprocessor source, which is in [Antlr](https://github.com/processing/processing/tree/349f413a3fb63a75e0b096097a5b0ba7f5565198/java/src/processing/mode/java/preproc). So, if the syntax from Java that you are using appears in the Processing reference or examples, then that is Processing. If it doesn’t, then you can always try and see! Processing is mostly documented declaratively, for learners, like a language – “I can do this” – not differentially, “this is an enumeration of the ways I’m different from Java 7 / 8.” For that, there is mainly experience and forum lore (and the source).
If you don’t WANT to write in Processing – an intentionally simplified syntax that primarily targets beginners and artists – then you can still write Java in .java files that are part of a .pde sketch folder. Or, even better, use an Eclipse project instead of PDE and work with the full Processing API, but not the PDE format or compiler – just write it all in 100% Java, with no pde. It seems like that _might_ be what you want…?
---
### Author:  [@LoliProcessor](https://discourse.processing.org/u/LoliProcessor)
#### Post date: [April 22, 2019, 9:45am UTC](https://discourse.processing.org/t/why-does-type-inference-not-work-in-the-processing-editor/10467/13 "2019-04-22T09:45:39Z")
Then I guess the Folder of your processing sketch (where the data folder is inside as well) acts as the default package of your module.
But good to know that you can mix .java and .pde files.
---
### Author:  [@jeremydouglass](https://discourse.processing.org/u/jeremydouglass)
#### Post date: [April 22, 2019, 2:14pm UTC](https://discourse.processing.org/t/why-does-type-inference-not-work-in-the-processing-editor/10467/14 "2019-04-22T14:14:48Z")
> [@LoliProcessor](#):
>
> acts as the default package of your module.
For more on how that works in PDE (vs eclipse) also read the two “Advanced” note boxes in the documentation I linked above. You can also subclass PApplet within PDE and do all-java there, but your classes are no longer automatically inner classes, so some of the PDE “just works” magic is gone – passing around PApplet is required. At that point it starts making sense to set up the Processing Eclipse Template instead.
[https://processing.org/tutorials/eclipse/](https://processing.org/tutorials/eclipse/)
---
### Author:  [@GoToLoop](https://discourse.processing.org/u/GoToLoop)
#### Post date: [April 22, 2019, 8:52pm UTC](https://discourse.processing.org/t/why-does-type-inference-not-work-in-the-processing-editor/10467/15 "2019-04-22T20:52:56Z")
> [@LoliProcessor](#):
>
> Then I guess the folder of your processing sketch… acts as the default `package` of your module.
The PDE concatenates all “.pde” files and transpiles them as 1 valid “.java” file wrapped up as 1 PApplet subclass.
But the PDE doesn’t add the keyword `package` to this unified “.java” file. So it’s kinda “packageless”.
However, we can use the keyword `package` in our own “.java” files, if we really feel like it:
>
But even if we do use `package` in our “.java” files, using `import` inside our “.pde” files, in order to access those “.java” sketch files, is still optional.
That is, even though I’ve included `package gotoloop.countdown;` inside “Countdown.java”, that `import gotoloop.countdown.Countdown;` statement inside “CountdownClass.pde” isn’t really needed at all.
---
### Author:  [@LoliProcessor](https://discourse.processing.org/u/LoliProcessor)
#### Post date: [April 23, 2019, 12:35pm UTC](https://discourse.processing.org/t/why-does-type-inference-not-work-in-the-processing-editor/10467/16 "2019-04-23T12:35:27Z")
Are you sure about your statement about the import statement not being required.
Using a packaged class without import gives error:
Cannot find a class or type named “class\_name”
---
### Author:  [@neilcsmith](https://discourse.processing.org/u/neilcsmith)
#### Post date: [April 23, 2019, 12:52pm UTC](https://discourse.processing.org/t/why-does-type-inference-not-work-in-the-processing-editor/10467/17 "2019-04-23T12:52:04Z")
> [@jeremydouglass](#):
>
> If you don’t WANT to write in Processing – an intentionally simplified syntax that primarily targets beginners and artists
The decision to change language syntax, as opposed to just structural syntax, is probably the worst decision Processing made. It’s what makes adopting Java 7/8 features like this more difficult, and ends up with Java syntax actually being the simpler one. Maybe with Java 11 (and additional type inference like `var`) it would be good to either remove the bulk of the preprocessor, or provide an alternative mode?
For comparison, PraxisLIVE uses Java basic syntax, but the same basic structural wrapping (import, class body, etc.) as Processing using preprocessing code from Janino that has most of the same benefits with less code, and handles Java language updates without problem.
---
### Author:  [@GoToLoop](https://discourse.processing.org/u/GoToLoop)
#### Post date: [April 23, 2019, 2:05pm UTC](https://discourse.processing.org/t/why-does-type-inference-not-work-in-the-processing-editor/10467/18 "2019-04-23T14:05:21Z")
> [@LoliProcessor](#):
>
> Using a packaged class without import gives error:
Oh, you’re right! Perhaps that was true in some very old PDE version. 🥴
Indeed, if we use `package` in a “.java” file, we’ve gotta use `import` for it. 🙄
Otherwise, if they don’t have `package`, we can straight use them! 🤩
---
### Author:  [@LoliProcessor](https://discourse.processing.org/u/LoliProcessor)
#### Post date: [May 1, 2019, 2:49pm UTC](https://discourse.processing.org/t/why-does-type-inference-not-work-in-the-processing-editor/10467/19 "2019-05-01T14:49:01Z")
I am really not trying to pick on Processing here. In fact, I think Processing is pretty cool.
But is it possible that wildcard extensions don’t work in the Processing editor either?
Wildcard Extension:
ParameterizableClass\ a;
TYPE objectOfTYPE = new TYPE();
a.parameterizedMethod(objectOfTYPE); // prePROCESSES to an error that the capture of a type doesn’t equal the type itself
---
### Author:  [@GoToLoop](https://discourse.processing.org/u/GoToLoop)
#### Post date: [May 1, 2019, 4:24pm UTC](https://discourse.processing.org/t/why-does-type-inference-not-work-in-the-processing-editor/10467/20 "2019-05-01T16:24:42Z")
Ru sure that’s valid Java syntax? I’ve made the attempt code below in order to check that out: ✍
```auto
import java.util.List;
import java.util.ArrayList;
public class Test {
public final List list = new ArrayList<>();
public final Double d = Math.random();
public Test() {
//list.add(d); // uncomment this for "capture" bug!
}
@Override public String toString() {
return "" + d;
}
@SafeVarargs public static final void main(final String... args) {
System.out.println(new Test());
}
}
```
Pasted that code at this Java online IDE site (javac 1.8.0\_201): 🗒
[https://www.CompileJava.net](https://www.CompileJava.net)
And here’s the error log if we uncomment `list.add(d);` inside Test’s constructor: ☠
```auto
/tmp/java_3Bq5e5/Test.java:9: error: no suitable method found for add(Double)
list.add(d); // uncomment this for bug!
^
method Collection.add(CAP#1) is not applicable
(argument mismatch; Double cannot be converted to CAP#1)
method List.add(CAP#1) is not applicable
(argument mismatch; Double cannot be converted to CAP#1)
where CAP#1 is a fresh type-variable:
```
[Next page](https://discourse.processing.org/t/why-does-type-inference-not-work-in-the-processing-editor/10467.md?page=2)