/** Creates an explanation with one step. */ public static Violation of(String reason) { return create(ConsPStack.singleton(reason)); }
/** * Construct a PStack containing a single value * </pre> * {@code * List<String> single = PStacks.singleton("1"); * * //or * * PStack<String> single = PStacks.singleton("1"); * * } * </pre> * * @param value Single value for PVector * @return PVector with a single value */ public static <T> PStack<T> singleton(T value){ return ConsPStack.singleton(value); } /**
ConsPStack.empty().plusAll(UtilityTest.reverse(pstack))); UtilityTest.assertEqualsAndHash(pstack, ConsPStack.singleton(10).plusAll(1,UtilityTest.reverse(pstack)).minus(0));
/** Creates an explanation with one step. */ public static Violation of(String reason) { return create(ConsPStack.singleton(reason)); }
/** * Construct a PStack containing a single value * </pre> * {@code * List<String> single = PStacks.singleton("1"); * * //or * * PStack<String> single = PStacks.singleton("1"); * * } * </pre> * * @param value Single value for PVector * @return PVector with a single value */ public static <T> PStackX<T> singleton(T value){ return new PStackXImpl<>(ConsPStack.singleton(value),true); } /**
public static <T> Monoid<PStack<T>> toPStackReversed() { return Monoid.<PStack<T>>of(ConsPStack.empty(), (PStack<T> a) -> b -> a.plusAll(b), (T x) -> ConsPStack.singleton(x)); }
/** * Construct a PStack containing a singleUnsafe value * </pre> * {@code * List<String> singleUnsafe = PStacks.singleton("1"); * * //or * * PStack<String> singleUnsafe = PStacks.singleton("1"); * * } * </pre> * * @param value Active value for PVector * @return PVector with a singleUnsafe value */ public static <T> LinkedListX<T> singleton(final T value){ return new LazyLinkedListX<>( ConsPStack.singleton(value),null,Reducers.toPStack(),Evaluation.LAZY); }
public static <T> Monoid<PStack<T>> toPStack() { return Monoid.<PStack<T>>of(ConsPStack.empty(), (PStack<T> a) -> b -> a.plusAll(b), (T x) -> ConsPStack.singleton(x)); } public static <K,V> Monoid<PMap<K,V>> toPMap() {
public static <T> Monoid<PStack<T>> toPStack() { return Monoid.<PStack<T>>of(ConsPStack.empty(), (PStack<T> a) -> b -> a.plusAll(b), (T x) -> ConsPStack.singleton(x)); } public static <K,V> Monoid<PMap<K,V>> toPMap() {
/** * <pre> * {@code * PStack<Integer> q = Reducers.<Integer>toPStackReversed() .mapReduce(Stream.of(1,2,3,4)); * * } * </pre> * @return Reducer for PStack in reveresed order */ public static <T> Reducer<PStack<T>> toPStackReversed() { return Reducer.<PStack<T>> of(ConsPStack.empty(), (final PStack<T> a) -> b -> a.plusAll(b), (final T x) -> ConsPStack.singleton(x)); } /**
public static <T> Monoid<PStack<T>> toPStack() { return Monoid.<PStack<T>>of(ConsPStack.empty(), (PStack<T> a) -> b -> a.plusAll(a.size(),b), (T x) -> ConsPStack.singleton(x)); } public static <T> Monoid<PStack<T>> toPStackReversed() {
/** * <pre> * {@code * PStack<Integer> q = Reducers.<Integer>toPStack() .mapReduce(Stream.of(1,2,3,4)); * * } * </pre> * @return Reducer for PStack */ public static <T> Reducer<PStack<T>> toPStack() { return Reducer.<PStack<T>> of(ConsPStack.empty(), (final PStack<T> a) -> b -> a.plusAll(a.size(), b), (final T x) -> ConsPStack.singleton(x)); } /**
private Either<Set<ParseFailedException>, Term> wrapTermWithCast(Constant c, Sort declared) { Production cast; if (addCast) { cast = productions.apply(KLabel("#SemanticCastTo" + declared.toString())).head(); } else if (inferCasts && !hasCastAlready && productions.contains(KLabel("#SyntacticCast"))) { cast = stream(productions.apply(KLabel("#SyntacticCast"))).filter(p -> p.sort().equals(declared)).findAny().get(); } else { cast = null; } if (cast == null) { return Right.apply(c); } else { return Right.apply(TermCons.apply(ConsPStack.singleton(c), cast, c.location(), c.source())); } }
for(StateReturn stateReturn : s.ntCalls.computeIfAbsent(new NonTerminalCall.Key(nt, position), NonTerminalCall.Key::create).exitStateReturns) { if (stateReturn.key.stateEnd == s.input.length) { resultSet.add(KList.apply(ConsPStack.singleton(Ambiguity.apply(stateReturn.function.values))));
public ProductionReference addBrackets(ProductionReference inner, TermCons outer, ProductionReference leftCapture, ProductionReference rightCapture) { if (requiresBracketWithSimpleAlgorithm(outer, leftCapture, rightCapture, inner)) { int position = getPosition(inner, outer); Sort outerSort = ((NonTerminal)outer.production().items().apply(position)).sort(); Sort innerSort = inner.production().sort(); for (Tuple2<Sort, scala.collection.immutable.List<Production>> sort : iterable(m.bracketProductionsFor())) { boolean isCorrectOuterSort = m.subsorts().lessThanEq(sort._1(), outerSort); if (isCorrectOuterSort) { for (Production p : mutable(sort._2())) { boolean isCorrectInnerSort = stream(p.items()) .filter(i -> i instanceof NonTerminal) .map(i -> (NonTerminal) i) .map(NonTerminal::sort) .filter(s -> m.subsorts().lessThanEq(innerSort, s)) .findAny().isPresent(); if (isCorrectInnerSort) { return TermCons.apply(ConsPStack.singleton(inner), p); } } } } return TermCons.apply(ConsPStack.singleton(inner), Production(Sorts.KBott(), Seq(NonTerminal(Sorts.K())))); } return inner; }
@Test public void testKList() throws Exception { assertCleanup(Ambiguity.apply(KList.apply(ConsPStack.singleton(foo))), foo); }