Programmer Humor @lemmy.ml sebastiancarlos @lemmy.sdf.org 2w ago

Real Programmers Implement Functions On Top Of Classes

class BaseFunction {
  static #allowInstantiation = false;

  constructor(...args) {
    if (!BaseFunction.#allowInstantiation) {
      throw new Error(
        "Why are you trying to use 'new'? Classes are so 2015! Use our fancy 'run' method instead!"
      );
    }
    for (const [name, validator] of this.parameters()) {
      this[name] = validator(args.shift());
    }
  }

  parameters() {
    return [];
  }

  body() {
    return undefined;
  }

  static run(...args) {
    BaseFunction.#allowInstantiation = true;
    const instance = new this(...args);
    BaseFunction.#allowInstantiation = false;
    return instance.body();
  }
}

class Add extends BaseFunction {
  parameters() {
    return [
      ["a", (x) => Number(x)],
      ["b", (x) => Number(x)],
    ];
  }

  body() {
    return this.a + this.b;
  }
}

console.log(Add.run(5, 3)); // 8

28 comments

"Why are you trying to use 'new'? Classes are so 2015! [...]"

Uses new to throw error
OP, what's your address? I have a "present" for you
A true FP programmer would make it apply instead of run...
- Ahem, map...
  
  And, of course, everything is a lazy list even if the functions can't handle more than one element in each list.
It's just Java
- Yep, some code examples from the official documentation. This:
  
  printPersons( roster, (Person p) -> p.getGender() == Person.Sex.MALE && p.getAge() >= 18 && p.getAge() <= 25 );
  
  ...is syntactic sugar for this:
  
  interface CheckPerson { boolean test(Person p); } printPersons( roster, new CheckPerson() { public boolean test(Person p) { return p.getGender() == Person.Sex.MALE && p.getAge() >= 18 && p.getAge() <= 25; } } );
  
  ...which is syntactic sugar for this:
  
  interface CheckPerson { boolean test(Person p); } class CheckPersonEligibleForSelectiveService implements CheckPerson { public boolean test(Person p) { return p.gender == Person.Sex.MALE && p.getAge() >= 18 && p.getAge() <= 25; } } printPersons(roster, new CheckPersonEligibleForSelectiveService());
  
  The printPersons function looks like this:
  
  public static void printPersons(List<Person> roster, CheckPerson tester) { for (Person p : roster) { if (tester.test(p)) { p.printPerson(); } } }
  
  Basically, if you accept a parameter that implements an interface with only one method (CheckPerson), then your caller can provide you an object like that by using the lambda syntax from the first example.
  
  They had to retrofit lambdas into the language, and they sure chose the one hammer that the language has.
  
  Source: https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html
  
  That's not quite right. In bytecode, lambdas are significantly more efficient than anonymous class instances. So while the lambda implementation is semantically equivalent, characterizing it like you have is reductive and a bit misleading.
- Hence, Clojure. It's not just functions that implement IFn... as the string of "cannot cast to clojure.lang.IFn" errors that I get because I couldn't be bothered to validate my data's shape is eager to inform me.
- Golang also does this, but it's not classes.
  
  How so?
validators is a shitty name for something that actually does type conversion.
Dont look at C++ with std:: function
JS disgusts me
That'll be fun in a multi threaded setting!
What theme are you using, i like it!
- Looks like Catppuccin Mocha
  
  Thanks!
  
  Actually now that check it again its not quite right for mocha. But it's close!
Amazing, lol
I think that's called a functor.
I've seen something similar to this at work. Horrible.
Very DRY.

28 comments