/** An empty explanation. */ public static Violation absent() { return create(ConsPStack.empty()); } }
public static <E> PStack<E> stack() { return ConsPStack.empty(); }
public static <E> PStack<E> stack() { return ConsPStack.empty(); }
/** * @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 PSequence<Entry<K,V>> getEntries(final int hash) { PSequence<Entry<K,V>> entries = intMap.get(hash); if(entries==null) return ConsPStack.empty(); return entries; }
private PSequence<Entry<K,V>> getEntries(final int hash) { PSequence<Entry<K,V>> entries = intMap.get(hash); if(entries==null) return ConsPStack.empty(); return entries; }
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); }
static <E> PStack<E> reverse(final Collection<? extends E> list) { PStack<E> rev = ConsPStack.empty(); for(E e : list) rev = rev.plus(e); return rev; } }
@Override public ConsPStack<E> subList(final int start, final int end) { if(start<0 || end>size || start>end) throw new IndexOutOfBoundsException(); if(end==size) // want a substack return subList(start); // this is faster if(start==end) // want nothing return empty(); if(start==0) // want the current element return new ConsPStack<E>(first, rest.subList(0, end-1)); // otherwise, don't want the current element: return rest.subList(start-1, end-1); }
@Override public ConsPStack<E> subList(final int start, final int end) { if(start<0 || end>size || start>end) throw new IndexOutOfBoundsException(); if(end==size) // want a substack return subList(start); // this is faster if(start==end) // want nothing return empty(); if(start==0) // want the current element return new ConsPStack<E>(first, rest.subList(0, end-1)); // otherwise, don't want the current element: return rest.subList(start-1, end-1); }
public void testStackExceptions() { sequenceExceptions(ConsPStack.<Integer>empty()); }
/** 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)); }
PStack<Integer> pstack = ConsPStack.empty(); List<Integer> list = new LinkedList<Integer>(); Random r = new Random(); UtilityTest.assertEqualsAndHash(ConsPStack.empty(), pstack.minusAll(pstack)); UtilityTest.assertEqualsAndHash(pstack, ConsPStack.empty().plusAll(UtilityTest.reverse(pstack))); UtilityTest.assertEqualsAndHash(pstack, ConsPStack.singleton(10).plusAll(1,UtilityTest.reverse(pstack)).minus(0));
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); }
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)); }
public void testMap() { PMap<Object,String> m = HashTreePMap.<Object,String>empty(); assertEquals(m.size(),0); m = m.plus(1,"One"); assertEquals(m.get(1),"One"); // last three have same hashCode: Object[] keys = {1,2,0,3,ConsPStack.empty()}; String[] values = {"one","two","","three","emptyList"}; for(int i=0;i<keys.length;i++) { m = m.plus(keys[i],values[i]); m = m.minus(keys[i]); m = m.plus(keys[i],values[i]); assertEquals(m.size(),i+1); assertEquals(m.get(keys[i]),values[i]); } for(int i=keys.length-1;i>=0;i--) { m = m.minus(keys[i]); assertEquals(m.size(),i); } }