Cómo compilar un decorador: C ++, Python y su propia implementación. Parte 2

Los decoradores son una de las características más inusuales de Python. Esta es una herramienta que puede existir completamente solo en un lenguaje interpretado de tipo dinámico. En la primera parte del artículo, mi amigo.Witcher136 mostró cómo implementar en C ++ lo más aproximado a la versión estándar (Python) de decoradores.

Te contaré cómo decidí intentar implementar decoradores en un lenguaje de programación compilado , para lo cual terminé escribiendo mi propio pequeño compilador Haskell basado en LLVM .

Tabla de contenido

1. Cómo funcionan los decoradores en Python
2. Haskell y LLVM - compilador nativo
3. Entonces, ¿cómo compilas un decorador?

Cómo funcionan los decoradores en Python

Antes de sumergirse en el algoritmo de compilación del decorador, hablemos sobre la implementación de decoradores en python y por qué no puede reproducirse de la misma forma en un lenguaje compilado. Noto de inmediato que en este artículo, python se entiende como CPython. Todas las partes del compartimento del motor se refieren solo a él.

, , , , — , .

Python, - , :

decorator, func, old. new — old

def decorator(func):
    def new(*args, **kwargs):
        print('Hey!')
        return func(*args, **kwargs)
    return new

@decorator
def old():
    pass

# old()  "Hey!" -   old    new

— , -, — , .

1. —

. decorator , :

name = input('  ')

def first(func):
    ...  #  

def second (func):
    ...  #  

if name == 'first':
    decorator = first
elif name == 'second':
    decorator = second
else:
    decorator = lambda f: f   #    

@decorator 
def old():
    pass

, old . (, C++) , (- ), . Python — , , , " ", .

, , old void-, , — , , , .

, Python, : .

2. Python

def decorator(func):
    def two_args(x, y):
        ...
    return two_args

@decorator
def one_arg(x):
    ...

, . one_arg , ( ) — , , , (, "" ). , ? " " . , , decorator -, .

, , , — . , .

— — func? , , — , . func A, A. void* func, , .

— func , — Witcher136 . , (. C++ ).

. :

• — ?
• — ?
• , , ( )

, Python — . , — Python — .

— " ", , , . , .

.

Haskell LLVM —

Haskell, , LLVM . Haskell llvm-hs, LLVM. Parsec, , - ( , , Parsec — parser combinators).

, Grit, ( , , ) — . .

Grit — expression-oriented ()

Grit, , if-else, , — , .

int main() = {
    int i = 0;
    i = i + if(someFunction() > 0) {
        1;
    }
    else {
        0;
    };
};

, i 1, someFunction , , 0 .

return

, ( ) .

, — , Grit, — , . returns, — , ; .

, , "" — "", — , .

int simple(int x) = {
    /* 
          
        x   y
    */
    int y = someOtherFunction();
    x + y;
};

/*
   ,    ,    .
      ,   
*/
int incr(int x) = x + 1;

int main() returns statusCode {
    /*
             returns
         ,  
           .
         "" 
         ,     
    */
    int statusCode = 0;
    int result = someFunction();
    if (someFunction < 0) {
        statusCode = 1;
    };
};

Auto — Grit

Grit auto, , ( ) .

— , . — — , — ..

, , returns.

auto half (int x) = x / 2;   //   incr    float

(expression-oriented), return ( — ) — Grit. , .

, , .

— ?

?

, , — runtime compile-time, .

, , , — , .

-, Grit — , ( AST, abstract syntax tree), . -, , .

, :

@auto flatten = {
    auto result = @target;
    if (result < 0) {
        0;
    }
    else {
         result;
    };
};

, , 0, 0, .

@auto flatten — flatten @auto — , (@ — , , ).

. , — , , , .

— @target. , . ( ), , , , ( ).

, AST @target, . , , — . , .

@auto lockFunction = {
    mutex.lock();
    @target
};

@auto optional = if (checkCondition()) {
    @target;
}
else {
    someDefaultValue;
};

Grit :

@auto flatten = {
    auto result = @target;
    if (result < 0) {
        0;
    }
    else {
         result;
    };
};

@flatten
int incr(int x) = x+1;

flatten , .

"" , - :

Decorator "flatten" auto {
  BinaryOp = (Def auto "result") (DecoratorTarget)
  If (BinaryOp < (Var "result") (Int 0)) {
    Int 0
  }
  else {
    Var "result"
  }
}
Function "incr" int ; args [Def int "x"] ; modifiers [Decorator "flatten"] ; returns Nothing {
  BinaryOp + (Var "x") (Int 1)
}

, — Decorator, incr , Decorator "flatten". DecoratorTarget — incr.

, — . , , , "" — , .

, :

Function (int -> int) incr ["x"] {
  BinaryOp i= (Def int "result") (
    Block int {
      BinaryOp i+ (Var int "x") (int 1)
    }
  )
  If int (BinaryOp b< (Var int "result") (int 0)) {
    int 0
  }
  else {
    Var int "result"
  }
}

:

• — AST, .
• incr — , flatten, DecoratorTarget Block {...} — " ", . , , — int "result". BinaryOp i= int-, result auto — , , .

, , , . Python, , , Grit.

, — , , :

@auto lockF(mutex M) {
    M.lock();
    @target;
};

@lockF()
int someFunction(...)

— mutex M, "", (, , Python — ).

, @args, , " " . , @args.length — , @args.1 — . - , - — .

, Haskell , , , , . , ( , ), - .

, stack

PD: Fue una experiencia muy interesante e inusual para mí, espero que tú también puedas sacar algo útil de esta historia. Si necesita un artículo separado sobre cómo escribir un compilador Haskell basado en LLVM, escriba los comentarios.

Trataré de responder cualquier pregunta en los comentarios o en un telegrama: @ nu11_pointer_exception