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