Rename to Some

winterbe · winterbe · commit e2b0126f545e · 2015-03-14T12:36:29.000+01:00
diff --git a/src/com/winterbe/java8/Some.java b/src/com/winterbe/java8/Some.java
@@ -10,13 +10,13 @@
  * @see Optional2
  * @author Benjamin Winterberg
  */
-public class Take<T> {
+public class Some<T> {
 
-    private static final Take<?> EMPTY = new Take<>(null);
+    private static final Some<?> EMPTY = new Some<>(null);
 
     private T value;
 
-    private Take(T value) {
+    private Some(T value) {
         this.value = value;
     }
 
@@ -30,36 +30,32 @@ public static <T> Optional<T> of(Supplier<T> resolver) {
         }
     }
 
-    public static <T> Take<T> of(T something) {
-        return new Take<>(something);
+    public static <T> Some<T> of(T something) {
+        return new Some<>(something);
     }
 
-    public <S> Take<S> take(Function<? super T, S> resolver) {
-        if (!isPresent()) {
+    public <S> Some<S> get(Function<? super T, S> resolver) {
+        if (value == null) {
             return empty();
         }
         S result = resolver.apply(value);
-        return new Take<>(result);
+        return new Some<>(result);
     }
 
     public Optional<T> get() {
         return Optional.ofNullable(value);
     }
 
     public T orElse(T fallback) {
-        if (isPresent()) {
+        if (value != null) {
             return value;
         }
         return fallback;
     }
 
-    public boolean isPresent() {
-        return value != null;
-    }
-
     @SuppressWarnings("unchecked")
-    private static <T> Take<T> empty() {
-        return (Take<T>) EMPTY;
+    private static <T> Some<T> empty() {
+        return (Some<T>) EMPTY;
     }
 
 }
diff --git a/src/com/winterbe/java8/SomeTest.java b/src/com/winterbe/java8/SomeTest.java
@@ -5,7 +5,7 @@
 /**
  * @author Benjamin Winterberg
  */
-public class TakeTest {
+public class SomeTest {
 
     static class Outer {
         Nested nested = new Nested();
@@ -34,23 +34,25 @@ String getFoo() {
     public static void main(String[] args) {
         Outer something = new Outer();
 
-        Optional<String> optional = Take.of(something)
-                .take(Outer::getNested)
-                .take(Nested::getInner)
-                .take(Inner::getFoo)
+        Optional<String> optional = Some.of(something)
+                .get(Outer::getNested)
+                .get(Nested::getInner)
+                .get(Inner::getFoo)
                 .get();
 
         System.out.println(optional.isPresent());
 
         something.getNested().inner = null;
-        Optional<String> optional2 = Take.of(() ->
+
+        optional = Some.of(() ->
                 something.getNested().getInner().getFoo());
-        System.out.println(optional2.isPresent());
+
+        System.out.println(optional.isPresent());
 
 
         String x = null;
         String y = "boo";
-        String z = Take.of(x).orElse(y);
+        String z = Some.of(x).orElse(y);
 
         System.out.println(z);
 

Original file line number	Diff line number	Diff line change
`@@ -10,13 +10,13 @@`
`10`	`10`	`* @see Optional2`
`11`	`11`	`* @author Benjamin Winterberg`
`12`	`12`	`*/`
`13`		`-public class Take<T> {`
	`13`	`+public class Some<T> {`
`14`	`14`
`15`		`- private static final Take<?> EMPTY = new Take<>(null);`
	`15`	`+ private static final Some<?> EMPTY = new Some<>(null);`
`16`	`16`
`17`	`17`	`private T value;`
`18`	`18`
`19`		`- private Take(T value) {`
	`19`	`+ private Some(T value) {`
`20`	`20`	`this.value = value;`
`21`	`21`	`}`
`22`	`22`
`@@ -30,36 +30,32 @@ public static <T> Optional<T> of(Supplier<T> resolver) {`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`
`33`		`- public static <T> Take<T> of(T something) {`
`34`		`- return new Take<>(something);`
	`33`	`+ public static <T> Some<T> of(T something) {`
	`34`	`+ return new Some<>(something);`
`35`	`35`	`}`
`36`	`36`
`37`		`- public <S> Take<S> take(Function<? super T, S> resolver) {`
`38`		`- if (!isPresent()) {`
	`37`	`+ public <S> Some<S> get(Function<? super T, S> resolver) {`
	`38`	`+ if (value == null) {`
`39`	`39`	`return empty();`
`40`	`40`	`}`
`41`	`41`	`S result = resolver.apply(value);`
`42`		`- return new Take<>(result);`
	`42`	`+ return new Some<>(result);`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`public Optional<T> get() {`
`46`	`46`	`return Optional.ofNullable(value);`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`public T orElse(T fallback) {`
`50`		`- if (isPresent()) {`
	`50`	`+ if (value != null) {`
`51`	`51`	`return value;`
`52`	`52`	`}`
`53`	`53`	`return fallback;`
`54`	`54`	`}`
`55`	`55`
`56`		`- public boolean isPresent() {`
`57`		`- return value != null;`
`58`		`- }`
`59`		`-`
`60`	`56`	`@SuppressWarnings("unchecked")`
`61`		`- private static <T> Take<T> empty() {`
`62`		`- return (Take<T>) EMPTY;`
	`57`	`+ private static <T> Some<T> empty() {`
	`58`	`+ return (Some<T>) EMPTY;`
`63`	`59`	`}`
`64`	`60`
`65`	`61`	`}`