Function with memories of its past life

Question

Task

I need a function that accept string and return a function f1.

That f1 function should also accept string and return a f2 function, but as a side effect it must print string passed to previous function.

That f2 function should also accept string and return a f3 function, but as a side effect it must print string passed to previous function.

And so on.

For language that require explicit declaration of side effects (like haskell) you may return next best thing (like IO(...) in haskell).

For language that don't have function as first class object (like Java) you may return next best thing (like instance of Function interface in Java).

You need to show function and example of it usage.

This is code golf all standard rules apply. Only function itself is counted in score. Example is for demonstration only.

Reference implementation in Java

    static Function<String, Function> f(String s) {
        class C implements Function<String, Function> {
            String s1;

            public C(String s) {
                s1 = s;
            }

            @Override
            public Function apply(String s) {
                System.out.println(s1);
                return new C(s);
            }
        }
        return new C(s);
    }

Example of usage

        Function<String, Function> t = f("s1");
        t = t.apply("s2"); // Prints "s1"
        t = t.apply("s3"); // Prints "s2"

Answer 1

JavaScript (V8), 21 bytes

f=s=>x=>f(x,print(s))

Try it online!

Answer 2

K (ngn/k), 9 bytes

partial application ftw

{ \x;o@y}

Try it online!

 f:{ \x;o@y}
 f:f"s1"
 f:f"s2"
"s1"
 f:f"s3"
"s2"

Answer 3

R, 24 bytes

f=\(s)\(t){show(s);f(t)}

Attempt This Online!

Answer 4

Java, 85 bytes

interface N{N f(String s);static N i=s->t->{System.out.println(s);return N.i.f(t);};}

Try it online.

Explanation:

interface N{     // Interface to use as our lambda
  N f(String s); //  taking a String parameter, and returning another instance of itself

  static         // Static context so we're able to reference the interface
         N i=    // Create this interface as re-usable lambda method:
    s->          //  Taking a String parameter and returning another lambda method:
       t->{      //   Also taking a String parameter and returning a lambda method:
         System.out.println(s);
                 //    Print the String of the outer lambda with trailing newline
         return  //    And then return
           N.i.f(t);};}
                 //     A call to the outer lambda with the inner String parameter,
                 //     using a static call to prevent 'self-reference in initializer' errors

Answer 5

Arturo, 33 bytes

f:$->x->$.import:->x=>[f&print,x]

Try it!

Ungolfed:

f: function [x][
    function .import:[x] [y][
        print x
        f y
    ]
]

Answer 6

Ruby, 23 bytes

f=->s{->z{puts s;f[z]}}

Try it online!

Answer 7

C (gcc), 27 bytes

t;f(s){t&&puts(t);t=s;s=f;}

Try it online!

Answer 8

Wolfram Language (Mathematica), 19 18 bytes

f@a_=f[Print@a;#]&

Try it online!

---

(subjectively) more interesting:

24 bytes:

Curry[Print@@##2;#0]@!#&

Try it online!

27 bytes:

#0@*(D@@(#/._?Print@_->$))&

Try it online!

Answer 9

Haskell, 57, 45 bytes

Solution using a constructor:

data U=U([Char]->IO U);f s=U$(<$putStrLn s).f

Try it online!

Invalid solution using typeclasses:

{-#LANGUAGE FlexibleInstances#-}
class F a where g::String->a
instance F()where g _=()
instance F a=>F(String->IO a)where g a b=g b<$putStrLn a

Try it online!

The the typeclass based version will eventually return IO (), so it isn't really infinite. The non-typeclass based version however does go on forever.

Answer 10

PARI/GP, 21 bytes

f(x)=t->print(x);f(t)

Attempt This Online!

Answer 11

Python 3, 38 bytes

f=lambda x:lambda y:[f(y),print(x)][0]

Try it online!

Well sadly, the anonymous function can’t be shorter while being completely anonymous… 😮‍💨

Answer 12

Clojure, 25 bytes

defn f[s]#(do(pr s)(f %))

Try it online!

Answer 13

C++, 69 bytes

auto f(auto s){return[=](this auto t,auto n){return cout<<s,s=n,t;};}

Try it online!

Answer 14

Rust, 57 49 45 29 bytes

fn x(s:&str)->!{dbg!(s);x(s)}

Attempt This Online!