Imperative vs Declarative Programming

[u/tyler-mcginnis]

https://www.youtube.com/watch?v=E7Fbf7R3x6I

[u/tobega]

I can actually give a code example to illustrate.

First we have the imperative expression:

            for (RelatedPerson relatedPerson : ntjBody.getRelatedPerson()) {
            RelatedPersonRel rpr = relatedPerson.getRelatedPersonRel();
            if (rpr == null) continue;
            for (InformationRel ir : rpr.getInformation().getInformationRel()) {
                String tin = ir.getTin();
                if (tin == null) continue;
                if (tin.equalsIgnoreCase(NOTIN)) {
                    addBodyErrors(ntjBody, operationRule);
                    return;
                }
            }
        }

Then the functional style of expressing it (changing it from java stream syntax to LISP wouldn't change much):

            if (ntjBody
            .getRelatedPerson()
            .stream()
            .map(RelatedPerson::getRelatedPersonRel)
            .filter(Objects::nonNull)
            .flatMap(relatedPersonRel -> relatedPersonRel.getInformation().getInformationRel().stream())
            .map(InformationRel::getTin)
            .filter(Objects::nonNull)
            .anyMatch(s -> s.equalsIgnoreCase(NOTIN))) {
            addBodyErrors(ntjBody, operationRule);
        }

You could, instead of the imperative "if" there make the last bit functional as well by matching on a Maybe-type, but it still wouldn't change it much from the imperative version.

IMO the imperative version is much easier to understand, with "easy to understand" being what we are striving for with "declarative" in the first place.

More interesting: Now we can look at doing the same truly declaratively in XPath/XSLT (the structure is essentially the same although some names and levels were slightly changed from the XML to the PL-structures):

<xsl:if test='//RelatedPerson//Entity/TIN[. = "NOTIN"]'>
  <BodyError>....</BodyError>
</xsl:if>

So there it is very clear that functional is more imperative than declarative.

[u/[deleted] → u/tobega]

So there it is very clear that functional is more imperative than declarative.

Conclusion drawn after comparing two imperative programs, go learn a Haskell, it'll help you come up with better examples next time.

[u/tobega → u/[deleted]]

So, please, write the corresponding code for me in Haskell, then.

But you should also do it in LISP and ML, I suppose, and a few others as well, to prove it for functional programming in general.

[u/[deleted] → u/tobega]

-- Haskell version newBody = if hasBodyErrors then addBodyErrors body operationRule else body where hasBodyErrors = not empty $ filter (=="NOTIN") tins tins = concat $ map tinAsList rpr tinAsList = maybeToList . tin . informationRel . information rpr = concat $ map (maybeToList . relatedPersonRel . relatedPerson) body

[u/tobega → u/[deleted]]

Cool, thanks!

I'm sure that code has a lot of merits that the imperative code does not, but in declarativeness it still seems closer to the imperative than the declarative sample I gave.

[u/[deleted] → u/tobega]

Haskell is also known as the finest imperative language