Java Without If
ashtonkemerling.com
ashtonkemerling.com
That they also allow mapping, filtering, etc, isn't about 'removing ifs' or 'hiding ifs' so much as they are about writing more readable code, imho.
Optional<Foo> myValue = gateway.callThatApi(...)
return myValue.filter(Utils::isNotTooShabby)
.map(this::mapToCoolerType)
.map(getDecorator())
.orElseThrow(new TotallyBlewItException())
Debugging is annoying, yes, but I think there's hope that a good pattern for it will be figured out by the community.
ListCondi<ObjType> myValue = gateway.callThatApi(...)
foreach(tmp as Condi in myVlue)
{
if (tmp.worked) { foo(tmp.Generic);}
else {bar(tmp.Generic);}
}
In the case you're presenting, one might consider:
Stream<Foo> myVals = gateway.callThatApi(...)
return myVals.forEach(val -> getFooOrBar(val).apply(val))
Streams also let you add filters to the "list" of values, reduce them to a single value with a reducer, or use a nice set of "collectors" that reduce to Java generic collection types. (Collectors.groupBy is so handy).
Streams are also lazy, which I think is more good than bad.
The thing I tell everyone to do right now, today, is to open their Java code and search for "return null", then replace it with "return Optional.empty()". It'll break your code in lots of places, but things will be better when you fix all those things. Often you'll find lots of places that didn't handle the null possiblity at all!
The way I see it it's like this:
Optional<Integer> num = getSomeRiskyNumber();
if (!num.isPresent())
return ... code to bubble up a blank optional
Integer num = getSomeRiskyNumber();
if (num == null)
... throw exception or return null
You get `if (value == null)` for free. Throwing exceptions is very heavy and I'd place Optional<> above that but there isn't any way to signify the error that you acctually got. You'd need to make an Optional<Maybe<T>> where Maybe<T> supports error/exceptions. Maybe Maybe<T> holds data and you can extend it with BadMaybe<T> who extends exception or something so you can put that in instead of your value to signal your exception.
I don't see the benifit. Maybe I'm just crazy but `if (v == null)` has all the features Optional has for less of an overhead and less cognitive load. (If you're afraid of NPEs then just document all the return states of your methods and use @nullable to show when you need to check. IIRC IntellJ catches that kind of mistake).
You're right about code that branches based on `isPresent()` is semantically the same as null checks - and if you only did that and didn't use any functional paradigm like mapping on the types, you don't really get any real benefit!
getSomeRiskyNumber map {
case Some(i) => Map("risk" -> i)
case None => Map("error" -> "Error retrieving number.")
} map { response =>
Json.toJson(response)
}
Also, currently, Java doesn't have a match {} expression that works with Some() and None. I belive that would completely change my opinion and the name of the game.
Option(JavaClassFactory.staticMethodThatCanReturnNull()).map(i => i + 1).getOrElse(0)
Try(OldJavaClass.methodThatThrowsExceptions()).toOption.map(i => i + 1).getOrElse(0)
With an exception you can still generate a json response, but also handle errors in the way you like.
If something is wrong, throw an exception. If it's the kind of error that must be handled, throw a checked exception. If there's no value to return, return Optional.empty.
The code receiving that Optional<Foo> is now free to do what the author is suggesting: map, filter, all without worrying if the value is actually there or not. The code is cleaner, easier to read, etc.
But no one should ever have to check for null anymore.
Java's Optional is a bad idea implemented badly made even more bad by bad usage.
Option(null).map(str => str + "!").foreach(str => println(str)) is a noop.
"...an object which implements the expected interface, but whose method body is empty. "
That is sometimes just not an option performance wise yet.
"If it's the kind of error that must be handled, throw a checked exception. If there's no value to return, return Optional.empty."
Again, why is Optional.empty() better then null? What makes it better? What do you get from throwing an exception? What is the benifit. You can't just say "my way is better" when we have years and years of Java development flying contrary to your statement. What has changed that makes null a non-viable practice?
"The code receiving that Optional<Foo> is now free to do what the author is suggesting: map, filter, all without worrying if the value is actually there or not. The code is cleaner, easier to read, etc."
The code being cleaner is a subjective, or at least extremely difficult to prove, statment. For instance
List<Integer> nums = getNumbers();
if (nums == null) {
S.o.p("Failed to load numbers");
return;
}
for (Integer i : nums)
System.out.println(i);
Optional<List<Integers>> nums = getNumbers();
if (!nums.isPresent()) {
S.o.p("Failed to load numbers");
return;
}
nums.forEach(S.o::p);
for (int i : nums)
if (i < 10)
S.o.p(i);
nums.filter((n) -> n < 10).forEach(S.o::p);
pa(i i nums < 10)
In my opinion. Just compressing your logic doesn't make it more readable. I think some verbosity is needed to preserve simplicity.
"But no one should ever have to check for null anymore. "
I mean that just doesn't make sense. If you're suggesting that there are some times the state of a program should never contain a null value is just ridiculous. Some things are correctly modled by null and some things are also too performance dependant to not use null.
I think some things benifit from using Optional<> but the case doesn't exist to completely remove null. Even just by the creation of a new container object wrapping your already expensive return object there exists a case for null to exist.
Just saying "Don't do it it's bad" is not proof. Saying "the code is cleaner, easier to read, etc" is not proof or even an example of a design that is simpler to pickup and get going with. You'd have to write some code with the Java/OOP paradigms and write a version (that is feature complete) with the FP paradigms and see which is easier to understand for a new programmer. I'd be hard pressed to belive that the FP implementation would be simpler. Maybe to you and me but no to someone without the domain specific knowladge required to understand what's going on. Even when I use map, zip, and list comprehensions in my python code it scares off some of my coworkers.
Look, what you're trying to do is simple.
getNumbers.fold(println("Failed to load numbers"))(nums => nums.foreach(println))
getNumbers match {
case Some(nums) => nums.foreach(println)
case None => println("Failed to load numbers")
}
The second option, as I have stated many times in this thread, is far preferable to null. Java does not support it but when it does I will like it.
"* No null check, no loops, just very simple easy-to-read bulletproof code. This code cannot generate a NPE at all, ever.*"
The NPE isn't the illness, it's the symptom. It's the symptom of a far larger problem in your program: unhandled or otherwise unexpected state. That's why I like the match example. It forces you to expect all of the states of your program. The first example does neither. It hides flow and operation in a single (ever-expanding) line. Far from ideal in any case in my book.
As soon as Match is supported in Java I'll change my opinion. Until then I'm stuck. You get nothing better from the Java version in terms of readability.
In Scala, the debate between using fold on an Option or using map and getOrElse is almost as old as the language. The method signature for this is:
def fold[B](ifEmpty: => B)(f: (A) => B): B
def map[B](f: (A) => B): B
def getOrElse[B](f: => B): BYou make the Understanding This Codebase 101 curriculum some percent longer without making your programmers any better.
If it's terseness, I don't really think one symbol is any verbosity benefit over two. Same order of magnitude, same cost. It's a rounding error in brevity. People way overvalue terseness.
And the cost of people missing chances to learn getOrElse has got to be massive.
It looks like syntactic sugar here, but it's really not. It's just a function that is more commonly used on collections with more than one item.
[0] also reduce, inject, aggregate, and other synonyms, because naming is hard
It's actually trivial, and has been used in all kinds of languages, and scaled just fine, since the 60s.
Because with Optional the type tells the caller that it might not return a value. With null, you have no idea if you need to check for null or not.
Being able to chain maps, filters, etc. is convenient as well, but I'd argue that's just a side benefit.
Oh, one other thing Optional can do that null can't: nest. For example, if you call get() on a Map, and it returns null, you can't tell if the key wasn't in the map, or if it's value was null. If get() returned an Optional, then for a Map<String,Optional<String>>, get() would return Optional<Optional<String>>.
public List<Integer> add2(File file) {
List<Integers> nums = file.getNumbers();
if(nums != null) {
List<Integer> resultList = List<>();
for ( i : nums) {
resultList.append(i + 2);
}
return resultList;
} else {
return null;
}
}
public Optional<List<Integer>> add2(File file) {
Optional<List<Integers>> numsOpt = file.getNumbers();
return numsOpt.map((nums) =>
nums.map((i) => i + 2);
);
}
public List<Integer> add2(File file) {
List<Integer> resultList = new ArrayList<>();
for (int i : ListUtils.emptyIfNull(file.getNumbers())) {
resultList.append(i + 2);
}
return resultList;
}It's amazing how far people will go to defend a bad practice, than even its inventor called a 'billion dollar mistake'.
That's a case that comes up a lot! DB read failed vs DB read 0 items for example.
public List<Integer> add2(File file) {
List<Integers> nums = file.getNumbers(); // Show where the data comes from
if(nums == null) { // Show the invariant provided for the rest of the code
return Collections.<Integer>emptyList(); // Show the default return value if there has been an error
}
List<Integer> resultList = List<>(); // Apply your logic
for ( i : nums) {
resultList.append(i + 2);
}
return resultList; // Return your list
}
public List<Integer> add2(File file) {
// Show data source
List<Integers> nums = file.getNumbers();
// Show case where data is supplimented
if(nums == null)
nums = Collections.<Integer>emptyList(); // Show supplimnetal
// Show transformation
List<Integer> resultList = List<>();
for ( i : nums) {
resultList.append(i + 2);
}
return resultList;
}
Simple example that proves my point: You can't call .length on null, but you can for every string. Therefore null isn't a string. So why in hell should you be able to write code that states (falsely) that null is a string? You can't say an int is a string.
Removing null from a language adds a tremendous amount of safety.
> That is sometimes just not an option performance wise yet.
Why? I haven't heard about performance issues of exceptions since 90-ties and C++ problems.
And if you consider that you can throw exceptions instead of error codes (which null is an example of) why would a list of numbers be ever null?
It should be an empty list, not null.
Generally you don't add Optionals to Collections/Iterables/Maps because they already have a notion of empty.
So your example becomes:
List<Integer> nums = getNumbers();
for (Integer i : nums)
System.out.println(i);
e.g. you know
public Optional<File> loadFile(String filename);
public Int sum(Int a, Int b);
Obviously, because nulls exist in java, this guarantee isn't provable on compilation the way it is in e.g. Scala, but if your entire team writes code this way, at least you can rely on that for internal libraries. Like generics, this is one of those ideas that's ok in java 1.X, but doesn't shine as much until a backwards incompatible java 2.X
Can't in Kotlin, though.
Which is why I like Kotlin's approach. Same guarantees, one letter instead of ten. If you're writing Java, though, I can see why Optional has some use.
Yes, you could argue that you will only use null for an actually empty result. But two things: 1) You won't keep to it because the compiler won't force you to do so, and 2) potential contributors will not comply. When using optionals/either/enums, compiler will not allow a wildcard result (such as null).
.empty is just more semantically specific, and if you read a method's API for the first time, semantics helps you grasp it a lot faster. That's the reason I'm using enums in Swift all over the place now. Compared to the nilling out of Objective-C, I can be way more confident that method results really are what they claim they are.
The code I've written using optionals instead is much shorter, much clearer in its intent, and generally has fewer bugs.
That's anecdotal experience, not proofs. All I can really recommend is that you try it with an open mind.
Let's take this back to map/filter on lists. Remember the bad old days when you didn't have map and filter on lists? If you had some code that iterated heavily and then you needed to add another step you often ended up refactoring a lot of manual for code that explicitly handled iteration logic. Now with streams you can just chain another call onto the same stream and as long as the types match up you're ready to go test it. Optional gives you the same thing, but instead of working with lists it handles values that might be missing.
Optional<Integer> num = getSomeRiskyNumber();
match num {
Some(x) => ... ;
None => return error or whatever;
}
1: does java even have this?
Optional<X> x = ...;
switch (status(x)) {
case SOME: return x.get() * 10;
case NONE: .... send error ...
}
With match, that cleans up a LOT of code and if the compiler can guarantee no speed or memory hits for doing this it becomes very valuable very quick.
It's one of the reasons I wanted to learn Rust.
Optional<Integer> num = getSomeRiskyNumber();
return num.map(x -> ...).orElseGet(return error or whatever);
May be nitpicking, but in your other example, you've allocated at least one object (Integer) to just return 1 value, which means that supertight performance is not important in getSomeReskyNumber
https://www.infoq.com/presentations/Null-References-The-Bill...
BufferedImage avatar = users.getUser(userName) .flatMap(User::getAvatarUri) .flatMap(ImgIO::read) .orElse(anonymousAvatar);
I made this up, but I hope you see the point. Optional is just a fancy null pointer if you don't use it in a functional way. :-)
You'd typically use a sequence of map, flatMap and orElse calls. For example, this is some controller code I'm currently shipping:
return Drawing.getForLocation(id)
.map(d -> ok(Json.toJson(d)))
.orElse(notFound("No drawing for location " + id));
Getting down to the meat of your argument, why is optional better than an if not null check or an exception?
I think anyone can see why it's better than throwing an exception. Optional makes it obvious to the caller that (a) there can be no response, and (b) what happens exactly when there's no response. With exceptions, either they're unchecked, in which case you don't know what exception to catch without peeking, and it's really easy to forget to add a try/catch handler at all; or it's checked, but even in that case the handling code is uglier than an equivalent optional construct.
The more interesting question is why it is better than deliberately returning null. Again, it's about signaling. A library author can signal to the caller that they should expect not to get a value sometimes. Yes, it's possible to return null from a method that returns an optional, and this will cause an NPE, but in that case the error is the library's, not the callers. In making API's, you want to encourage correct use, and optionals help do that.
Optionals in java suffer from the same problem as most API's in java do though. They're uglier than they need to be, and some common use patterns are awkward. For example, in my spark code in scala I'll use constructs like this one to convert a stream between types where the conversion might fail for some elements (and I don't care about the ones where it does):
val someIntermediate = someStream.flatMap(convertMaybe)
But in Java streams, you can't do that, and you end up with constructs like this:
someStream.map(convertMaybe).flatMap(o -> o.isPresent() ? Stream.of(o.get()) : Stream.empty())
someStream.map(convertMaybe).flatMap(Optional::stream)
Any way, I think optional has its uses in Java. It's definitely something that helps when building out robust API's. But where optionals would be most valuable, the combination with streams and futures, is where they're painful to work with. That's par for the course in Java though. Oracle's not actually all that good at designing API's. Usually the first attempt at something turns out so broken it has to be replaced wholesale later (like java.util.Date), or it's so ugly it feels bad to use it (CompletionStage? seriously?). But, to each their own, I'm sure my attempt at it would be even worse, and despite the warts I still like Java 8 overall.
Null ruins that. It's a known source of runtime exceptions, and it is not a compilation error to return null or forget the null-check. It is a compilation error to pretend that an Optional<T> is just a T. The Java compiler is not smart enough to prevent you from doing something silly like calling get() on Optional<T> without checking isPresent() first, but at least it gives you something.
Also Optional has some really nice creature comforts. It gives you the ability to map to compose an Optional<T> with functions that couldn't care less about the Optionality, and it lets you use flatMap to chain successive calls that might fail together, avoiding an arbitrary number of null checks (that you might forget!) in your code.
Frankly arguing against Optional<T> is like arguing against map on lists/streams and saying that for is good enough for you. You can do it, but I think you'd be nuts to work against yourself like that.
It also provides some nice combinator syntax for handling that null beyond .isPresent, but if you were to just get .isPresent it would be a win.
Documentation is optional (hah) and therefor shouldn't be relied on.
Optional as a return type means there's no need to check for documentation, there's no need for @Nullable, and you get some pretty syntax to boot.
If you want to return a status instead of nothing, you use an Either type (as mentioned in the post). In an Either, you populate left or right, but not both. You can let left be your status and right be your template type. You could codify this as StatusOr<T>.
In a StatusOr land, you return if there's an error; otherwise you continue the computation. This gives a few advantages, but one is that you control the flow of control. (This is also done decently with exceptions in Java, iirc)
However, all of these - maybes, either - they make your functions composable.
There's a good talk... Railroad oriented programming... that dives into this.
The real problem is branching - when reading code I have to think through two conditional cases.
In this particular example (where you have to validate a client request), I don't see a way out of branching. However I don't think this post has produced the ideal:
JsonParser.parse(request.getBody())
.flatMap(Validator::validate)
.map(ServiceObject::businessLogic)
.flatMap(JsonGenerator::generate)
.match(l -> HttpResponse.internalServerError(l.getMessage()),
r -> HttpResponse.ok(l));
In other words, I should be able to read this part of the data flow without thinking of branching:
(generate-json (business-logic req))
(if (valid? req)
(generate-json (business-logic req))
(generate-json (errors req)))
Why is this objectively better? Because we now have to think about branching wrt to the validation function ONLY. We've minimized where branching matters, and that's solving the core issue.
(doseq [n (range 1 101)]
(println
(match [(mod n 3) (mod n 5)]
[0 0] "FizzBuzz"
[0 _] "Fizz"
[_ 0] "Buzz"
:else n)))
The structure is almost identical. You even have an "else" clause!
I think most function programmers are actually very familiar with the patters found in Java. It's often one of the reasons they fell in love with more functional styles of programming.
module Raindrops (convert) where
import Control.Monad (liftM2)
import Data.Foldable(fold)
import Data.Maybe (fromMaybe)
convert = build rules
build = liftM2 fromMaybe show . fold
rules = uncurry rule <$> [(3, "Pling"), (5, "Plang"), (7, "Plong")]
where rule i s j = if j `mod` i == 0 then Just s else Nothing
I like this solution because it shows how powerful it is to abstract over these concepts but also that trying to be too clever quickly ends in impossible to follow complexities.
Three times you introduce possible failure, the original parse as well as each call to flatMap. It flattens each of these possible failures into one, though, so you don't have to think about it!
So if the programmer is sane and doesn't hide side effects in there you only have to think about branching at the pattern match - if any step failed do this, otherwise do this!
Is this a satire?
If a function could return either T or null, return Optional<T>, and then use Optional::flatMap to join them together.
Pretty straightforward.
Optional<String> x = Helper.functionOne()
.map((descriptiveName) => Helper.functionTwo(descriptiveName))
.flatMap((descriptiveName) => Helper.functionThree(descriptiveName));Clarity I think comes from breaking out branching into small parts. Coding just for one-liners leads to confusion in teams many times for non functional programmers. You might have programmers yak shaving just to cut down on "ifs" because they are harmful now? Same with null types. Some languages are built for it and others aren't.
The example is less lines of code, and functional clean code, but is it easier to expand, follow and use throughout your codebase? I guess that is up to the project/team, I feel like in many cases this outlook could be adding complexity where simplicity does just fine.
It's been a long time since I've written any Java, so I wonder, how is this better than Clojure?
But does that String contain @ character (checking for email)? Is this Date in the future or in the past (validating a credit card form)? Types say nothing about that. I'm not saying that types have zero utility, but in the vast majority of my use cases compile-time type checking doesn't go very far.
Perhaps I'm just stuck in my ways, but I like to be able to see in the code I'm looking at what attributes or actions are applicable to this thing. With Clojure I lose all of that. What is in this map? Well, I better print it out to know.
Clojure's dynamic typing, and any dynamic language to me, is only useful if you're never more that 2 stack frames away from your data's source. After that it's a lot of documentation to make sure you don't cock it up.
Oh, spec also serves as documentation!
Maybe you'll like more now. :)
Basically if you have only a few different shapes of data, Clojure is great. But the moment that you have lots of different data types that are similar but require different behavior, Clojure starts to struggle.
Let's make a trivial example. Imagine that there are 4 different ways to identify an object in your system that are recognized industry wide, you cannot eliminate or choose not to support them. These ways are by the keys :foo, :bar, :baz, and :quux. They are not interchangeable, each is unique, and each one requires a different combination of database or API access to use correctly.
In Java you would probably create an empty interface for ObjectIdentifier with tiny-type classes at Foo, Bar, Baz, and Quux. Methods that only need an identifier of any type could accept/return ObjectIdentifier, but at the integration point you could specialize on each type to hit the correct APIs/Database Tables/Etc.
In Clojure you've got if cases, multimethods, and protocols. Frankly we've had big issues with multimethods and protocols. Without enumerating every single issue we've had, they tend to increase the WTFs per day of the system, and they easily confuse both the programmer and their tooling.
So you end up with if cases, probably related to key/values in a map somewhere. But now you've got two really big problems:
1) Methods that just need an arbitrary identifier of some type end up having to pass the whole map, or use select-keys all over the place, requiring that you modify every point that touches this map when you need to add/remove an identifier.
2) You end up with an implicit ordering between these identifiers. What do you do when your map contains {:foo "foo identifier" :bar "bar identifier"}? In Java you'd have a Foo instance or a Bar instance, never both. But in Clojure you need to pick which one to use which implicitly ranks these choices, or throw an exception or similar. Now obviously if you're deserializing json you will need to make that choice in any language, but in a static one you make that choice exactly once and you're provided a measure of safety by the compiler. In Clojure those decision points leak all over your system.
Ultimately there are ways out of this issue in Clojure, and we've actually tried several. But frankly a lot of the solutions start to feel like a half-baked implementation of plain old Java interfaces and objects.
- Optional does not protect from NPE, null is still allowed
- It adds extra layer of complexity
- some libraries use it, some do not. it is not enforced
- extra typing, Java does not even have type inference and `val` declaration
- `if` expression in java does not return a value, no pattern matching... again far more typing
- no support for chained call on several nullable fields
I use Kotlin for couple of years. It has nullability baked into type system and enforced by the compiler. And it works with existing java libraries.
It feels like going back 15 years to Java 1.4, when I use Optional in Java8 or Scala.
The wording you used and the fact that your post was a completely off-topic opinion, just to attack the language you don't like. We're discussing various null-safety approaches here, not opinions about which language is better. That Kotlin can't treat optional types as any other monad (e.g. Either or Try monads) unlike Haskell, Scala and probably half a dozen other languages is a fact, not opinion. Also baking optional types into the syntax and the type system makes them language more complex and this is also a fact.
> 80% of scala projects fail to deliver [citation needed]
Which Map are you talking about? I don't see the method that returns nulls for missing values.
> Kotlin has only single way.
... with the nice side-effect of being unable to tell whether the key didn't exist or if it was null. That's the single worst approach one can take.
Most Java Collections does not allow null keys and null values.
Also, only a few of the newer concurrent Java collections disallow nulls. All the classes commonly used allow null, as well as the collection interfaces themself.
Java had the chance to address this with Optional, but they got the implementation of the null handling completely wrong. Now they are stuck with it, which caused an obscene amount of complexity in the new generics spec to work around it.
When you have "if" statements, you can press "next" repeatedly in Eclipse/IntelliJ/whatever and step through the code. When you use chained method calls you're constantly going into and out of function calls, and all the local variables become return values that you don't ever necessarily get to see in a stack frame, and sometimes you have to step through loads of boilerplate to see the next interesting line of code, even when you're doing something totally simple.
But if you're really worried, set a breakpoint in each lambda (trivial in IntelliJ) and use continue instead of step over.
Ok, I agree with you. Someone needs to patch Java and other IDEs to allow breakpoints on periods. Double clicking a dot to set a breakpoint sounds like awesome UX. Why hasn't this been done?
Breakpoints on periods and the ability to step through them. Honestly if I have to use more than one breakpoint to find a problem because stepping doesn't work, I'm unhappy.
- You can still use intermediate variables for readability
e.g. instead of
nums.filter((n) => n % 2 == 0).map((n) => n + 2).foreach((n) => print(n))
nums.filter((n) => n % 2 == 0)
.map((n) => n + 2)
.foreach((n) => print(n))
List<Integer> evens = nums.filter((n) => n % 2 == 0)
evens.map((n) => n + 2)
.foreach((n) => print(n))Basically I want to see a "skip to next chained method" button alongside "step" and "step into" and "step over". And maybe another that lets me step to the next iteration of a given chained method as well.
Java
IntPredicate even = i -> i % 2 == 0;
IntUnaryOperator add2 = i -> i + 2;
UnaryOperator<IntStream> process = s -> s.filter(even).map(add2);
for (int i in process.apply(numbers)) {
System.out.println(String.valueOf(i));
}
printProcessed = mapM_ print . process
where process = map (+2) . filter even x = something that might result in an exception
x = f(x)
http://gbacon.blogspot.sg/2009/07/programmable-semicolon-exp...
var x = foo();
var y = bar(x);
var z = baz(y);
var x = foo(); // returns an Either
var y = x.flatMap(bar);
var z = y.flatMap(baz);
I fail to see much difference between an Optional has/doesn't have a value and null. It's just paint and there is no insight into why there is no value. Something like an Expected type that has either a value or the Error/Exception is much more explicit and may let someone do something about it. At least then the user of the method can choose what an appropriate action is with knowledge. But optional and null are the same and give you no more information than a result or that there is no result.
This is because the standard library can forego memory allocation for temporary data structures implied in expressions throughout the stream statement. Also, the Java 8 VM can apply other aggressive optimizations to the lambda functions to inline them.
When you heavily use stream constructions, you're relying on the JVM to:
• Synthesise classes for the lambdas.
• Inline the map/filter/fold calls and then inline the lambdas too. The JVM doesn't make any guarantees about inlining and may unpredictably bail out. If inlining doesn't happen then profile pollution will kill off some of the other optimisations the JVM does.
• Escape analyse any temporary objects created like iterators and then scalar replace them.
• Try and do some loop fusion, but I'm not sure to what extent the JIT compilers can do that.
This is a long list of complex and often fragile optimisations. If any of them don't get applied then you end up with virtual method calls, objects being created, poor cache utilisation etc. Sure objects that die young are cheap but they aren't entirely free. It's still best to avoid them.
The reality is that writing traditional style code is going to be more efficient or at least more reliably efficient than functional style code for the forseeable future.
Note that the JVM has a much easier time of it when using Kotlin's support for lambdas and functional programming because the inlining is guaranteed to be done by the Kotlin compiler not the JVM, and that fixes a lot of issues with profile pollution and unpredictable performance drops.
https://bitbucket.org/iopq/fizzbuzz-in-rust/src/bf4968973d73...
https://github.com/zachcoyle/fizzbuzz-without-booleans/blob/...
But I like your solution better
Let's say you wanted to change the program to yield "Fizzbuzz" instead of "FizzBuzz" in the 15 case, but the rest being the same.
I would first build my string from "fizz" and "buzz" and then I'd have to do .map(capitalize) as the second to last step. If I wanted to have the correct case in the originating strings I could just run them into to_lowercase first before anything happens and capitalize correctly afterwards.
(Actually, the capitalize function itself is probably more complicated than this change)
Similarly, other changes are intuitively easy to stick into the correct place in the program once you know what this program does.
https://play.rust-lang.org/?gist=3fb51314d7df9249c9f774dde96...
So something like
fizzes, buzzes, empties = str_cycle('Fizz', 3), str_cycle('Buzz', 5), str_cycle('', 7)
I would have really liked to hear what the argument for switching to Java is - over staying on Clojure or switching to a language other than Java.
It sounds like a ternary operator to me.
a != null ? fn(a) : null
(a, fn) => a != null ? fn(a) : nullIf you want to chain calls, you could do that easily by passing "possibly null" returned values to methods with parameters that are marked @NotNull and handling null checks as exceptions down the line instead of inventing the optional type.
We should use exception all the time. We should adopt exceptional programming.
null is the type to return, just in case we haven't thrown an exception yet.
Everyone know the exception API, how to throw them, how to catch them, we have to use it all the time. It's great.
We definitely don't need a strong type system, we need an exceptional programming language, everything is an exception.
But, hey, if it helps make Java code cleaner and safer (and Optional and Either definitely help a lot with that), I'm all for it.
Who did it first can be interesting, but it's rarely much use.
java.util.Optional<int> opt = some_null_returning_function( );
Database theory tells us that having multiple null values is useful ("eh, I don't know" vs "your question has no meaning").
Seriously though, it would be great if they just added a "non null reference" type to the language. C++ has this, and it is useful (even though the compiler doesn't enforce the non-null bit).
The thing that always irked me about Optional<T> is that they are synonymous with bare Java references (which also can be null, at least according to the language spec / compiler). It is like a Java version of
#define THIS_PROGRAM_IS_WRITTEN_IN_C *
to my eyes.
To each their own.
Not sure how far it can go down the rabbit hole though. This is really where value types/regular types are really nice.
I think it would have been better for Java to allow the flatmap like stuff for any reference instead of creating an optional. But I am not a fan of either for when there is no value due to error conditions. There are optional values and there are errors that prevent the fulfillment of the contract. So either throw so something can be done or return a class that can either be an error or the value. But returning null does not allow the caller to act on it.
You are so right though about non-null references. I would go further and say nullable should not have been the default but an added keyword. That is the trait of a c++ reference I like. Just use it and don't check for null. With that Optional can have some differentiation and is meaningful for situations where an error hasn't occurred.
Very out of context, and very off topic, but this is a profoundly deep statement... its veracity is questionable and unknown.
More details: http://www.furidamu.org/blog/2017/01/28/error-handling-with-...
The potential for JSON parsing to fail is encoded in its
type, not in the potential for a variable to null, or
false, or for an exception to have been thrown. You’re
leaning on the compiler to tell you if you’ve handled the
failure cases properly, as the code won’t compile
otherwise. Now instead of testing for runtime exceptions
you only test to make sure that your business logic is
correct.
The OP does discuss checked expcetions a little bit:
Checked exceptions guarantee that someone will deal with
the issue, but they are extremely annoying, and might
result in disparate and different exception handlers all
over the place.
There are some actual problems with exceptions though:
1. It may be hard to tell from looking at the code which particular calls inside a function produce which particular kinds of exceptions.
2. This is particularly problematic with stateful code, as to ensure exception-save stateful transactions.
3. They tend to be more expensive for the exceptional codepath -- on the other hand, they are faster than Optional for the non-exceptional path!
In my experience points 2 and 3 are the most important. Since in Java many things may throw, one has two think about exception safety anyways most of the time. This is also a good argument maybe, to just avoid statefulnes instead.
Point 3 is very important. Maybe exceptions should be relegated to truly exceptional situations, and not be used as a replacement for an if. Optional<>/Either<> is excellent in this sitiation. Still in some languages do use exceptions for this and familiarity might be something to consider there (I'm thinking of idiomatic Python signals iteration end or key presence in maps, but Python also has very different performance characteristics as Java and does not have static types for the most part anyways...).
As much as I actually love FP, and I am also trying to bring more FP to other languages (C++), I don't believe in fighting the language for the sake of it. Having a nuanced conversation about the "why" and a the "when" is important. Specially when bringing these techniques to communities that are not used to them and, at the end of the day, already have methods that "Just Work TM". Otherwise, you end up having reactions like this: https://news.ycombinator.com/item?id=13505620
Over the past two decades I've internalized the value of writing code that's very easy to understand. Otherwise 6 months later I can't figure things out myself. This Java style reminds me very much of Scala which seemed like a decent language until I saw how people actually use it in practice. Noped right out of that in a hurry.
If this API is not understood then the code feels convoluted.
Therefore such projects have to contain a document that will explain the most common usage of the API to the newcomer. I think that this would remove most of the confusion.
Naturally it would be good if we had one most widely standardized API that most of the people are familiar with (like they are with if and for).
I can dream up APIs which will keep confusing you, no matter how long you use them (hello Android SDK!). Or which have difficult to memorize syntax (hello Bash!).
There are subtle variations in naming like Java's Map is Select in C# because Microsoft modeled its functional API on SQL, but you have the same differences for iteration and selection (the things you are referring to for and if).
For example you have 'for (int i = 0; i < n; i++)' in C, but you don't have the exact same way of doing it in Python, where you have to use a range: 'for num in range(0, n):' or you can write a 'while' loop in Java but not in Go where it's a 'for' with a single expression.
I would choose a functional version over a three level nested for loop monster any day.
I'm a fairly decent programmer and I never worked with map or flatmaps outside of examples.
I have however significantly simplified two significant code bases, made and maintained for years a webapp that users loved etc.
Very often I feel it is just people wanting to sell something and it wouldn't surprise me if many of the people who sell functional are the same who sold object oriented back in the day.
This article was actually a bit refreshing IMO.
That being said, I love map/filter/flatMap. Look at them as higher level loops.
For example: A while loop is very general, you can implement any kind of loop with it. This makes it harder to understand the meaning of the loop. Therefore, when you want to iterate a constant number of times, you'll likely use a for loop. It expresses your intent better. Map, filter, and flatMap are just extending this principle to more specialised use cases. The advantage for a reader is that the one word "map" already tells them a lot about what the loop body is good for.
Of course, if you're writing actual code, now -- what I'm saying doesn't help you much. But if you're looking at a new language, it might be important to remember: not "filter" is broken that way, it's just the implementation on the JVM.
An added bonus is that null elements are sorted and that you HAVE to separate data manipulation operations. You have to filter, map and apply sorting separately, not mix all three in a triple for loop with several branches.
It's often justified to do that. For instance, we model stuff as matrices or graphs to gain access to their mathematical properties or because we have specialized hardware for matrix operations.
The big debate right now is whether the mathematical properties of functional programming are useful enough to move further away from natural language for general purpose programming.
We probably think something like this:
Parse and validate the request
If that fails then
return 400, "invalid request: " + err
Run business logic to get a result
If that fails then
return 500, "logic failed: " + err
return 200, result as JSON
I think there is more going on here. For the sake of eliminating an if, you are lifting everything else into what is effectively a separate language with the original code embedded in that language. Overall, that doesn't look like a win to me.
After all, what is the actual domain logic? Is it flatMap().map().flatMap().map()? Or is it validate().businessLogic().generate() ?
That doesn't mean that what is going in isn't useful, but it seems to me we need to have a way to specify the lifting without writing it down everywhere, so that the actual code can be expressed at the base level again.
for(blah blah blah)
map(blah blah blah)
All programming techniques should be viewed as means to write code that's some combination of readable, reliable and performant, not as ends themselves.
I don't use partial application/currying that much, but more and more over time.
All in all I feel that doing these things have greatly improved my code and efficiency, and I'm kind of waiting for some downtime to get back into learning the more 'hardcore' functional languages.
It might be said that any such example would be too complex and drawn-out for an article like this, but if so, then to me that is like the drunk looking for his keys under the lamp-post: writing an article that claims a simple example shows a profound difference, when it does not, suggests that the Emperor's wardrobe is threadbare. The thing to do is to provide links to articles where this is worked out in sufficient depth, and I would like to see some of those links here.
* Mapping (producing a data structure of the same size/type)
* Filtering (producing a data structure of the same type buy smaller)
* Side effects
* Collecting (producing a different data structure)
If you're incredibly unlucky or foolish a for loop might be doing more than one operation at a time!
Assuming you're only using the return types, map, filter, and collect are very clear about having only one purpose.
If that's not telling you more I don't know what is.
A more useful question is how can map, used properly, make things better, and I stand by my claim that the simple examples of the sort given in this article, and articles like it, fail to make that case.
I have no such expectations of a loop until I've read and understood its body. I hardly have any expectations of a loop at all until I've understood the whole thing.
And that's how map, used properly makes things better. It communicates what kinds of things the reader should expect it to do and not do. It reduces the cognitive load of reading the program, as if, for example, you're scanning for where a certain side effect happens, you can skip the function called by 'map' on your first pass through. It shouldn't happen there; maybe it could, but it should be pretty far down the list of places to check.
Mea culpa: I have to admit that I have sometimes used side-effects in map to modify the members of a list returned by a function reading data from a stream.
Except in this case it wasn't actually a sequence, but an Optional/Either and it wasn't about transforming that sequence but about error handling. So in a way the code wasn't even not intention-revealing, it was actually deceptive.
However, just as I also wrote, that's not an actual sequence of values, it's a single wrapped value (or none).
Optional can generally be thought of as a "sequence" of one or zero values. You could use an array of "[some]" or "[] /* none */" to manage control flow in an almost identical way (you'd just be adopting and managing an API that doesn't statically ensure that these arrays never have more than 1 value).
"map/flatMap" are predictable functions that can be used to manage the transformation of data (which is generally the entire point of code). The type/context that a computation is lifted into communicates a lot: Optional, for example, can be returned for a computation that may or may not return a value, and it can be "mapped" into another value by a pure computation that _always_ returns a value, or "flat-mapped" through a computation that may produce another nullable value. Anyone familiar with these basic functions can jump in, read the code, and generally know that every computation lifted into "map" can't fail, while every computation that is "flat-mapped" can. And in static languages it's all checked by the type system! No testing for "null" everywhere!
Whenever I write Java (or Java-like OO), I always have this exact "separate language within a language" feeling.
I'm supposedly working in a high-level, object-oriented, loosely-coupled, message-passing/dynamically-dispatching world of classes and instances; yet an awful lot of code is actually written in a separate language of "primitive values" with opaque control structures like if/then/else, for/while, etc.
Compare this to e.g. Smalltalk, where "ifTrue" is a method on boolean objects, "timesRepeat" is a method on integer objects, etc.
Having "for" not be a method on an object means it's something completely different: a magical keyword control structure, a gift from the irreproachable language designers to the lowly language users; since mere users cannot be trusted to make such decisions for themselves.
Is the potential of failure part of my domain? Or is it something I have to handle in order to avoid errors?
Should .businessLogic() have to handle the case if .validate() failed? Or should it only be called if validate succeeded?
Using a common API (Either is not new or novel, it's all over the place) to separate success from failure lets me write code that is only concerned with its side of the success/fail tree without polluting it with null checks and error handling that belongs elsewhere.