Declaração de uso

    Para usar um pacote em seu código, você precisa ter um comando de uso. Isto diz ao compilador para encontrar o pacote que você precisa e disponibilizar os tipos definidos no mesmo. Todo arquivo Pony que precisa saber sobre um tipo de pacote deve ter um comando de uso para ele.
      Os comandos de uso são um conceito similar aos comandos Python e Java "importar", C/C++ "#incluir" e C# "usar", mas não exatamente o mesmo. Eles vêm no início dos arquivos Pony e se parecem com isto:

    use "collections"

      Isto encontrará todos os tipos publicamente visíveis definidos no pacote de coleções e os adicionará ao espaço de nomes de tipos do arquivo que contém o comando de uso. Estes tipos estão então disponíveis para uso dentro daquele arquivo, tal como se fossem definidos localmente.
        Por exemplo, a biblioteca padrão contém o tempo do pacote. Esta contém a seguinte definição (entre outras):

      primitive Time
        fun now(): (I64, I64)

        Para acessar a função agora basta adicionar um comando de uso:

      use "time"
      
      class Foo
        fun f() =>
          (var secs, var nsecs) = Time.now()

        Usar nomes

          Como vimos acima, o comando de uso adiciona todos os tipos públicos de um pacote no espaço de nomes do arquivo de uso. Isto significa que o uso de um pacote pode definir os nomes dos tipos que você deseja usar para seus próprios tipos. Além disso, se você usar dois pacotes dentro de um arquivo, ambos podem definir o mesmo tipo de nome, causando um choque em seu namespace. Por exemplo, o nome de um pacote pode ser definido como um nome de tipo:

        // In package A
        class Foo
        
        // No pacote B
        class Foo
        
        // no seu código
        use "packageA"
        use "packageB"
        
        class Bar
          var _x: Foo

          As declarações de _x são um erro porque não sabemos a qual Foo está sendo feita referência. Na verdade, nem sequer é necessário usar 'Foo', basta usar tanto o pacote A como o pacote B para causar um erro aqui.
            Para evitar este problema, o comando de uso permite que você especifique um apelido. Se você fizer isso, então apenas esse apelido será colocado em seu espaço de nomes. Os tipos do pacote usado podem então ser acessados usando este alias como um qualificador. Nosso exemplo agora se torna:

          // In package A
          class Foo
          
          // No pacote B
          class Foo
          
          // no seu código
          use a = "packageA"
          use b = "packageB"
          
          class Bar
            var _x: a.Foo  // O Foo do pacote A
            var _y: b.Foo  // O Foo do pacote B

            Se preferir, você pode dar um pseudônimo para apenas um dos pacotes. Foo ainda será adicionado a seu namespace referindo-se ao pacote:

          // No pacote A
          class Foo
          
          // No pacote B
          class Foo
          
          // no seu código
          use "packageA"
          use b = "packageB"
          
          class Bar
            var _x: Foo  // O Foo do pacote A
            var _y: b.Foo  // O Foo do pacote B

            Posso apenas especificar o caminho completo do pacote e esquecer o comando de uso, como eu faço em Java e C#? Não, você não pode fazer isso no Pony. Você não pode se referir a um pacote baseado em um comando de uso para outro pacote e não pode usar tipos de um pacote sem um comando de uso para esse pacote. Todo pacote que você deseja usar deve ter seu próprio comando de uso.
              Há limites para os nomes que eu posso usar para um pseudônimo? O uso de nomes alternativos tem que começar com uma letra minúscula. Além disso, você pode usar o nome que quiser, desde que não esteja usando esse nome para nenhum outro propósito em seu arquivo.

              Indicadores do esquema

                A sequência que damos a um comando de uso é conhecida como o especificador. Este consiste de um indicador de esquema e um localizador, separados por dois pontos. O indicador de esquema diz ao comando de uso o que queremos que ele faça, por exemplo, o indicador de esquema para incluir um pacote é "pacote". Se não forem encontrados dois-pontos dentro do especificador, então o comando de uso assume que você quis dizer "pacote".
                  Os dois comandos de uso a seguir são exatamente equivalentes:

                use "foo"
                use "package:foo"

                  Se você estiver usando uma cadeia de localização que inclui dois pontos, por exemplo, um caminho absoluto no Windows, então você tem que incluir o especificador do esquema "pacote":

                use "C:/foo/bar"  // Erro, esquema "C" é desconhecido
                use "package:C:/foo/bar"  // OK

                  Para permitir que os comandos de uso sejam portáteis entre sistemas operacionais, e para evitar confusão com caracteres de escape, o '/' deve ser sempre usado como separador de caminho em comandos de uso, mesmo no Windows.

                  Biblioteca padrão

                    A biblioteca padrão Pony é uma coleção de pacotes que podem ser usados conforme necessário para fornecer uma variedade de funcionalidades. Por exemplo, o pacote de arquivos fornece acesso a arquivos e o pacote de coleções fornece listas genéricas, mapas, conjuntos e assim por diante.
                      Há também um pacote especial na biblioteca padrão chamado builtin. Este contém vários tipos que o compilador tem que tratar especialmente e são tão comuns que todos os códigos Pony precisam saber sobre eles. Todos os arquivos fonte do Pony têm um comando de uso implícito "builtin". Isto significa que todos os tipos definidos no pacote builtin estão automaticamente disponíveis no espaço de nomes de tipos de todos os arquivos fonte do Pony.

                    www.000webhost.com