private Expression parseInlineList(final boolean aImmutable) throws ParsingException {
		final List<Expression> elements;
		final SyntaxToken expected = aImmutable ? SyntaxToken.C_BRACK : SyntaxToken.C_INDEX;

		if (advanceIfNext(expected)) {
			elements = Collections.emptyList();
		} else {
			final Expression first = parseAssignment();

			if (advanceIfNext(SyntaxToken.RANGE)) {
				return parseRangeList(first, aImmutable);
			}

			if (advanceIfNext(expected)) {
				elements = Collections.singletonList(first);
			} else {
				final int position = mTokenizer.getPostion();
				final Token separator = mTokenizer.next();

				if (is(separator, SyntaxToken.ARROW)) {
					if (advanceIfNext(expected)) {
						// set with a single element
						return new InlineSetExpression(Collections.singletonList(first), aImmutable);
					}

					if (advanceIfNext(SyntaxToken.COMMA)) {
						// parse set
						elements = parseInlineList0(first, aImmutable, true);
						return new InlineSetExpression(Util.immutableList(elements), aImmutable);
					}

					final Expression value = parseAssignment();
					final AssocEntry<Expression, Expression> firstEntry = new AssocEntry<Expression, Expression>(
						first,
						value);
					final List<AssocEntry<Expression, Expression>> entries = parseInlineMap(firstEntry, aImmutable);
					return new InlineMapExpression(entries, aImmutable);
				}

				mTokenizer.restorePosition(position);
				final List<Expression> temp;
				if (is(separator, SyntaxToken.COLON)) {
					return parseConsList(first);
				}

				temp = parseInlineList0(first, aImmutable, false);
				elements = Util.immutableList(temp);
			}
		}

		return new InlineListExpression(elements, aImmutable);
	}