From fefd6eb2917b9a0856c247353545cc13876b6eda Mon Sep 17 00:00:00 2001 From: Ben Culkin Date: Tue, 1 Dec 2020 20:19:34 -0500 Subject: An assortment of changes/new things --- .../java/bjc/utils/patterns/ComplexPattern.java | 90 ++++++++++++++++------ .../bjc/utils/patterns/MutablePatternMatcher.java | 13 ++-- base/src/main/java/bjc/utils/patterns/Pattern.java | 6 -- 3 files changed, 72 insertions(+), 37 deletions(-) (limited to 'base/src/main/java/bjc/utils/patterns') diff --git a/base/src/main/java/bjc/utils/patterns/ComplexPattern.java b/base/src/main/java/bjc/utils/patterns/ComplexPattern.java index 3926f2c..e9035df 100644 --- a/base/src/main/java/bjc/utils/patterns/ComplexPattern.java +++ b/base/src/main/java/bjc/utils/patterns/ComplexPattern.java @@ -35,6 +35,8 @@ public interface ComplexPattern { */ ReturnType apply(InputType input, PredType state); + /* Pattern producing functions */ + /** * Create a pattern composed from a predicate & a function. * @@ -49,7 +51,8 @@ public interface ComplexPattern { */ static ComplexPattern from( Function> matcher, - BiFunction accepter) { + BiFunction accepter) + { return new FunctionalPattern<>(matcher, accepter); } @@ -68,7 +71,8 @@ public interface ComplexPattern { @SuppressWarnings("unchecked") static ComplexPattern ofClass( Class clasz, - Function action) { + Function action) + { return from( (input) -> IPair.pair(clasz.isInstance(input), null), (input, ignored) -> action.apply((ClassType)input) @@ -89,11 +93,12 @@ public interface ComplexPattern { static ComplexPattern matchesObject( InpType obj, Function action - ) { + ) + { return from( - (input) -> IPair.pair(obj.equals(input), null), - (input, ignored) -> action.apply(input) - ); + (input) -> IPair.pair(obj.equals(input), null), + (input, ignored) -> action.apply(input) + ); } /** @@ -113,13 +118,16 @@ public interface ComplexPattern { static ComplexPattern equalsString( String pattern, BiFunction action - ) { + ) + { + Function> matcher = (input) -> { + String objString = input.toString(); + + return IPair.pair(pattern.equals(objString), objString); + }; + return from( - (input) -> { - String objString = input.toString(); - - return IPair.pair(pattern.equals(objString), objString); - }, + matcher, (input, objString) -> action.apply(input, objString) ); } @@ -140,21 +148,21 @@ public interface ComplexPattern { String regex, Predicate cond, BiFunction action - ) { + ) + { java.util.regex.Pattern regexPat = java.util.regex.Pattern.compile(regex); + Function> matcher = (input) -> { + String inpString = input.toString(); + + Matcher mat = regexPat.matcher(inpString); + + if (cond.test(mat)) return IPair.pair(true, mat); + else return IPair.pair(false, null); + }; + return from( - (input) -> { - String inpString = input.toString(); - - Matcher mat = regexPat.matcher(inpString); - - if (cond.test(mat)) { - return IPair.pair(true, mat); - } else { - return IPair.pair(false, null); - } - }, + matcher, (input, res) -> action.apply(input, res) ); } @@ -162,6 +170,7 @@ public interface ComplexPattern { // @TODO Nov 21, 2020 Ben Culkin :MorePatterns // Try and write something to iterate over Iterator in a type-safe manner // Also, something for doing a sub-pattern match + /** * Create a pattern which will always execute. * @@ -174,10 +183,41 @@ public interface ComplexPattern { */ static ComplexPattern otherwise( Function action - ) { + ) + { return from( (input) -> IPair.pair(true, null), (input, ignored) -> action.apply(input) ); } + + /** + * Create a pattern which checks if the string form of a given object starts + * with a specific string. + * + * @param The type returned by the matcher. + * @param The type being matched against. + * + * @param pattern The string to check against. + * @param action The action to execute. + * + * @return A pattern which functions as described. + */ + static ComplexPattern startsWith( + String pattern, + Function action) + { + return from((input) -> { + String objString = input.toString(); + + if (objString.startsWith(pattern)) { + return IPair.pair( + true, + objString.substring( + pattern.length())); + } else { + return IPair.pair(false, null); + } + }, (ignored, input) -> action.apply(input)); + } } \ No newline at end of file diff --git a/base/src/main/java/bjc/utils/patterns/MutablePatternMatcher.java b/base/src/main/java/bjc/utils/patterns/MutablePatternMatcher.java index 7900262..8e040fe 100644 --- a/base/src/main/java/bjc/utils/patterns/MutablePatternMatcher.java +++ b/base/src/main/java/bjc/utils/patterns/MutablePatternMatcher.java @@ -13,9 +13,10 @@ import bjc.data.*; * @author Ben Culkin * * @param The type returned by the pattern matcher. + * @param The type of the input to match against. */ public class MutablePatternMatcher - implements IPatternMatcher{ + implements IPatternMatcher { private final List> patterns; /** @@ -45,15 +46,15 @@ public class MutablePatternMatcher @Override public ReturnType matchFor(InputType input) throws NonExhaustiveMatch { Iterator> iterator; - for (iterator = new NonCMEIterator<>(patterns); - iterator.hasNext();) { + iterator = new NonCMEIterator<>(patterns); + while(iterator.hasNext()) { ComplexPattern pattern = iterator.next(); IPair matches = pattern.matches(input); - if (matches.getLeft()) { - pattern.apply(input, matches.getRight()); - } + matches.doWith((bool, obj) -> { + if (bool) pattern.apply(input, obj); + }); } throw new NonExhaustiveMatch("Non-exhaustive match against " + input); diff --git a/base/src/main/java/bjc/utils/patterns/Pattern.java b/base/src/main/java/bjc/utils/patterns/Pattern.java index e03623e..c9902e8 100644 --- a/base/src/main/java/bjc/utils/patterns/Pattern.java +++ b/base/src/main/java/bjc/utils/patterns/Pattern.java @@ -1,11 +1,5 @@ package bjc.utils.patterns; -import java.util.*; -import java.util.function.*; -import java.util.regex.*; - -import bjc.data.*; - /** * A simpler version of ComplexPattern, which always applies against Object * -- cgit v1.2.3 From a2c7425458f645802a352abc4783e0afc73dba13 Mon Sep 17 00:00:00 2001 From: Ben Culkin Date: Thu, 3 Dec 2020 19:22:35 -0500 Subject: Adapt to esodata changes --- .../java/bjc/utils/patterns/ComplexPattern.java | 24 +++++++++++----------- .../java/bjc/utils/patterns/FunctionalPattern.java | 6 +++--- .../bjc/utils/patterns/MutablePatternMatcher.java | 2 +- .../java/bjc/utils/patterns/PatternMatcher.java | 2 +- .../java/bjc/utils/patterns/SimplePatttern.java | 4 ++-- 5 files changed, 19 insertions(+), 19 deletions(-) (limited to 'base/src/main/java/bjc/utils/patterns') diff --git a/base/src/main/java/bjc/utils/patterns/ComplexPattern.java b/base/src/main/java/bjc/utils/patterns/ComplexPattern.java index e9035df..c6d72ec 100644 --- a/base/src/main/java/bjc/utils/patterns/ComplexPattern.java +++ b/base/src/main/java/bjc/utils/patterns/ComplexPattern.java @@ -23,7 +23,7 @@ public interface ComplexPattern { * @return Whether or not this pattern is matched, as well as a state value * that will get passed to the pattern if it did match. */ - IPair matches(InputType input); + Pair matches(InputType input); /** * Apply this pattern, once it has matched. @@ -50,7 +50,7 @@ public interface ComplexPattern { * @return A pattern composed from the passed in functions. */ static ComplexPattern from( - Function> matcher, + Function> matcher, BiFunction accepter) { return new FunctionalPattern<>(matcher, accepter); @@ -74,7 +74,7 @@ public interface ComplexPattern { Function action) { return from( - (input) -> IPair.pair(clasz.isInstance(input), null), + (input) -> Pair.pair(clasz.isInstance(input), null), (input, ignored) -> action.apply((ClassType)input) ); } @@ -96,7 +96,7 @@ public interface ComplexPattern { ) { return from( - (input) -> IPair.pair(obj.equals(input), null), + (input) -> Pair.pair(obj.equals(input), null), (input, ignored) -> action.apply(input) ); } @@ -120,10 +120,10 @@ public interface ComplexPattern { BiFunction action ) { - Function> matcher = (input) -> { + Function> matcher = (input) -> { String objString = input.toString(); - return IPair.pair(pattern.equals(objString), objString); + return Pair.pair(pattern.equals(objString), objString); }; return from( @@ -152,13 +152,13 @@ public interface ComplexPattern { { java.util.regex.Pattern regexPat = java.util.regex.Pattern.compile(regex); - Function> matcher = (input) -> { + Function> matcher = (input) -> { String inpString = input.toString(); Matcher mat = regexPat.matcher(inpString); - if (cond.test(mat)) return IPair.pair(true, mat); - else return IPair.pair(false, null); + if (cond.test(mat)) return Pair.pair(true, mat); + else return Pair.pair(false, null); }; return from( @@ -186,7 +186,7 @@ public interface ComplexPattern { ) { return from( - (input) -> IPair.pair(true, null), + (input) -> Pair.pair(true, null), (input, ignored) -> action.apply(input) ); } @@ -211,12 +211,12 @@ public interface ComplexPattern { String objString = input.toString(); if (objString.startsWith(pattern)) { - return IPair.pair( + return Pair.pair( true, objString.substring( pattern.length())); } else { - return IPair.pair(false, null); + return Pair.pair(false, null); } }, (ignored, input) -> action.apply(input)); } diff --git a/base/src/main/java/bjc/utils/patterns/FunctionalPattern.java b/base/src/main/java/bjc/utils/patterns/FunctionalPattern.java index e4b4a3d..1e9dbab 100644 --- a/base/src/main/java/bjc/utils/patterns/FunctionalPattern.java +++ b/base/src/main/java/bjc/utils/patterns/FunctionalPattern.java @@ -7,11 +7,11 @@ import bjc.data.*; class FunctionalPattern implements ComplexPattern { - private final Function> matcher; + private final Function> matcher; private final BiFunction accepter; FunctionalPattern( - Function> matcher, + Function> matcher, BiFunction accepter) { super(); this.matcher = matcher; @@ -19,7 +19,7 @@ class FunctionalPattern } @Override - public IPair matches(InputType input) { + public Pair matches(InputType input) { return matcher.apply(input); } diff --git a/base/src/main/java/bjc/utils/patterns/MutablePatternMatcher.java b/base/src/main/java/bjc/utils/patterns/MutablePatternMatcher.java index 8e040fe..17de37a 100644 --- a/base/src/main/java/bjc/utils/patterns/MutablePatternMatcher.java +++ b/base/src/main/java/bjc/utils/patterns/MutablePatternMatcher.java @@ -50,7 +50,7 @@ public class MutablePatternMatcher while(iterator.hasNext()) { ComplexPattern pattern = iterator.next(); - IPair matches = pattern.matches(input); + Pair matches = pattern.matches(input); matches.doWith((bool, obj) -> { if (bool) pattern.apply(input, obj); diff --git a/base/src/main/java/bjc/utils/patterns/PatternMatcher.java b/base/src/main/java/bjc/utils/patterns/PatternMatcher.java index e2ae9f6..f144d36 100644 --- a/base/src/main/java/bjc/utils/patterns/PatternMatcher.java +++ b/base/src/main/java/bjc/utils/patterns/PatternMatcher.java @@ -30,7 +30,7 @@ public class PatternMatcher @Override public ReturnType matchFor(InputType input) throws NonExhaustiveMatch { for (ComplexPattern pattern : patterns) { - IPair matches = pattern.matches(input); + Pair matches = pattern.matches(input); if (matches.getLeft()) { pattern.apply(input, matches.getRight()); } diff --git a/base/src/main/java/bjc/utils/patterns/SimplePatttern.java b/base/src/main/java/bjc/utils/patterns/SimplePatttern.java index 1601894..db53287 100644 --- a/base/src/main/java/bjc/utils/patterns/SimplePatttern.java +++ b/base/src/main/java/bjc/utils/patterns/SimplePatttern.java @@ -34,7 +34,7 @@ public interface SimplePatttern extends Pattern { } @Override - default IPair matches(Object input) { - return new Pair<>(doesMatch(input), null); + default Pair matches(Object input) { + return new SimplePair<>(doesMatch(input), null); } } \ No newline at end of file -- cgit v1.2.3 From f3814a84f8471684cd483347db4fb7b107c2e635 Mon Sep 17 00:00:00 2001 From: Ben Culkin Date: Thu, 3 Dec 2020 19:28:15 -0500 Subject: Rename interfaces to match Java style Rename several interfaces that were in the style IWhatever, which Java doesn't use --- .../utils/patterns/FunctionalPatternMatcher.java | 2 +- .../java/bjc/utils/patterns/IPatternMatcher.java | 85 ------------------- .../bjc/utils/patterns/MutablePatternMatcher.java | 2 +- .../java/bjc/utils/patterns/PatternMatcher.java | 96 ++++++++++++++++------ .../bjc/utils/patterns/SimplePatternMatcher.java | 41 +++++++++ 5 files changed, 113 insertions(+), 113 deletions(-) delete mode 100644 base/src/main/java/bjc/utils/patterns/IPatternMatcher.java create mode 100644 base/src/main/java/bjc/utils/patterns/SimplePatternMatcher.java (limited to 'base/src/main/java/bjc/utils/patterns') diff --git a/base/src/main/java/bjc/utils/patterns/FunctionalPatternMatcher.java b/base/src/main/java/bjc/utils/patterns/FunctionalPatternMatcher.java index 5a214d3..e370fa0 100644 --- a/base/src/main/java/bjc/utils/patterns/FunctionalPatternMatcher.java +++ b/base/src/main/java/bjc/utils/patterns/FunctionalPatternMatcher.java @@ -11,7 +11,7 @@ import bjc.functypes.*; * @param The type to match against. */ public class FunctionalPatternMatcher - implements IPatternMatcher { + implements PatternMatcher { private final ThrowFunction matcher; diff --git a/base/src/main/java/bjc/utils/patterns/IPatternMatcher.java b/base/src/main/java/bjc/utils/patterns/IPatternMatcher.java deleted file mode 100644 index b688a47..0000000 --- a/base/src/main/java/bjc/utils/patterns/IPatternMatcher.java +++ /dev/null @@ -1,85 +0,0 @@ -package bjc.utils.patterns; - -import java.util.function.*; - -import bjc.functypes.*; - -/** - * Represents a pattern matcher against a series of patterns. - * - * @author Ben Culkin - * - * @param The type returned from matching the patterns. - * @param The type to match against. - */ -@FunctionalInterface -public interface IPatternMatcher { - /** - * Match an input object against a set of patterns. - * - * @param input The object to match against. - * - * @return The result of matching against the object. - * - * @throws NonExhaustiveMatch If none of the patterns in this set match - */ - ReturnType matchFor(InputType input) throws NonExhaustiveMatch; - - /** - * Create a pattern matcher against a static set of patterns. - * - * @param The type returned from matching the patterns. - * @param The type to match against. - * - * @param patterns The set of patterns to match on. - * - * @return A pattern matcher which matches on the given patterns. - */ - @SafeVarargs - static IPatternMatcher matchingOn( - ComplexPattern... patterns) { - return new PatternMatcher<>(patterns); - } - - /** - * Create a pattern matcher from a handler function. - * - * @param The type returned by the matcher. - * @param The type to match against. - * - * @param handler The handler function. - * - * @return A pattern matcher defined by the given handler. - */ - static IPatternMatcher from( - ThrowFunction handler) { - return new FunctionalPatternMatcher<>(handler); - } - - /** - * Create a pattern matcher which applies a transform to its input. - * - * @param The new input type to use. - * @param transformer The function to convert from the new input to the old input. - * - * @return A pattern matcher which takes values of the new type instead. - */ - default IPatternMatcher transformInput( - Function transformer) { - return from(inp -> matchFor(transformer.apply(inp))); - } - - /** - * Create a pattern matcher which applies a transform to its output. - * - * @param The new output type to use. - * - * @param transformer The function to convert from the new output to the old output. - * - * @return A pattern matcher which takes values of the new type instead. - */ - default IPatternMatcher transformOutput( - Function transformer) { - return from(inp -> transformer.apply(matchFor(inp))); - } -} \ No newline at end of file diff --git a/base/src/main/java/bjc/utils/patterns/MutablePatternMatcher.java b/base/src/main/java/bjc/utils/patterns/MutablePatternMatcher.java index 17de37a..28e9cd7 100644 --- a/base/src/main/java/bjc/utils/patterns/MutablePatternMatcher.java +++ b/base/src/main/java/bjc/utils/patterns/MutablePatternMatcher.java @@ -16,7 +16,7 @@ import bjc.data.*; * @param The type of the input to match against. */ public class MutablePatternMatcher - implements IPatternMatcher { + implements PatternMatcher { private final List> patterns; /** diff --git a/base/src/main/java/bjc/utils/patterns/PatternMatcher.java b/base/src/main/java/bjc/utils/patterns/PatternMatcher.java index f144d36..40bf42b 100644 --- a/base/src/main/java/bjc/utils/patterns/PatternMatcher.java +++ b/base/src/main/java/bjc/utils/patterns/PatternMatcher.java @@ -1,41 +1,85 @@ package bjc.utils.patterns; -import bjc.data.*; +import java.util.function.*; + +import bjc.functypes.*; /** - * Implements pattern-matching (of a sort) against a collection of patterns. + * Represents a pattern matcher against a series of patterns. * * @author Ben Culkin - * - * @param The type returned by the pattern. + * + * @param The type returned from matching the patterns. + * @param The type to match against. */ -public class PatternMatcher - implements IPatternMatcher { - private final ComplexPattern[] patterns; +@FunctionalInterface +public interface PatternMatcher { + /** + * Match an input object against a set of patterns. + * + * @param input The object to match against. + * + * @return The result of matching against the object. + * + * @throws NonExhaustiveMatch If none of the patterns in this set match + */ + ReturnType matchFor(InputType input) throws NonExhaustiveMatch; /** - * Create a new pattern matcher. + * Create a pattern matcher against a static set of patterns. * - * @param patterns The set of patterns to match against. + * @param The type returned from matching the patterns. + * @param The type to match against. + * + * @param patterns The set of patterns to match on. + * + * @return A pattern matcher which matches on the given patterns. */ - @SuppressWarnings("unchecked") @SafeVarargs - public PatternMatcher(ComplexPattern...patterns) { - // Note: this may seem a somewhat questionable cast, but because we never - // actually do anything with the value who has a type matching the second - // parameter, this should be safe - this.patterns = (ComplexPattern[]) patterns; + static PatternMatcher matchingOn( + ComplexPattern... patterns) { + return new SimplePatternMatcher<>(patterns); + } + + /** + * Create a pattern matcher from a handler function. + * + * @param The type returned by the matcher. + * @param The type to match against. + * + * @param handler The handler function. + * + * @return A pattern matcher defined by the given handler. + */ + static PatternMatcher from( + ThrowFunction handler) { + return new FunctionalPatternMatcher<>(handler); + } + + /** + * Create a pattern matcher which applies a transform to its input. + * + * @param The new input type to use. + * @param transformer The function to convert from the new input to the old input. + * + * @return A pattern matcher which takes values of the new type instead. + */ + default PatternMatcher transformInput( + Function transformer) { + return from(inp -> matchFor(transformer.apply(inp))); } - @Override - public ReturnType matchFor(InputType input) throws NonExhaustiveMatch { - for (ComplexPattern pattern : patterns) { - Pair matches = pattern.matches(input); - if (matches.getLeft()) { - pattern.apply(input, matches.getRight()); - } - } - - throw new NonExhaustiveMatch("Non-exhaustive match against " + input); + /** + * Create a pattern matcher which applies a transform to its output. + * + * @param The new output type to use. + * + * @param transformer The function to convert from the new output to the old output. + * + * @return A pattern matcher which takes values of the new type instead. + */ + default PatternMatcher transformOutput( + Function transformer) { + return from(inp -> transformer.apply(matchFor(inp))); } -} +} \ No newline at end of file diff --git a/base/src/main/java/bjc/utils/patterns/SimplePatternMatcher.java b/base/src/main/java/bjc/utils/patterns/SimplePatternMatcher.java new file mode 100644 index 0000000..fea947a --- /dev/null +++ b/base/src/main/java/bjc/utils/patterns/SimplePatternMatcher.java @@ -0,0 +1,41 @@ +package bjc.utils.patterns; + +import bjc.data.*; + +/** + * Implements pattern-matching (of a sort) against a collection of patterns. + * + * @author Ben Culkin + * + * @param The type returned by the pattern. + */ +public class SimplePatternMatcher + implements PatternMatcher { + private final ComplexPattern[] patterns; + + /** + * Create a new pattern matcher. + * + * @param patterns The set of patterns to match against. + */ + @SuppressWarnings("unchecked") + @SafeVarargs + public SimplePatternMatcher(ComplexPattern...patterns) { + // Note: this may seem a somewhat questionable cast, but because we never + // actually do anything with the value who has a type matching the second + // parameter, this should be safe + this.patterns = (ComplexPattern[]) patterns; + } + + @Override + public ReturnType matchFor(InputType input) throws NonExhaustiveMatch { + for (ComplexPattern pattern : patterns) { + Pair matches = pattern.matches(input); + if (matches.getLeft()) { + pattern.apply(input, matches.getRight()); + } + } + + throw new NonExhaustiveMatch("Non-exhaustive match against " + input); + } +} -- cgit v1.2.3