@Override public <R> Bag<R> map(Function<? super T, ? extends R> fn) { return fromStream(stream().map(fn)); }
/** * <pre> * {@code * PersistentBag<Integer> q = Reducers.toPersistentBag() .foldMap(Stream.of(1,2,3,4)); * * } * </pre> * @return Reducer for PBag */ public static <T> Reducer<PersistentBag<T>,T> toPersistentBag() { return Reducer.fromMonoid(Monoids.concatPersistentCollection(Bag.empty()), a -> Bag.of(a)); } /**
@Test public void toBagX() throws Exception { assertThat(Reducers.toPersistentBag().foldMap(Stream.of(1,2,3)),equalTo(Bag.of(1,2,3))); assertThat(Bag.empty().plus(10),equalTo(Bag.of(10))); assertThat(Bag.empty().plusAll(Arrays.asList(10)),equalTo(Bag.of(10))); assertThat(Bag.empty().plus(5).plusAll(Arrays.asList(10,20)),equalTo(Bag.of(5,10,20))); }
@Test public void minus(){ Bag<Integer> bag1 = Bag.of(1,2,3,4,10,1,1,2); assertThat(bag1.removeValue(1).instances(1),equalTo(2)); } @Test
@Override public <R> Bag<R> unitStream(Stream<R> stream) { return fromStream(stream); }
@Test public void testBag(){ Bag<Integer> bag1 = Bag.of(1,2,3,4,10,1,1,2); Bag<Integer> bag2 = Bag.fromStream(Stream.of(1,2,3,4,10,1,1,2)); assertThat(bag1,equalTo(bag2)); } @Test
@Override public Bag<T> plusAll(Iterable<? extends T> list) { Bag<T> res = this; for(T next : list){ res = res.plus(next); } return res; }
@Override public <T> ImmutableSet<T> of(T... values) { return Bag.of(values); }
@Override public <T> Bag<T> empty() { return Bag.empty(); }
public static <T> Bag<T> empty() { return new Bag<>(HashMap.empty(), 0); }
@Override public Bag<T> removeAll(Iterable<? extends T> list) { Bag<T> res = this; for(T next : list){ res = res.removeValue(next); } return res; }
@Override public Iterator<T> iterator() { return stream().iterator(); }
public Bag<T> bag(){ return Bag.fromIterable(iterable); } public <K,V> HashMap<K,V> hashMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends V> valueMapper){
@Override public boolean equals(Object o) { if (this == o) return true; if (o == null) return false; if(o instanceof ImmutableSet) { ImmutableSet bag = (ImmutableSet) o; return equalToIteration(bag); } if(o instanceof PersistentBag) { PersistentBag bag = (PersistentBag) o; return equalToIteration(bag); } return false; }
@Override protected <T> ImmutableSet<T> fromStream(Stream<T> s) { return Bag.fromStream(s); }
@Override public Bag<T> add(T value) { return plus(value); }
public static <T> Reducer<Bag<T>,T> toBag() { return Reducer.fromMonoid(Monoids.<T>bagConcat(),a->Bag.of(a)); } public static <T extends Comparable<? super T>> Reducer<TreeSet<T>,T> toTreeSet() {