/** Adds a step. */ public Violation plus(String edge) { return create(path().plus(edge)); }
public ConsPStack<E> plusAll(final Collection<? extends E> list) { ConsPStack<E> result = this; for(E e : list) result = result.plus(e); return result; }
public ConsPStack<E> plusAll(final Collection<? extends E> list) { ConsPStack<E> result = this; for(E e : list) result = result.plus(e); return result; }
/** * @param <E> * @param e * @return empty().plus(e) */ public static <E> ConsPStack<E> singleton(final E e) { return ConsPStack.<E>empty().plus(e); }
/** * @param <E> * @param e * @return empty().plus(e) */ public static <E> ConsPStack<E> singleton(final E e) { return ConsPStack.<E>empty().plus(e); }
private static <E> ConsPStack<E> from(final Iterator<? extends E> i) { if(!i.hasNext()) return empty(); E e = i.next(); return ConsPStack.<E>from(i).plus(e); }
private static <E> ConsPStack<E> from(final Iterator<? extends E> i) { if(!i.hasNext()) return empty(); E e = i.next(); return ConsPStack.<E>from(i).plus(e); }
/** Make sure the right element is removed */ public void testMinusInt() { // First, let's try a list with distinct elements PStack<String> pstack = ConsPStack.<String>empty().plus("C").plus("B").plus("A"); assertEquals(Arrays.asList("A", "B", "C"), pstack); assertEquals(Arrays.asList("B", "C"), pstack.minus(0)); assertEquals(Arrays.asList("A", "B"), pstack.minus(2)); //Now, let's try duplicates pstack = pstack.plus("B"); assertEquals(Arrays.asList("B", "A", "B", "C"), pstack); assertEquals(Arrays.asList("A", "B", "C"), pstack.minus(0)); assertEquals(Arrays.asList("B", "A", "C"), pstack.minus(2)); }
public ConsPStack<E> plusAll(final Collection<? extends E> list) { ConsPStack<E> result = this; for (E e : list) result = result.plus(e); return result; }
public ConsPStack<E> plusAll(final Collection<? extends E> list) { ConsPStack<E> result = this; for(E e : list) result = result.plus(e); return result; }
/** * @param <E> * @param e * @return empty().plus(e) */ public static <E> ConsPStack<E> singleton(final E e) { return ConsPStack.<E>empty().plus(e); }
/** * @param <E> * @param e * @return empty().plus(e) */ public static <E> ConsPStack<E> singleton(final E e) { return ConsPStack.<E>empty().plus(e); }
private static <E> ConsPStack<E> from(final Iterator<? extends E> i) { if(!i.hasNext()) return empty(); E e = i.next(); return ConsPStack.<E>from(i).plus(e); }
private static <E> ConsPStack<E> from(final Iterator<? extends E> i) { if (!i.hasNext()) return empty(); E e = i.next(); return from(i).plus(e); }
/** * Construct a Cases instance from a list of Pattern Matching Cases * Will execute sequentially when Match is called. * * @param cases Persistent Stack of cases to build Cases from * @return New Cases instance (sequential) */ public static <T,R,X extends Function<T,R>> Cases<T,R,X> ofList(List<Case<T,R,X>> cases){ return new Cases(cases.stream().map(ConsPStack::singleton) .reduce(ConsPStack.empty(),(acc,next)-> acc.plus(acc.size(),next.get(0))),true); }
/** * Construct a Cases instance from an array Pattern Matching Cases * Will execute sequentially when Match is called. * * @param cazes Array of cases to build Cases instance from * @return New Cases instance (sequential) */ public static <T,R,X extends Function<T,R>> Cases<T,R,X> of(Case<T,R,X>... cazes){ return ofPStack( Stream.of(cazes) .map(ConsPStack::singleton) .reduce(ConsPStack.empty(),(acc,next)-> acc.plus(acc.size(),next.get(0)))); } /**