The motif from runeflobakk

Fn<Object, Integer> Base.hashCode

Fn to get Object.hashCode()

Force evaluation of Elements<T>

For expensive map and/or filters, it may be convenient to force evaluation and still return Elements for further mapping/filtering/other operations. This is opposed to calling collect() and then wrap the returned List in another Iterate.on(..).

A Fn which feeds its argument into several Fns and joins the results into a String with an optional separator

Fn<String, Iterable<String>> to split a string using a delimiter

A Comparator API

It's already possible to create Comparators using a Fn<?, ? extends Comparable<?>>. It should return an interface (say EnhancedComparator<T> or similar) with methods to create modifications based on the original Comparator.

Suggestion:

interface EnhancedComparator<T> extends Comparator<T> {
   EnhancedComparator<T> descending();
   EnhancedComparator<T> nullsFirst(); //nullsafe comparator
   EnhancedComparator<T> nullsLast();  //nullsafe comparator
}

Strings.reversed

A Fn which takes a String and returns it with its characters in reversed order

Strings.repeat(int amount) and Strings.repeat(int amount, String separator)

Repeat a string a given amount, optionally with a separator String.

Check out markdown doclet

Try the markdown doclet mentioned in this blog http://blog.paralleluniverse.co/2014/05/01/modern-java/

<dependency>
    <groupId>ch.raffael.pegdown-doclet</groupId>
    <artifactId>pegdown-doclet</artifactId>
    <version>1.1.1</version>
</dependency>

Make Strings.substring behave like Commons Lang StringUtils.substring

Implement Strings.substring so that it avoids throwing exceptions. The behavior of Apache Commons Lang's StringUtils.substring is suitable.

Also add a substring that takes just the beginIndex and extends to the end of the string.

API similar to Optional, but for non-Optional values

Pushed to dev branch 6f2452f

Provide Locale to String Fns, and a way to resolve Locale implicitly

Every String function must accept Locale. In addition, provide a static function the developer can supply once to have Locales resolved implicitly. (Typically fetch it from a thread local Web session or something)

Rename Strings.between to Strings.inBetween

The name change should make it clearer that the operation will insert a string between two other strings, and not extract a substring.

Strings.bytes - Fn which wraps call to String.getBytes()

containedIn(Collection<? extends T>): Predicate<T>

Predicate which wraps Collection.contains(T)

Base.equalTo(Fn0)

equalTo-predicate which resolves its operand on each application. Typically used to check for equivalence on some independently continuously changing value, e.g. the system clock.

Remove redundant NullIfArgIsNull and DefaultIfArgIsNull

The abstract classes NullIfArgIsNull and DefaultIfArgIsNull are not needed anymore, and can be removed. Existing usage can be replaced with composition using Base.when(..) instead of the slightly awkward inheritance based approach with those classes.

Problematic typing in the Base.when(..) signature

<I, O> When<I, O> when(Predicate<? super I> condition, Fn<I, O> fn)

Not possible to use a more specific Predicate than the mapping Fn.

FnChain.then(Do<T>) to insert a side-effect into a Fn chain

Result type should be an Fn.

Type an FnChain<I, O> as Do<I>

Rename Maps.mapkey() and Maps.mapvalue() to Maps.key() and Maps.value()

Base.toIterable(..) should be moved to Iterate.toIterable(..)

This method seems more appropriate in the Iterate class, as it deals with iterables/arrays. It should be moved there.

YieldsJavaCollection.groupBy(Fn<T,K>)

Similar to #7 but the resulting map values are lists, and thus is usable for non-unique computed keys.

Make Motif Java 6 compatible

The original reason for Motif being compiled for Java 7 is the @SafeVarargs annotation introduced in Java 7. It has come to my attention that using the @SafeVarargs annotation, even when it is included in the binary with RetentionPolicy.RUNTIME, will not break when executed on a platform without the annotation (i.e. Java 6, and Java >= 5.0u6) as per the Java Language Spec

http://stackoverflow.com/questions/3567413/why-doesnt-a-missing-annotation-cause-a-classnotfoundexception-at-runtime

http://bugs.sun.com/view_bug.do?bug_id=6322301

Elements.filter stops at first null-element

Filtering elements containing nulls will stop at the first null.

Change Strings.bytes to Fn<String, Iterable<Byte>>

Makes it easier to work with. E.g. usable with Optional.each(..).

Strings.indexOf(..): Fn<String, Integer>

Map a string to the index of the first appearing character, much the same way as java.lang.String.indexOf.

Should probably return null instead of -1 for no matches, in order to correctly map an Optional to None.

May also include a variant to find the beginning index of a substring? Strings.indexOf(String)

Reflect.name does not work on Classes

class Class does not implement Member. Thus Reflect.name only works with methods and fields.

Not really a bug, but definitely a missing feature which was expected to be there.

Upcast operation on Elements

See if an upcast operation can be implemented on Elements. See #36

Strings.allBetween

Fn<String, Iterable<String>> which puts all substrings it can find between two given strings in an iterable.

Iterate.newInstance(Iterable) should not call iterator().hasNext()

For Iterables which consumes its contents, typically Iterable views of streams, this optimization may yields some surprises, as one element will be consumed during the check for emptiness.

E.g.

public final class ZipEntries implements Iterable<ZipEntry> {
    private final ZipInputStream zip;
    public ZipEntries(ZipInputStream zip) { this.zip = zip; }

    @Override public Iterator<ZipEntry> iterator() {
        return new SimpleIterator<ZipEntry>() {
            @Override protected Optional<? extends ZipEntry> nextIfAvailable() {
                try {
                             return optional(zip.getNextEntry());
                        } catch (IOException e) {
                           throw new RuntimeException(e.getMessage(), e);
                       }
                }};
    }
}

will skip over the first element if wrapped with Iterate.on(new ZipEntries(..))

IO.write(OutputStream)

Do<Byte> which wraps a call to OutputStream.write(int)

Make Motif Java 6 compatible

It has come to my attention that Motif may use the @SafeVarargs annotation and still be compatible with Java 6, as the Java Language Specification states that an annotation compiled into the binary (RetentionPolicy.{RUNTIME, CLASS}) does actually not need to be available at runtime.

So Motif can be developed on Java 7 and compiled for Java 6 as long no Java 7-specific API is used. However, using @SafeVarargs will not prevent the use of Motif on Java 6.

http://stackoverflow.com/questions/3567413/why-doesnt-a-missing-annotation-cause-a-classnotfoundexception-at-runtime

http://mojo.codehaus.org/animal-sniffer-maven-plugin/examples/generating-java-signatures.html

Possible to iterate entries of a Map

Create Iterate.on(Map) which returns Elements<Map.Entry>.
Also create Fn implementations to extract key and value from Map.Entry.

More effective handling of iterating Strings and arrays

Iterate.on(String) invokes toCharArray which effectively duplicates the characters of the given string. This is unnecessary.

Implement an abstract Iterator to better support iterating elements given a start and end index. Also provide implementation for iterating characters of a String, and most common arrays of primitives (byte, char, int).

Create a constant Predicate from boolean expression

Allow SimpleIterator.nextIfAvailable() to throw checked Exceptions.

Allow SimpleIterator.nextIfAvailable() to throw checked Exceptions. If implementation throws exception, SimpleIterator rethrows it wrapped in a RuntimeException if original exception is checked.

Reflect.name

A Fn to get the name of a java.lang.reflect.Member (class, method, field, etc)

Iterating after .map does two calls on the mapping Fn per element

Works as long as the mapping Fn is referentially transparent, but if it has side effects (e.g. printing to console or other IO) this will be performed twice.

Consider fasttrack-releasing fix for this as version 0.4.1.

Optional.None should implement equals() & hashCode()

In most circumstances, None is a true singleton, effectively enforced through standard Java visibility rules. Even so, using Optional with libraries/frameworks which relies on serialization (e.g. Hazelcast, Wicket, etc), will manage to deserialize to a new None-instance, and thus none.equals(anotherNone) will return false.

flatMap on Optional and Elements

Change name of abstract method in Do<V>

The method to override in Do<V> should be renamed to be able to have classes implementing both Fn<I,O> and Do<V>.

Make no.motif.f.base.Throw<I1, I2, O> implement Do<I1> when this is done.

Need a more generic term for Optional.split(..)

The method-name "split" on Optional<V> and A<V> is somewhat awkward since it hints about how a value is transformed into several values. The passed Fn should describe how it will be done, e.g. splittingOn(','). Using this as an exsample, possible names can be:

the("a,b,c").explode(splittingOn(','))
the("a,b,c").toElements(splittingOn(','))
the("a,b,c").dissect(splittingOn(','))

Fn<Collection<?>, Integer> Iterate.size

Fn to get size() of a Collection.

Fn<Class, String> Reflect.packageName

Fn to get the packagename of a class. May be combined as a Fn<Class, Package> and Fn<Package, String>.

YieldsJavaCollection.mapBy(Fn<T,K>)

New "bridge" back to Java collections which are able to on each element, compute a key for the element, and put the resulting key and element as key and value into a map, which is returned. The mapBy method must include documentation that the Fn should compute unique keys for each element, and what the behavior will be if that is not the case.

Add upcast operation to Optional

It is sometimes useful to upcast an Optional to a less specific type

Say if your method is declared to return an Optional<A>, and your method prepares a value v of type B extends A. The statement return optional(v) will not compile, since the type is inferred to be Optional<B>

Candidate method names:

.as(Class<N super V>): Optional<N>
.upcastTo(Class<N super V>): Optional<N>

Refinements in the Optional API

Shorten getOrElse() to orElse(), and add orNull() and or(Optional)

Strings.between, Strings.after, Strings.before

Substring operations:

extract string between two other strings
the string after the first occurence of a given string
the string before the first occurence of a given string.

This depends on #10 being done first.

Reflect.annotatedWith

Predicate to identify elements with a specified annotation.

runeflobakk / motif Goto Github PK

motif's Introduction

Motif

Branch status

motif's People

Contributors

Stargazers

Watchers

motif's Issues

Recommend Projects

Recommend Topics

Recommend Org