Assinaturas (F#)

Um arquivo de assinatura contém informações sobre as assinaturas públicas de um conjunto de F# elementos do programa, como, por exemplo, tipos, namespaces e módulos. Ele pode ser usado para especificar a acessibilidade desses elementos de programa.

Comentários

Para cada F# arquivo de código, você pode ter um arquivo de assinatura, que é um arquivo que tem o mesmo nome do arquivo de código, mas com o .fsi de extensão em vez de .fs. Arquivos de assinatura também podem ser adicionados à compilação de linha de comando se você estiver usando a linha de comando diretamente. Para distinguir entre os arquivos de código e arquivos de assinatura, os arquivos de código são às vezes denominados arquivos de implementação. Em um projeto, o arquivo de assinatura deve preceder o arquivo de código associado.

Um arquivo de assinatura descreve a namespaces, módulos, tipos e membros no arquivo de implementação correspondente. Use as informações em um arquivo de assinatura, para especificar quais partes do código na implementação correspondente arquivo pode ser acessado a partir do código fora do arquivo de implementação e que partes são internas para o arquivo de implementação. Os namespaces, módulos e tipos que são incluídos no arquivo de assinatura devem ser um subconjunto dos namespaces, módulos e tipos que são incluídos no arquivo de implementação. Com algumas exceções indicadas neste tópico, esses elementos de linguagem que não estão listados no arquivo de assinatura são considerados particulares do arquivo de implementação. Se nenhum arquivo de assinatura é encontrado no projeto ou na linha de comando, a acessibilidade padrão é usada.

Para obter mais informações sobre a acessibilidade padrão, consulte Controle de acesso (F#).

Em um arquivo de assinatura, você não se repetem a definição dos tipos e as implementações de cada método ou função. Em vez disso, você deve usar a assinatura para cada método e a função, que atua como uma especificação completa a funcionalidade é implementada por um fragmento de namespace ou módulo. A sintaxe de uma assinatura de tipo é o mesmo que são usados em declarações de método abstract em interfaces e classes abstratas e também é mostrada a por IntelliSense e o FSI. exe F# intérprete quando ela exibe a entrada compilada corretamente.

Se não há informações suficientes na assinatura de tipo para indicar se um tipo é sealed ou se ele é um tipo de interface, você deve adicionar um atributo que indica a natureza do tipo para o compilador. Os atributos que podem ser usados para essa finalidade são descritos na tabela a seguir.

O compilador produz um erro se os atributos não são consistentes entre a assinatura e a declaração no arquivo de implementação.

Use a palavra-chave val para criar uma assinatura para um valor de valor ou a função. A palavra-chave type apresenta uma assinatura de tipo.

Você pode gerar um arquivo de assinatura usando o --sig opção de compilador. Geralmente, você não escrever .fsi arquivos manualmente. Em vez disso, você pode gerar arquivos de .fsi usando o compilador, adicioná-los ao seu projeto, se você tiver um e editá-los removendo métodos e funções que não deseja que sejam acessíveis.

Existem várias regras para assinaturas de tipo:

• Abreviações de tipo em um arquivo de implementação não devem corresponder a um tipo sem uma abreviação em um arquivo de assinatura.

• Registros e uniões discriminadas devem expor todos ou nenhum de seus campos e construtores e a ordem na assinatura deve corresponder a ordem no arquivo de implementação. Classes podem revelar alguns, todos ou nenhum de seus campos e métodos na assinatura.

• Classes e estruturas que têm construtores devem expor as declarações de suas classes base (o inherits declaração). Além disso, classes e estruturas que têm os construtores devem expor todos os métodos abstratos e declarações de interface.

• Tipos de interface devem revelar seus métodos e interfaces.

As regras para assinaturas de valor são os seguintes:

• Modificadores de acessibilidade (public, internale assim por diante) e o inline e mutable modificadores na assinatura devem coincidir com aqueles na implementação.

• O número de parâmetros de tipo genérico (ou inferido implicitamente ou explicitamente declaradas) deve corresponder e os tipos e as restrições de tipo nos parâmetros de tipo genérico devem corresponder.

• Se a Literal atributo é usado, ele deve aparecer na assinatura e a implementação e o mesmo valor literal deve ser usado para ambos.

• O padrão de parâmetros (também conhecido como o arity) de assinaturas e implementações devem ser consistentes.

O exemplo de código a seguir mostra um exemplo de um arquivo de assinatura que tenha espaço para nome, módulo, o valor de função e assinaturas de tipo junto com os atributos apropriados. Ele também mostra o arquivo de implementação correspondente.

// Module1.fsi

namespace Library1
  module Module1 = 
    val function1 : int -> int
    type Type1 =
        new : unit -> Type1
        member method1 : unit -> unit
        member method2 : unit -> unit

    [<Sealed>]
    type Type2 = 
        new : unit -> Type2
        member method1 : unit -> unit
        member method2 : unit -> unit

    [<Interface>]
    type InterfaceType1 =  
        abstract member method1 : int -> int
        abstract member method2 : string -> unit

O código a seguir mostra o arquivo de implementação.

namespace Library1

module Module1 =

    let function1 x = x + 1


    type Type1() =
        member type1.method1() =
            printfn "test1.method1"
        member type1.method2() =
            printfn "test1.method2"


    [<Sealed>]
    type Type2() =
        member type2.method1() =
            printfn "test1.method1"
        member type1.method2() =
            printfn "test1.method2"

    [<Interface>]
    type InterfaceType1 =
        abstract member method1 : int -> int
        abstract member method2 : string -> unit

Consulte também

Conceitos

Controle de acesso (F#)

Outros recursos

Referência de linguagem do F#

Opções do compilador (F#)

Histórico de alterações