What is the name of λx.λf.fx in lambda calculus?
Does the corresponding function have a standard name in functional programming languages, like Haskell?
In object oriented programming, is there a usual name for a method foo which takes a function as an argument, such that x.foo(f) returns f(x)?
In Haskell, \x.\f.f x is flip ($) which as $ is read as apply, I would read as reverse apply.
Roughly based on https://stackoverflow.com/questions/4090168/is-there-an-inverse-of-the-haskell-operator
\f.\x.\y.f y x flip is C here en.wikipedia.org/wiki/B,C,K,W_system
May 18, 2013 at 13:46
$ to flip like this is expecting a partially applied function that takes over 2 arguments where you're going to only flip the last 2 so you partially apply all but those 2
May 18, 2013 at 13:52
(\f.\x.\y.f y x) (\f.\x.f x) reduces to (\x.\f.f x) modulo renaming? Which it does.
Using the standard combinators you can express this function as
C I
where
C f x y = (f y) x
In Haskell it would be
flip id
Here id's type is specialized to (a -> b) -> a -> b and flip swaps a -> b and a.
You can also express it in the SKI calculus:
S (K (S I)) K
In the original Alonzo Church's "The calculi of lambda-conversion", he denotes this combinator by T.
In the context of Church numerals, it is called exp. This matches the "shorthand" notation used by Church for the "application" of a term N to a term M: "[MN]" stands for "(NM)".
I haven't heard yet of a standard name for an analogous function in programming.
This is sometimes referred to as the thrush combinator, and in Clojure it's called the thread-first macro. It's primary use is in allowing you to express a computation as a series of chained computations in the order they execute in. For instance, taking a value x, passing it to a function f, then passing the results of f(x) to a function g, would be written as g(f(x)) using standard function composition (or g (f x) if you're working with implicit parentheses.) This can be awkward when there's a large number of chained functions because you have to read them in the reverse order of how they execute. The thrush combinator lets you express this differently, if we define the thrush combinator as:
T x f = f x
T x f g ... = T (T x f) g ...
Then the expression T x f g h becomes h (g (f x)).
(For those looking for more information as well as a concrete implementation in the language Racket, I have a blog post on the subject: Thrush Combinator in Racket)
I hope I understand your question correctly, but I believe this is known as the (reverse) Pipe Operator in ML languages.
[1; 2; 3] |> List.map sq // let it = [1; 4; 9]
There is also the Reverse Pipe Operator which helps with order of operations.
printf "The value is.." <| 2 + 3 // let it = "The value is..5"
This is useful because the unpiped form
printf "The value is.." 2 + 3 ;; error
would error because printf would try to evaluate "The value is.." 2 and error because there is no defined + operator. In order to make that work, use parenthesis:
printf "The value is.." (2 + 3) // let it = "The value is..5"
As for practical use, the |> operator is incredibly useful and the bread-and-butter of many ML and ML-inspired languages such as F#, LiveScript and Elixir. <| is less common and typically only used when it increases readability.
