Schönfinkel introduced the game of choosing a few simple primitive functions and expressing all other functions solely in terms of the primitives. Each primitive is named with a single capital letter. Any function can then be written as an expression with only parentheses and these few letters. One solution starts with these primitive functions:
```S = (λfgx.fx(gx))
K = (λxy.x)
I = (λx.x)```
All other use of λ is thus avoided, as well as the pesky variables. The syntax of this language, called combs here, is even simpler than for the λ calculus:
`<expression> := S | K | I | (<expression> <expression>)`
Application is still left associative. Indeed these three functions can be explained ab initio without λ thus:
```(Sfgx) → (fx(gx))
(Kxy) → x
(Ix) → x```
where the small letters might stand for arbitrary expressions. Now any function is equivalent to some expression which includes only parentheses and the letters S, K and I.

Unlambda is a Polish version of this language.

The program cnvSch2 transforms a λ expression into a Scheme program with the same meaning. This Scheme function, C, inspired by this page converts the yield of cnvSch2 into combs. The Y-combinator (λfx.(f(xx))(λx.(f(xx)))) is transformed by cnvSch2 to the Scheme program

`(λ(b)((λ(c)( b (λ(d)(( c  c ) d ))))(λ(c)( b (λ(d)(( c  c ) d ))))))`
which then converts by Scheme program C to:
Y = ((S ((S ((S (K S)) ((S (K K)) I))) ((S ((S (K S)) ((S ((S (K S)) ((S (K K)) (K S)))) ((S ((S (K S)) ((S ((S (K S)) ((S (K K)) (K S)))) ((S ((S (K S)) ((S (K K)) (K K)))) (K I))))) ((S ((S (K S)) ((S (K K)) (K K)))) (K I)))))) ((S (K K)) (K I))))) ((S ((S (K S)) ((S (K K)) I))) ((S ((S (K S)) ((S ((S (K S)) ((S (K K)) (K S)))) ((S ((S (K S)) ((S ((S (K S)) ((S (K K)) (K S)))) ((S ((S (K S)) ((S (K K)) (K K)))) (K I))))) ((S ((S (K S)) ((S (K K)) (K K)))) (K I)))))) ((S (K K)) (K I)))))

Which may be shortened by exploiting the associativity convention with this program, ass, to:
(S (S (S (K S) (S (K K) I)) (S (S (K S) (S (S (K S) (S (K K) (K S))) (S (S (K S) (S (S (K S) (S (K K) (K S))) (S (S (K S) (S (K K) (K K))) (K I)))) (S (S (K S) (S (K K) (K K))) (K I))))) (S (K K) (K I)))) (S (S (K S) (S (K K) I)) (S (S (K S) (S (S (K S) (S (K K) (K S))) (S (S (K S) (S (S (K S) (S (K K) (K S))) (S (S (K S) (S (K K) (K K))) (K I)))) (S (S (K S) (S (K K) (K K))) (K I))))) (S (K K) (K I)))))

I do not pretend to read such programs and I do not find Formatting helpful.

```((λSKI.
((λn.ni0) ((

((S ((S ((S (K S)) ((S (K K)) I)))
((S ((S (K S))
((S ((S (K S)) ((S (K K)) (K S))))
((S ((S (K S))
((S ((S (K S)) ((S (K K)) (K S)))) ((S ((S (K S)) ((S (K K)) (K K)))) (K I))))) ((S ((S (K S)) ((S (K K)) (K K)))) (K I)))))) ((S (K K)) (K I))))) ((S ((S (K S)) ((S (K K)) I))) ((S ((S (K S)) ((S ((S (K S)) ((S (K K)) (K S)))) ((S ((S (K S)) ((S ((S (K S)) ((S (K K)) (K S)))) ((S ((S (K S)) ((S (K K)) (K K)))) (K I))))) ((S ((S (K S)) ((S (K K)) (K K)))) (K I)))))) ((S (K K)) (K I)))))
(λrn.(zn(λd.H)(λD.((λnfx.f(nfx))(r(dn))))i))) 7))

)
(λfgx.fx(gx)) ; S
(λxy.x) ; K
(λx.x) ; I
) ; => 7```