Conceito: Tipos com falha

Proponho o conceito de tipo com falha - modificação de tipos por analogia com anulável. Resumindo, este tipo pode adquirir um significado especial se algo der errado durante a execução do programa: o arquivo necessário não foi encontrado, ocorreu uma divisão por 0, etc. Esse tipo é projetado para lidar com erros perto de onde eles ocorrem, em oposição a exceções, que são mais adequadas para lidar com erros de forma centralizada. Para não mudar o layout 100.500 vezes, vou chamá-lo de "tipo errado", por mais engraçado que pareça.

Anúncio

Qualquer variável ou argumento de função pode ser declarado incorreto.

faultable int number;
faultable string fileName;
faultable Customer user;
void markCustomer (faultable string name){
 ...
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

O valor de retorno da função torna-se errôneo de fato, se em algum dos ramos houver retorno de um erro ou de um valor errôneo.

O tipo automático é considerado infalível, a menos que seja indicado o contrário.

Atribuindo um erro

O principal recurso para o qual esse tipo é introduzido é a capacidade de atribuir um significado especial a ele - o significado de um erro usando uma palavra-chave especial. O valor de erro pode ser acompanhado por uma descrição ou classe de erro.

number = fault;
filename = fault("  ");
return(fault(EOleException));
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Atribuições ao tipo normal

Ao contrário dos tipos anuláveis, um tipo incorreto pode passar diretamente um valor para variáveis ​​de um tipo infalível e vice-versa:

faultable int selNumber = 255;
...
int outNumber = selNumber;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Mas ao tentar atribuir um erro a um valor infalível, o compilador deve sair da função, retornando um erro:

faultable int selNumber = fault;
...
int outNumber = selNumber;//   
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Um erro deve ser lançado se o erro retornado pela função não for atribuído a nada

int parseMyDate(string strDate)
{
    ...
    return(fault);
}
...
parseMyDate("This is not a date");//
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, , , , , :

faultable Customer payer;
...
payer=fault("Customer not found");
...
faultable string name = customer.name;//    
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, , try...catch. .

, .

name=customer.name nofault;//   ,     name   
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

,

name=customer.name nofault "unknown";
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, :

var file=openFile(path) nofault(EFileNotExists) createFile(path);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

if (!variable.isFault()){
    outVar = variable;
}
else
{
    ...
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, amount = struct.getField("amount").toInteger() nofault 0;



,

try
{
    amount = struct.getField("amount").toInteger();
}
catch
{
    amount = 0;
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, . , , . .

, . catch/throw, « ».

, .

, , . , - . , . , , , — -, — , . , , .

, . — . , , .