Esolanging Fruit

antifreeze

antifreeze

Does anyone really want that?

I'm considering adding an interactive IO option where the stack is initialized with two impure functions: one that takes a Church numeral and writes it to STDOUT, and one that ignores its argument and returns a Church numeral read from STDIN.

I didn't know we had a tips page.

For example, with P = S S K you can implement factorial along the lines of P (λn s. if n = 0 then 1 else P s (n - 1))

In practice, if you want to write a recursive function S S K = λa b. a b a might be a more useful combinator than fix.

where fⁿ represents function iteration

and more generally, succⁿ K = λf x. fⁿ f

succ K = (λn f x. f (n f x)) K
       = λf x. f (K f x)
       = λf x. f f
       = λf x. f f

succ (succ K) = (λn f x. f (n f x)) (λf x. f f)
              = λf x. f ((λf x. f f) f x)
              = λf x. f (f f)

Noticing <><<>()> in the expression prompted me to try a few iterates of succ at K:

fix = λf. (λx. f (D x x)) (λx. f (D x x))
    = λf. push (λx. f (D x x)) pop
    = λf. push (f ∘ λx. D x x) pop
    = λf. push (f ∘ λx. S (S (K x) (K x))) pop
    = λf. push (f ∘ S ∘ λx. S (K x) (K x)) pop
    = λf. push (f ∘ S ∘ λx. (S ∘ K) x (K x)) pop
    = λf. push (f ∘ S ∘ S (S ∘ K) K) pop
   := {(<{}<>[<><<>()>()]>){}}

That gives us a much shorter derivation:

D f a = S (S (K f) (K a)) I
     := <> <f [() a]> {{}}

Actually, there's an alternative derivation of D for when f and a are already known:

(haven't tested if it works, but it should in principle)

fix = λf. (λx. x x) (λx. f (D x x))
    = (λx. x x) ∘ (λf x. f (D x x))
    = (λx. x x) ∘ (λf. f ∘ (λx. D x x))
    = S I I ∘ (λf. f ∘ S D I)
   := <[<>{{}}{{}}]{<{}[<>{<><<>[<>[(){}]]()>[(){{}}]}{{}}]>}>

You can use the delayed application combinator to implement a Y combinator:

It's not Flurry, but I thought I'd revive Flobnar

Draw an asterisk triangle

Also {<><<>[<>[(){}]]()>[<>()]}, which has the side effect of evaluating a b.

I got {<><<>[<>[(){}]]()>[(){{}}]} after messing around for a bit, but there might be a shorter answer.

Challenge: implement the function D = λf a b. f a b. Ensure that D f a does not evaluate f a immediately.

It also has the advantage of working when the stack is non-empty, although that doesn't matter in this case.

The function is allowed to have side effects as long as it leaves an empty stack empty.

The Haskell interpreter works by passing an opaque f and z value and checking that the resulting evaluation chain looks like f (f (... (f z)...))

Output.

It doesn't look like the online interpreter handles newlines correctly.

Print a 10 by 10 grid of asterisks

Already having experience with lambda calculus/CL programming is useful.

You can't detect any if they are created during reduction, but you could probably recognize constants and do simple pattern matching for succ, addition, multiplication, and exponentiation.

I wonder if it would be possible to add explicit support for Church numerals.

I got lucky with that one - it essentially only works due to insane coincidences.

Here's a much shorter equality answer (though not composable)

That gets us a shorter even/odd answer.

Never mind, n(){{}} works.

What's the easiest way to convert n from 0 to 1 and vice versa? n[()[<>()]]{{}} is annoyingly long.

I guess that's one weird rule you wouldn't have to handle if you wanted a visual interpreter with step-by-step reduction.

I forgot how my own interpreter works ಠ_ಠ

Ah, never mind

In the second example, the first pop returns 3 and the second returns 2.

Which means [[f a] b] can have different behavior from [f a b] in some situations.

Yes, Flurry reduces a sequence of applications by first reducing each of the terms and then performing each application in sequence.

<> <<> () <> [<> {{}}] ()> [() ()] {} {} {{<> ()}}      | a b
<> <<> () <> [<> {{}}] ()> [() ()] b {} {{<> ()}}       | a
<> <<> () <> [<> {{}}] ()> [() ()] b a {{<> ()}}        |
<<> () <> [<> {{}}] ()> b [() () b] a {{<> ()}}         |
<<> () <> [<> {{}}]> [() b] [() () b] a {{<> ()}}       |
<<> () <>> [<> {{}} [() b]] [() () b] a {{<> ()}}       |
<<> ()> [<> [<> {{}} [() b]]] [() () b] a {{<> ()}}     |
<> [() [<> [<> {{}} [() b]]]] [() () b] a {{<> ()}}     |
() [<> [<> {{}} [() b]]] a [() () b a] {{<> ()}}        |

Here's the execution trace for your swap operator:

The original purpose was to find a shorter SWAP operation, but it didn't end up helping. It might be useful for other people, though

I wrote a program to brute force CL expressions a while back: gist.github.com/Reconcyl/2c37c6e52564013bc86f0792df7b5bb6

Which argument order would you prefer - Z = λzs. z; S n = λzs. s n or Z = λsz. z; S n = λsz. s n?

I might also add support for Scott encoding, though it's a little trickier to detect.

I don't know of any.