Remove unimplemented operators?

[JaredDavis22]

I would like to remove all unimplemented operators. They do nothing but slow down operator parsing. The slowdown is less now that the first digit is part of the operator parsing.

We could update the readme with the the last git link with the unimplemented operators then delete them, their tests and stub implementations.

Or

We could create an opNotReadyForUsageYet helper that creates the Operator but does not add it to the operatorList.

Or

?

Thoughts?

[JaredDavis22]

What are the pros/cons of the two methods shown to allow a '.' in variable names?

	@Test
	public void dotOperatorJoinsVariables() {
		// Create an evaluator whose dot operator implementation joins variables
		// into a longer-named variable.
		final Evaluator e = new DefaultTreeEvaluator() {
			@Override
			public Object dot(Object a, Object b) {
				if (a instanceof Variable && b instanceof Variable) {
					Variable va = (Variable) a;
					Variable vb = (Variable) b;
					return new Variable(va.getToken() + "." + vb.getToken());
				}
				return super.dot(a, b);
			}
		};

		// Evaluate an expression with dotted variable names.
		e.set(new Variable("shape.length"), 13);
		e.set(new Variable("shape.width"), 17);
		final Object result = e.evaluate("shape.length * shape.width");
		final int expected = 13 * 17;
		assertEquals(expected, result);
	}

vs

	@Test
	public void allowDotsInVariableNames() {
		// Create a parser that allows dot characters as part of identifiers.
		//
		// NB: In this example:
		// - The dot character is allowed WITHIN an identifier, but not STARTING it.
		// - Multiple dot characters in a row are allowed. To allow only single dot
		//   characters in a row, you would need to override the parseIdentifier
		//   method instead to be more intelligent. A regex might come in handy.
		final ExpressionParser parser = new ExpressionParser( //
			(p, expression) -> new ParseOperation(p, expression)
			{
				@Override
				protected boolean isIdentifierPart(char c) {
					return c == '.' || super.isIdentifierPart(c);
				}
			});

		final LinkedList<Object> queue = parser.parsePostfix(
			"shape.length * shape.width");

		// shape.length shape.width *
		assertNotNull(queue);
		assertEquals(3, queue.size());
		assertVariable("shape.length", queue.pop());
		assertVariable("shape.width", queue.pop());
		assertSame(Operators.MUL, queue.pop());
	}

nit: typo in java doc? Should "Determines whether the given character is allowed to start an identifier." be "Determines whether the given character is allowed within an identifier."

	/**
	 * Determines whether the given character is allowed to start an identifier.
	 * <p>
	 * The default implementation uses
	 * {@link Character#isUnicodeIdentifierPart(char)}.
	 * </p>
	 */
	protected boolean isIdentifierPart(char c) {
		return Character.isUnicodeIdentifierPart(c);
	}