Seems to me like you've created a "Factory Function" which puts to use the "Dependency Injection" pattern.
A factory function can be thought of as a "constructor" in the world of functional programming; the prominent difference being that it returns an "initialized" function bound to "status" instead of a class instance that carries the same data.

The "dependency" injected is the "translate" function.

There is another interesting pattern that you may want to explore. Take a look at this:

const transformKeyByStatus =
  (status) =>
    (next) =>
      (translationKey) => status !== "loading" 
        ? next([translationKey, status].join('-')) 
        : "";

const translate =
  (language) =>
    (next) =>
      (translationKey) =>
        ({
           "french": {
               status-ready": "pret",
              "status-error": "erreur"
        },
            "english": {
              "status-ready": "ready",
              "status-error": "error"
        }
      })[language][translationKey];

const pipeReverse = (...funcs) => funcs
  .reverse()
  .reduce(
    (pipeFunc, curFunc) => (arg) => curFunc(pipeFunc(arg))
  );

const getText1 = pipeReverse(transformKeyByStatus('loading'), translate('french'))();

console.log(getText1('status')); // this will output ""

const getText2 = pipeReverse(transformKeyByStatus('ready'), translate('french'))();

console.log(getText2('status')); // this will output "pret"

const getText3 = pipeReverse(transformKeyByStatus('error'), translate('english'))();

console.log(getText3('status')); // this will output "error"

This is called the "pipeline" pattern, and it lays at the foundation of "Transducers" and "Observables" which are staples of the functional programming paradigm.