I came across an interesting problem recently to do with a concept I was pretty unfamiliar with: function decorators. The problem came from the email subscription Daily Coding Problems. It stated:
cons(a, b) constructs a pair, and car(pair) and cdr(pair) returns the first and last element of that pair. For example, car(cons(3, 4)) returns 3, and cdr(cons(3, 4)) returns 4.
Given this implementation of cons:
def cons(a, b): def pair(f): return f(a, b) return pair
Implement car and cdr.
Having some experience with Lisp languages (Scheme) I sort of got what was being asked: Implement these Lisp functions in python. But the stuff going on in the given code was weird to me, and actually there is a lot going on in these few lines of code. We have a function within a function, closure with the inner function accessing a and b although they aren't defined within it, and pair() taking in a function as an argument and cons() having a function as its return value. Also, what the heck is f?
After looking at the problem for a while I was still not getting it. I thought "cons is a function that returns a function which takes in a function and applies it to what was given as parameters to cons" which was too hard to wrap my head around. After looking up some stuff about function decorators, I had some better intuition and realized cons is modifying pair by telling it what to apply its parameter to. I then restated my analysis as "pair is a function that asks 'what should i do to a and b?' and cons is a function that makes pair functions for certain a's and b's". This made a lot more sense to me, and I was able to come up with the solution below:
def car (func): def retFirst(a,b): return a return func(retFirst)
This could be further reduced using lambda functions to my overall answer:
def car (f): return(f(lambda a,b: a)) def cdr (f): return(f(lambda a,b: b))
Just something I came across and found interesting, and maybe you will too! Also my first post on the site.