Eliminar duplicados usando solo las funciones lambda

Encontré la pregunta Python: eliminar duplicados en la lista solo con filter y lambda , donde el OP pregunta cómo eliminar elementos duplicados de una lista de Python utilizando exclusivamente las funciones filter y lambda .

Esto me hizo preguntarme, ¿es posible, desde un punto de vista teórico, eliminar los duplicados de una lista de Python usando solo las funciones lambda ?

Si es así, ¿cómo podemos hacer eso?

En este caso, “eliminar los duplicados” significa “mantener exactamente una aparición de cada elemento presente en la lista original”, por lo que [1,2,1,3,1,4] debería convertirse en [1,2,3,4] .

Además, el objective es escribir solo una lambda , por lo que el código sería de una sola línea como:

 lambda l: """do something that returns l without duplicates""" 

No se debe utilizar ninguna variable externa.

Además, en cuanto a la pregunta anterior, no se permite nada “sofisticado”, especialmente la función de set , así como reduce , map

Básicamente, ninguna otra función, incluso la incorporada, debe ser llamada.

Desde un punto de vista teórico, si un problema computacional requiere una entrada y una salida sin efecto secundario, el cálculo lambda probablemente puede resolverlo (más generalmente, el cálculo lambda es Turing completo, cf wikipedia ).

Ahora para la implementación, la siguiente función lambda toma un argumento de lista y devuelve una lista donde se han eliminado todos los duplicados:

 lambda l: (lambda u, a: u(u, a)) ((lambda f, x: x if len(x) <= 0 else (f(f, x[1:]) if x[0] in x[1:] else ([x[0]] + f(f, x[1:])))), l) 

Aquí hay una versión sin envolver:

 lambda l: (lambda u, a: u(u, a)) ( (lambda f, x: x if len(x) <= 0 else ( f(f, x[1:]) if x[0] in x[1:] else ([x[0]] + f(f, x[1:])) ) ), l ) 

La función consiste en una versión lambda de la siguiente función recursiva:

 def f(l): if len(l) <= 0: return l elif l[0] in l[1:]: return f(l[1:]) else: return ([l[0]] + f(l[1:])) 

Para emular una llamada recursiva, la lambda equivalente toma una función adicional como argumento, que será en sí misma:

 lambda f, x: x if len(x) <= 0 else ( f(f, x[1:]) if x[0] in x[1:] else ([x[0]] + f(f, x[1:])) ) 

Luego, otro lambda llama a esta función anterior, pasándose como argumento (además de la lista):

 lambda u, a: u(u, a) 

Finalmente, una lambda exterior envuelve todo, eso toma solo una lista como argumento.