Allow One Function Call solution and explanation

def once(fn):
    called = False
    result = None
    def inner(*args):
        nonlocal called, result
        if not called:
            called = True
            result = fn(*args)
            return result
        return None
    return inner

import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.Function;

public class Once {
    public static <T, R> Function<T, R> once(Function<T, R> fn) {
        AtomicBoolean called = new AtomicBoolean(false);
        return (T arg) -> {
            if (called.compareAndSet(false, true)) {
                return fn.apply(arg);
            }
            return null;
        };
    }
}

function once(fn) {
  let called = false;
  let result;
  return function(...args) {
    if (!called) {
      called = true;
      result = fn(...args);
      return result;
    }
    return undefined;
  };
}

#include <iostream>
#include <functional>

class Once {
public:
    Once(std::function<int(int, int, int)> fn) : fn(fn), called(false) {}

    int operator()(int a, int b, int c) {
        if (!called) {
            called = true;
            result = fn(a, b, c);
            return result;
        }
        return -1; // Undefined equivalent
    }

private:
    std::function<int(int, int, int)> fn;
    bool called;
    int result;
};

int main() {
    Once onceFn([](int a, int b, int c){ return a + b + c; });
    std::cout << onceFn(1, 2, 3) << std::endl; // Outputs the result
    std::cout << onceFn(2, 3, 4) << std::endl; // Outputs undefined equivalent
    return 0;
}

#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>

typedef int (*Function)(int, int, int);

typedef struct {
    Function fn;
    bool called;
    int result;
} Once;

Once* once(Function fn) {
    Once* o = (Once*)malloc(sizeof(Once));
    o->fn = fn;
    o->called = false;
    o->result = 0;
    return o;
}

int once_call(Once* o, int a, int b, int c) {
    if (!o->called) {
        o->called = true;
        o->result = o->fn(a, b, c);
        return o->result;
    }
    return -1; // Represent undefined
}

int sum(int a, int b, int c) {
    return a + b + c;
}

int main() {
    Once* onceFn = once(sum);
    printf("%d\n", once_call(onceFn, 1, 2, 3)); // Output the sum
    printf("%d\n", once_call(onceFn, 2, 3, 6)); // Output undefined equivalent
    free(onceFn);
    return 0;
}

type JSONValue = null | boolean | number | string | JSONValue[] | { [key: string]: JSONValue };
type OnceFn = (...args: JSONValue[]) => JSONValue | undefined;

function once(fn: Function): OnceFn {
    let called = false;
    return function (...args) {
        if (!called) {
            called = true;
            return fn(...args);
        }
    };
}

/**
 * let fn = (a,b,c) => (a + b + c)
 * let onceFn = once(fn)
 *
 * onceFn(1,2,3); // 6
 * onceFn(2,3,6); // returns undefined without calling fn
 */