O Princípio da Substituição de Liskov é incompatível com Introspecção ou Duck Typing?

Entendo corretamente que o Princípio da Substituição de Liskov não pode ser observado em linguagens em que objetos podem se inspecionar, como é habitual em linguagens tipificadas por pato?

Por exemplo, em Ruby, se uma classe Bherda de uma classe A, então para cada objeto xde A, x.classretornará A, mas se xfor um objeto de B, x.classnão retornará A.

Aqui está uma declaração do LSP:

Vamos q (x) ser um provable propriedade sobre objetos x do tipo T . Em seguida, q (Y) deve ser demonstrável para objectos y de tipo S , onde S é um subtipo de T .

Então, em Ruby, por exemplo,

class T; end
class S < T; end

viole o LSP neste formulário, como testemunhado pela propriedade q (x) =x.class.name == 'T'

Adição. Se a resposta for "sim" (LSP incompatível com a introspecção), minha outra pergunta seria: existe alguma forma "fraca" modificada de LSP que pode ser válida para uma linguagem dinâmica, possivelmente sob algumas condições adicionais e apenas com tipos especiais de propriedades .

Atualizar. Para referência, aqui está outra formulação de LSP que encontrei na web:

Funções que usam ponteiros ou referências a classes base devem poder usar objetos de classes derivadas sem conhecê-lo.

E outro:

Se S é um subtipo declarado de T, objetos do tipo S devem se comportar como objetos do tipo T devem se comportar, se forem tratados como objetos do tipo T.

O último é anotado com:

Observe que o LSP tem tudo a ver com o comportamento esperado dos objetos. Só se pode seguir o LSP se estiver claro sobre qual é o comportamento esperado dos objetos.

Isso parece ser mais fraco que o original e pode ser possível observar, mas eu gostaria de vê-lo formalizado, em particular explicado quem decide qual é o comportamento esperado.

O LSP não é uma propriedade de um par de classes em uma linguagem de programação, mas de um par de classes juntamente com um determinado conjunto de propriedades, satisfeito pela classe ancestral? Na prática, isso significaria que, para construir uma subclasse (classe descendente) respeitando o LSP, todos os usos possíveis da classe ancestral devem ser conhecidos? De acordo com o LSP, a classe ancestral deve ser substituída por qualquer classe descendente, certo?

Atualizar. Eu já aceitei a resposta, mas gostaria de adicionar mais um exemplo concreto de Ruby para ilustrar a pergunta. Em Ruby, cada classe é um módulo no sentido de que Classclasse é descendente de Moduleclasse. Contudo:

class C; end
C.is_a?(Module) # => true
C.class # => Class
Class.superclass # => Module

module M; end
M.class # => Module

o = Object.new

o.extend(M) # ok
o.extend(C) # => TypeError: wrong argument type Class (expected Module)

Aqui está o princípio real :

Seja q(x)uma propriedade comprovável sobre objetos xdo tipo T. Em seguida, q(y)deve ser demonstrável para objetos ydo tipo Sonde Sé um subtipo de T.

E o excelente resumo da Wikipedia :

Ele afirma que, em um programa de computador, se S é um subtipo de T, os objetos do tipo T podem ser substituídos por objetos do tipo S (ou seja, objetos do tipo S podem ser substituídos por objetos do tipo T) sem alterar nenhum dos as propriedades desejáveis ​​desse programa (correção, tarefa executada etc.).

E algumas citações relevantes do artigo:

O que é necessário é um requisito mais forte que restrinja o comportamento dos subtipos: as propriedades que podem ser comprovadas usando a especificação do tipo presumido de um objeto devem ser mantidas, mesmo que o objeto seja realmente um membro de um subtipo desse tipo ...

Uma especificação de tipo inclui as seguintes informações:
- O nome do tipo;
- Uma descrição do espaço de valor do tipo;
- Para cada um dos métodos do tipo:
--- Seu nome;
--- Sua assinatura (incluindo exceções sinalizadas);
--- Seu comportamento em termos de pré-condições e pós-condições.

Então, vamos à pergunta:

Entendo corretamente que o Princípio da Substituição de Liskov não pode ser observado em linguagens em que objetos podem se inspecionar, como é habitual em linguagens tipificadas por pato?

Não.

A.classretorna uma classe.
B.classretorna uma classe.

Como você pode fazer a mesma chamada no tipo mais específico e obter um resultado compatível, o LSP é retido. O problema é que, com linguagens dinâmicas, você ainda pode chamar as coisas no resultado, esperando que elas estejam lá.

Mas vamos considerar uma linguagem estaticamente estrutural (tipo pato). Nesse caso, A.classretornaria um tipo com uma restrição de que ele deve ser Aou um subtipo de A. Isso fornece a garantia estática de que qualquer subtipo de Adeve fornecer um método T.classcujo resultado seja um tipo que satisfaça essa restrição.

Isso fornece uma afirmação mais forte que o LSP contém em idiomas que suportam digitação de patos e que qualquer violação do LSP em algo como Ruby ocorre mais devido ao mau uso dinâmico normal do que a uma incompatibilidade de design de idioma.

No contexto do LSP, uma "propriedade" é algo que pode ser observado em um tipo (ou objeto). Em particular, fala sobre uma "propriedade comprovável".

Essa "propriedade" poderia existir um foo()método que não tem valor de retorno (e segue o contrato estabelecido em sua documentação).

Certifique-se de não confundir esse termo com "propriedade", como em " classé uma propriedade de todos os objetos no Ruby". Essa "propriedade" pode ser uma "propriedade LSP", mas não é automaticamente a mesma!

Agora, a resposta para suas perguntas depende muito de quão rigorosa você define "propriedade". Se você disser "a propriedade da classe Aé que .classretornará o tipo do objeto", Bna verdade ela possui essa propriedade.

Se, no entanto, você define a "propriedade" para ser " .classretornos A", então, obviamente, Bnão não têm essa propriedade.

No entanto, a segunda definição não é muito útil, pois você encontrou uma maneira geral de declarar uma constante.

Pelo que entendi, não há nada na introspecção que seja incompatível com o LSP. Basicamente, desde que um objeto suporte os mesmos métodos que outro, os dois devem ser intercambiáveis. Ou seja, se o seu código espera um Addressobjeto, então não importa se é um CustomerAddressou um WarehouseAddress, desde que ambos fornecem (por exemplo) getStreetAddress(), getCityName(), getRegion()e getPostalCode(). Você certamente poderia criar algum tipo de decorador que usa um tipo diferente de objeto e usa a introspecção para fornecer os métodos necessários (por exemplo, uma DestinationAddressclasse que pega um Shipmentobjeto e apresenta o endereço de entrega como um Address), mas não é obrigatório e certamente não impedir que o LSP seja aplicado.

Depois de examinar o artigo original de Barbara Liskov, descobri como concluir a definição da Wikipedia para que o LSP realmente pudesse ser satisfeito em quase qualquer idioma.

Primeiro de tudo, a palavra "comprovável" é importante na definição. Isso não é explicado no artigo da Wikipedia e "restrições" são mencionadas em outros lugares sem referência a ele.

Aqui está a primeira citação importante do artigo:

O que é necessário é um requisito mais forte que restrinja o comportamento dos subtipos: as propriedades que podem ser comprovadas usando a especificação do tipo presumido de um objeto devem ser mantidas, mesmo que o objeto seja realmente um membro de um subtipo desse tipo ...

E aqui está o segundo, explicando o que é uma especificação de tipo :

Uma especificação de tipo inclui as seguintes informações:

• O nome do tipo;
• Uma descrição do espaço de valor do tipo;
• Para cada um dos métodos do tipo:
  • O seu nome;
  • Sua assinatura (incluindo exceções sinalizadas);
  • Seu comportamento em termos de pré-condições e pós-condições.

Portanto, o LSP só faz sentido em relação a determinadas especificações de tipo e, para uma especificação de tipo apropriada (para a vazia, por exemplo), pode ser satisfeita provavelmente em qualquer idioma.

Considero a resposta de Telastyn a mais próxima do que eu estava procurando, porque as "restrições" foram mencionadas explicitamente.

Para citar o artigo da Wikipedia sobre LSP , "substituibilidade é um princípio na programação orientada a objetos". É um princípio e parte do design do seu programa. Se você escrever um código que dependa x.class == Adisso, é o seu código que está violando o LSP. Observe que esse tipo de código quebrado também é possível em Java, sem necessidade de digitação de pato.

Nada na digitação com patos quebra inerentemente o LSP. Somente se você abusar, como no seu exemplo.

Pensamento adicional: a verificação explícita da classe de um objeto não anula o objetivo da digitação do pato, afinal?