diff options
Diffstat (limited to 'BJC-Utils2/src/main/java/bjc/utils/funcdata')
5 files changed, 213 insertions, 0 deletions
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/IFunctionalList.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/IFunctionalList.java index 91b2ba3..5327dbe 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/funcdata/IFunctionalList.java +++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/IFunctionalList.java @@ -246,6 +246,16 @@ public interface IFunctionalList<ContainedType> { ContainedType randItem(Function<Integer, Integer> rnd); /** + * Select a random item from the list, using a default random number + * generator + * + * @return A random item from the list + */ + default ContainedType randItem() { + return randItem((num) -> (int) (Math.random() * num)); + } + + /** * Reduce this list to a single value, using a accumulative approach. * * @param <StateType> diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/PushdownMap.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/PushdownMap.java new file mode 100644 index 0000000..cc31923 --- /dev/null +++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/PushdownMap.java @@ -0,0 +1,91 @@ +package bjc.utils.funcdata; + +import java.util.function.BiConsumer; +import java.util.function.Consumer; +import java.util.function.Function; + +/** + * A map where + * + * @author ben + * + * @param <KeyType> + * @param <ValueType> + */ +public class PushdownMap<KeyType, ValueType> + implements IFunctionalMap<KeyType, ValueType> { + + @Override + public boolean containsKey(KeyType key) { + // TODO Auto-generated method stub + return false; + } + + @Override + public IFunctionalMap<KeyType, ValueType> extend() { + // TODO Auto-generated method stub + return null; + } + + @Override + public void forEach(BiConsumer<KeyType, ValueType> action) { + // TODO Auto-generated method stub + + } + + @Override + public void forEachKey(Consumer<KeyType> action) { + // TODO Auto-generated method stub + + } + + @Override + public void forEachValue(Consumer<ValueType> action) { + // TODO Auto-generated method stub + + } + + @Override + public ValueType get(KeyType key) { + // TODO Auto-generated method stub + return null; + } + + @Override + public int getSize() { + // TODO Auto-generated method stub + return 0; + } + + @Override + public IFunctionalList<KeyType> keyList() { + // TODO Auto-generated method stub + return null; + } + + @Override + public <V2> IFunctionalMap<KeyType, V2> mapValues( + Function<ValueType, V2> transformer) { + // TODO Auto-generated method stub + return null; + } + + @Override + public ValueType put(KeyType key, ValueType val) { + // TODO Auto-generated method stub + return null; + } + + @Override + public ValueType remove(KeyType key) { + // TODO Auto-generated method stub + return null; + } + + @Override + public IFunctionalList<ValueType> valueList() { + // TODO Auto-generated method stub + return null; + } + +} diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/theory/Bifunctor.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/theory/Bifunctor.java new file mode 100644 index 0000000..3bea135 --- /dev/null +++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/theory/Bifunctor.java @@ -0,0 +1,66 @@ +package bjc.utils.funcdata.theory; + +import java.util.function.Function; + +/** + * A functor over a pair of heterogenous types + * + * @author ben + * @param <LeftType> + * The type stored on the 'left' of the pair + * @param <RightType> + * The type stored on the 'right' of the pair + * + */ +public interface Bifunctor<LeftType, RightType> { + /** + * Lift a function to operate over the left part of this pair + * + * @param <OldLeft> + * The old left type of the pair + * @param <OldRight> + * The old right type of the pair + * @param <NewLeft> + * The new left type of the pair + * @param func + * The function to lift to work over the left side of the + * pair + * @return The function lifted to work over the left side of bifunctors + */ + public <OldLeft, OldRight, NewLeft> + Function<Bifunctor<OldLeft, OldRight>, Bifunctor<NewLeft, OldRight>> + fmapLeft(Function<OldLeft, NewLeft> func); + + /** + * Lift a function to operate over the right part of this pair + * + * @param <OldLeft> + * The old left type of the pair + * @param <OldRight> + * The old right type of the pair + * @param <NewRight> + * The new right type of the pair + * @param func + * The function to lift to work over the right side of the + * pair + * @return The function lifted to work over the right side of + * bifunctors + */ + public <OldLeft, OldRight, NewRight> + Function<Bifunctor<OldLeft, OldRight>, Bifunctor<OldLeft, NewRight>> + fmapRight(Function<OldRight, NewRight> func); + + /** + * Get the value contained on the left of this bifunctor + * + * @return The value on the left side of this bifunctor + */ + public LeftType getLeft(); + + /** + * Get the value contained on the right of this bifunctor + * + * @return The value on the right of this bifunctor + */ + public RightType getRight(); +} diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/theory/Functor.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/theory/Functor.java new file mode 100644 index 0000000..76f48e2 --- /dev/null +++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/theory/Functor.java @@ -0,0 +1,39 @@ +package bjc.utils.funcdata.theory; + +import java.util.function.Function; + +/** + * Represents a container or context some sort usually, but the precise + * definition is that it represents exactly what it is defined as + * + * @author ben + * @param <ContainedType> + * The value inside the functor + */ +public interface Functor<ContainedType> { + /** + * Converts a normal function to operate over values in a functor. + * + * N.B: Even though the type signature implies that you can apply the + * resulting function to any type of functor, it is only safe to call + * it on instances of the type of functor you called fmap on. + * + * @param <ArgType> + * The argument of the function + * @param <ReturnType> + * The return type of the function + * @param func + * The function to convert + * @return The passed in function converted to work over a particular + * type of functors + */ + public <ArgType, ReturnType> Function<Functor<ArgType>, Functor<ReturnType>> fmap( + Function<ArgType, ReturnType> func); + + /** + * Retrieve the thing inside this functor + * + * @return The thing inside this functor + */ + public ContainedType getValue(); +} diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/theory/package-info.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/theory/package-info.java new file mode 100644 index 0000000..33c80d6 --- /dev/null +++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/theory/package-info.java @@ -0,0 +1,7 @@ +/** + * Random functional type things that don't belong elsewhere + * + * @author ben + * + */ +package bjc.utils.funcdata.theory;
\ No newline at end of file |