Igualdade no Pony

    O pónei apresenta duas formas de igualdade: por estrutura e por identidade.

    Igualdade de identidade

      A verificação da igualdade de identidade no Pony é feita através da palavra-chave. é verificar se os dois itens são os mesmos.

    if None is None then
      // Verdade!
      // Há apenas 1 Nenhum, então a identidade é a mesma
    
    let a = Foo("hi")
    let b = Foo("hi")
    
    if a is b then
      // Não. Isso é falso
    end
    
    let c = a
    if a is c then
      // Sim! É verdade!
    End

      Igualdade estrutural

        A verificação da igualdade estrutural no Pony é feita através do operador infix ==. Ele verifica que dois itens têm o mesmo valor. Se a identidade dos itens sendo comparados for a mesma, então por definição eles têm o mesmo valor.
          Você pode definir como a igualdade estrutural é verificada em seu objeto, implementando o eq(que: caixa->Foo) divertido: Bool. Lembre-se, já que == é um operador infix, eq deve ser definido no operando esquerdo, e o operando direito deve ser do tipo Foo.

        class Foo
          let _a: String
        
          new create(a: String) =>
            _a = a
        
          fun eq(that: box->Foo): Bool =>
            this._a == that._a
        
        actor Main
          new create(e: Env) =>
            let a = Foo("hi")
            let b = Foo("bye")
            let c = Foo("hi")
        
            if a == b then
              // won't print
              e.out.print("1")
            end
        
            if a == c then
              // will print
              e.out.print("2")
            end
        
            if a is c then
              // won't print
              e.out.print("3")
            end

          Se você não definir seu próprio eq, você herdará a implementação padrão que define igual por valor como sendo o mesmo que por identidade.

        interface Equatable[A: Equatable[A] #read]
          fun eq(that: box->A): Bool => this is that
          fun ne(that: box->A): Bool => not eq(that)

          Primitivas e igualdade

            Os primitivos são os mesmos que as classes, exceto por duas diferenças importantes:

        • Um primitivo não tem campos.
        • Há apenas uma instância de um primitivo definido pelo usuário.
          • Isto significa que cada primitivo de um determinado tipo é sempre estruturalmente igual e igual com base na identidade. Assim, por exemplo, Nenhum é sempre Nenhum.

          if None is None then
            // this is always true
          end
          
          if None == None then
            // this is also always true
          End
          www.000webhost.com