Extensões de tipo

As extensões de tipo (também chamadas de aumentos) são uma família de recursos que permitem adicionar novos membros a um tipo de objeto definido anteriormente. Os três recursos são:

• Extensões de tipo intrínseco
• Extensões de tipo opcionais
• Métodos de extensão

Cada um pode ser usado em diferentes cenários e tem diferentes compensações.

Syntax

// Intrinsic and optional extensions
type typename with
    member self-identifier.member-name =
        body
    ...

// Extension methods
open System.Runtime.CompilerServices

[<Extension>]
type Extensions() =
    [<Extension>]
    static member extension-name (ty: typename, [args]) =
        body
    ...

Extensões de tipo intrínseco

Uma extensão de tipo intrínseco é uma extensão de tipo que estende um tipo definido pelo usuário.

As extensões de tipo intrínseco devem ser definidas no mesmo arquivo e no mesmo namespace ou módulo do tipo que estão estendendo. Qualquer outra definição resultará em extensões de tipo opcionais.

As extensões de tipo intrínseco às vezes são uma maneira mais limpa de separar a funcionalidade da declaração de tipo. O exemplo a seguir mostra como definir uma extensão de tipo intrínseco:

namespace Example

type Variant =
    | Num of int
    | Str of string
  
module Variant =
    let print v =
        match v with
        | Num n -> printf "Num %d" n
        | Str s -> printf "Str %s" s

// Add a member to Variant as an extension
type Variant with
    member x.Print() = Variant.print x

O uso de uma extensão de tipo permite separar cada um dos seguintes:

• A declaração de um tipo Variant
• Funcionalidade para imprimir a classe Variant dependendo de sua "forma"
• Uma maneira de acessar a funcionalidade de impressão com notação . de estilo de objeto

Esta é uma alternativa para definir tudo como membro em Variant. Embora não seja uma abordagem inerentemente melhor, pode ser uma representação mais clara da funcionalidade em algumas situações.

As extensões de tipo intrínseco são compiladas como membros do tipo que aumentam e aparecem no tipo quando o tipo é examinado por reflexão.

Extensões de tipo opcionais

Uma extensão de tipo opcional é uma extensão que aparece fora do módulo original, namespace ou assembly do tipo que está sendo estendido.

As extensões de tipo opcionais são úteis para estender um tipo que não foi definido por você. Por exemplo:

module Extensions

type IEnumerable<'T> with
    /// Repeat each element of the sequence n times
    member xs.RepeatElements(n: int) =
        seq {
            for x in xs do
                for _ in 1 .. n -> x
        }

Agora você pode acessar RepeatElements como se fosse um membro de IEnumerable<T> desde que o módulo Extensions esteja aberto no escopo em que você está trabalhando.

Extensões opcionais não aparecem no tipo estendido quando examinadas por reflexão. Extensões opcionais devem estar em módulos e estão apenas no escopo quando o módulo que contém a extensão está aberto ou está no escopo.

Membros de extensão opcionais são compilados para membros estáticos para os quais a instância do objeto é passada implicitamente como o primeiro parâmetro. No entanto, eles agem como se fossem membros de instância ou membros estáticos de acordo com a forma como são declarados.

Membros de extensão opcionais também não são visíveis para consumidores de C# ou Visual Basic. Eles só podem ser consumidos em outro código F#.

Limitação genérica de extensões de tipo intrínsecas e opcionais

É possível declarar uma extensão de tipo em um tipo genérico onde a variável de tipo é restrita. O requisito é que a restrição da declaração de extensão corresponda à restrição do tipo declarado.

No entanto, mesmo quando as restrições são correspondidas entre um tipo declarado e uma extensão de tipo, é possível que uma restrição seja inferida pelo corpo de um membro estendido que impõe um requisito diferente ao parâmetro de tipo do tipo declarado. Por exemplo:

open System.Collections.Generic

// NOT POSSIBLE AND FAILS TO COMPILE!
//
// The member 'Sum' has a different requirement on 'T than the type IEnumerable<'T>
type IEnumerable<'T> with
    member this.Sum() = Seq.sum this

Não é possível fazer esse código funcionar com uma extensão de tipo opcional:

• Como está, o membro Sum tem uma restrição diferente em 'T (static member get_Zero e static member (+)) do que é definido pela extensão de tipo.
• Modificar a extensão de tipo para ter a mesma restrição que Sum não corresponderá mais à restrição definida em IEnumerable<'T>.
• Alterar member this.Sum para member inline this.Sum dará um erro de que as restrições de tipo são incompatíveis.

O que se deseja são métodos estáticos que "flutuam no espaço" e podem ser apresentados como se estivessem estendendo um tipo. É aqui que os métodos de extensão se tornam necessários.

Métodos de extensão

Finalmente, métodos de extensão (às vezes chamados de "membros de extensão de estilo C#") podem ser declarados em F# como um método de membro estático em uma classe.

Os métodos de extensão são úteis quando você deseja definir extensões em um tipo genérico que restringirá a variável de tipo. Por exemplo:

namespace Extensions

open System.Collections.Generic
open System.Runtime.CompilerServices

[<Extension>]
type IEnumerableExtensions =
    [<Extension>]
    static member inline Sum(xs: IEnumerable<'T>) = Seq.sum xs

Quando usado, este código fará parecer que Sum está definido em IEnumerable<T>, desde que Extensions tenha sido aberto ou esteja no escopo.

Para que a extensão esteja disponível para o código VB.NET, é necessário um ExtensionAttribute extra no nível do assembly:

module AssemblyInfo
open System.Runtime.CompilerServices
[<assembly:Extension>]
do ()

Outras observações

As extensões de tipo também têm os seguintes atributos:

• Qualquer tipo que possa ser acessado pode ser estendido.
• As extensões de tipo intrínseco e opcional podem definir qualquer tipo de membro, não apenas métodos. Portanto, as propriedades de extensão também são possíveis, por exemplo.
• O token self-identifier na sintaxe representa a instância do tipo que está sendo invocado, assim como os membros comuns.
• Os membros estendidos podem ser membros estáticos ou de instância.
• As variáveis de tipo em uma extensão de tipo devem corresponder às restrições do tipo declarado.

As seguintes limitações também existem para extensões de tipo:

• As extensões de tipo não oferecem suporte a métodos virtuais ou abstratos.
• As extensões de tipo não oferecem suporte a métodos de substituição como aumentos.
• As extensões de tipo não oferecem suporte a Parâmetros de tipo resolvidos estaticamente.
• As extensões de tipo opcional não oferecem suporte a construtores como aumentos.
• As extensões de tipo não podem ser definidas em abreviações de tipo.
• As extensões de tipo não são válidas para byref<'T> (embora possam ser declaradas).
• As extensões de tipo não são válidas para atributos (embora possam ser declaradas).
• Você pode definir extensões que sobrecarregam outros métodos com o mesmo nome, mas o compilador F# dá preferência a métodos sem extensão se houver uma chamada ambígua.

Por fim, se existirem várias extensões de tipo intrínseco para um tipo, todos os membros deverão ser exclusivos. Para extensões de tipo opcionais, membros em extensões de tipo diferentes para o mesmo tipo podem ter os mesmos nomes. Erros de ambiguidade ocorrem apenas se o código do cliente abrir dois escopos diferentes que definem os mesmos nomes de membros.

Confira também

• Referência da Linguagem F#
• Membros