functional-programming | Introduction to Functional Programming using TypeScript | Functional Programming library

Functional programming languages have a variety of ways of achieving polymorphism. I'm going to contrast Java (the OOP language I know best) with Haskell (the functional language I know best).

Way 1: "parametric polymorphism"

With parametric polymorphism, you don't need to know anything at all about the underlying type. For example, if I have a singly-linked list with elements of type T, I actually don't need to know anything about type T in order to find the length of the list. I would just write something like

The second form you've linked to doesn't make much sense, I would avoid it.

If I rewrite your function like this it seems to work:

A "brute-force" solution can look as follows:

You can try this.

Add an ExpressionEvaluatingRequestHandlerAdvice (or a custom advice) to each endpoint.

Functional principles are just techniques and ideas. These are the bread and butter of the functional programming paradigm, which is what happens when you take these tools and use their unique advantages to gain systemic advantages.

A pure function is just a function with no side effects. You've written a million of these. But now, if you write only pure functions, your app can be split across processing cores with no effort or risk.

You've used constants before. But if you almost always use constants, then the things that are variable are the only things you have to think about when tracing code, and that is quite an advantage.

And you've chained functions before, but when you make everything pipe-able your entire language begins to feel like wiring up data flows, rather than giving the computer step-by-step instructions. This is much easier for humans to reason about and is less error-prone.

The techniques always have their advantages. When they become baseline assumptions, those advantages multiply. That's the functional paradigm.

Moving my comments here for clarity:

good question! In this article medium.com/@charlesbailey333/… it talked about how Rust had advantages over C++ because it incorporates functional programming ideas better. The evidence they give is that it supports Map, Reduce, and Filter. It almost seems like they're saying that those functions are "functional programming functions", but I don't think those functions are anything special. – Joshua Segal 16 mins ago

Okay great! This I can help with. SO this author is struggling to use the actual term for what they're referencing. It's called "expressiveness". Basically it means how close is the code I'm writing to the mental model of what I'm doing? For example, you want to give someone directions on how to get from A to B. Ideally, you do this by expressing it in turns and street names. However, if your language forces you to express this using the angle of the accelerator pedal and the angle of the steering wheel, this is much clunkier to do. C++ did it clunky. Rust did it elegantly and expressively.

In general, the functional and declarative languages tend to be much better at "expressing" your ideas in code and visually. You have branching paths? Your code literally looks like a branching tree. You have a data flow with a transformer? Guess what friend, that's just a function that transforms X to Y and a some sort of pipe operator that takes care of looping and new info.

The thing is, expressiveness isn't a statistic or something you can optimize for. It's an emergent "feeling" when using the language. The paradigms are general principles that tend to be internally consistent that produce useful "feelings". FP feels like flowing pipes and transformations. OOP feels like gadgets and features that talk to each other. The different mental models have different uses. FP is better for data processing. OOP can be good for UI and stateful services. At the boundaries they can clash a little, which is where the clunk comes from in C++.

At this point anything that is "completely OOP" or "completely FP" is usually shit, to be frank, so it can be a little hard to see the identities of the two when they are so merged. If you do complete OOP you can't compose anything and you have to write a million connector classes. If you do complete FP you can't modify state or have side effects (like... uh... showing stuff on screen?). These are genres. What makes something a house beat? If something else uses a house beat is it automatically house music? Does anyone care about the categorization?

There's not a specific "right FP way" to do this. It's about incorporating various techniques that serve your purpose. Here, I'll use the fp-ts library to show you the concepts of

1. the IO monad (to model a synchronous effect, bc your function is called "....DoesSomething...", so we imagine it's writing a Foo to disk)

2. functional composition (using flow here, which turns a bunch of functions into a single function)

3. immutability (immutable data reduces the possible errors you can encounter by ensuring the data is always as you expect)

4. lenses, in the category of optics, which deal with focusing on a single prop in an object and are basically a pair of getter and (immutable) setter functions

impl Trait syntax can only be used in argument position or return position of a function signature. Both of these are fine:

Consider the following expression: