Можно ли передавать размеченные теги объединения в качестве аргументов?

Дискриминированные союзы работают лучше всего, если между падежами нет семантического совпадения.

В вашем примере каждый случай содержит один и тот же компонент с одинаковым значением, string указывающий «название животного». Но это семантическое совпадение! Затем дискриминационный союз заставит вас проводить различия, которых вы не хотите: вы не хотите, чтобы вас заставляли различать «имя свиньи» и «имя коровы». ; вы просто хотите думать о «названии животного».

Давайте сделаем тип, который подходит лучше:

type Animal = Pig  | Cow  | Fish
type Pet = Animal * string

let animals = [(Pig, "Mike"); (Fish, "Eve"); (Pig, "Romeo")

С этим типом фильтрация не-Pigs является однострочной:

animals |> List.filter (fst >> (=) Pig) 

Если не у каждого животного есть имя, используйте вариант типа:

type Pet = Animal * string option

Вы использовали бы размеченный союз для своих животных, если бы знали, что, скажем, у каждого Pig есть имя, а у Fish нет: эти случаи не пересекаются.

Вы можете изменить функцию filterAnimals, чтобы она принимала в качестве входных данных частично активный шаблон:

let rec filterAnimals (|IsAnimalType|_|) animals =
    if animals = [] then
        []
    else
        let rest = filterAnimals (|IsAnimalType|_|) (List.tail animals)
        match List.head animals with
        | IsAnimalType animal -> animal::rest
        | _ -> rest

Затем вы можете определить активный частичный шаблон для свиней:

let (|IsPig|_|) candidate =
    match candidate with
    | Pig(_) -> Some candidate
    | _ -> None

И вы можете вызвать функцию следующим образом (пример FSI):

> filterAnimals (|IsPig|_|) animals;;
val it : Animal list = [Pig "Mike"; Pig "Sarah"; Pig "John"]

На самом деле вы можете уменьшить Partial Active Pattern следующим образом:

let (|IsPig|_|) = function | Pig(x) -> Some(Pig(x)) | _ -> None

И оказывается, что их можно даже инлайнить:

> filterAnimals (function | Pig(x) -> Some(Pig(x)) | _ -> None) animals;;
val it : Animal list = [Pig "Mike"; Pig "Sarah"; Pig "John"]
> filterAnimals (function | Fish(x) -> Some(Fish(x)) | _ -> None) animals;;
val it : Animal list = [Fish "Eve"]
> filterAnimals (function | Cow(x) -> Some(Cow(x)) | _ -> None) animals;;
val it : Animal list = [Cow "Laura"]

Просто для полноты картины я перечислю это решение.
Если вы процитировав ваш вклад, вы сможете рассуждать о названиях тегов:

open Microsoft.FSharp.Quotations

type Animal = Pig of string | Cow of string | Fish of string

let isAnimal (animalType : Expr) (animal : Expr) =
    match animal with
        | NewUnionCase(at, _) ->
            match animalType with
                | Lambda (_, NewUnionCase (aatt, _)) -> aatt.Name = at.Name
                | _ -> false
        | _ -> false

let animal = <@ Pig "Mike" @>
isAnimal <@ Pig @> animal  // True
isAnimal <@ Cow @> animal  // False

Это, по общему признанию, довольно многословно, и это стало бы еще больше, если бы вы хотели процитировать список вместо одного значения.

Немного другая версия, где мы указываем только тип животного, позволит вам легко фильтровать списки животных, как вам нужно (ценой некоторого сомнительного сравнения строк):

open Microsoft.FSharp.Quotations

type Animal = Pig of string | Cow of string | Fish of string

let isAnimal (animalType : Expr) animal =
    match animalType with
        | Lambda (_, NewUnionCase (aatt, _)) -> animal.ToString().EndsWith(aatt.Name)
        | _ -> false

let animal = Pig "Mike"  // No quote now, so we can process Animal lists easily
isAnimal <@ Pig @> animal  // True
isAnimal <@ Cow @> animal  // False

let animals = [Pig "Mike"; Pig "Sarah"; Fish "Eve"; Cow "Laura"; Pig "John"]
let pigs = animals |> List.filter (isAnimal <@ Pig @>)

Последняя версия на самом деле не лучше, чем передача имени тега в виде строки.

Нет, невозможно передать только тег, чтобы иметь возможность отдельно обрабатывать тег и строку, вы можете определить их следующим образом:

type AnimalType = Pig  | Cow  | Fish
type Animal = Animal of AnimalType * string

let animals = [Animal (Pig, "Mike"); Animal (Pig, "Sarah"); Animal (Fish, "Eve"); Animal (Cow, "Laura"); Animal (Pig, "John")]

let rec filterAnimals animalType animals =
    if animals = [] then
        []
    else
        let rest = filterAnimals animalType (List.tail animals)
        match List.head animals with
        | Animal (x, animal) when x = animalType -> animal::restwork
        |_ -> rest

printfn "%A" (filterAnimals Pig animals)

В качестве альтернативы вы можете использовать только кортеж AnimalType * string

ОБНОВЛЕНИЕ

Что касается вашего вопроса в комментариях о том, что произойдет, если структура не всегда одинакова, вы можете использовать хитрость: вы можете сравнить тип двух размеченных союзов, поскольку каждый тег компилируется в другой подкласс.

type Animal = 
    | Person of string * string 
    | Pig of string 
    | Cow of string 
    | Fish of string

let animals = [Pig "Mike"; Pig "Sarah"; Fish "Eve"; Cow "Laura"; Pig "John"]

let rec filterAnimals animalType animals =
    if animals = [] then
        []
    else
        let rest = filterAnimals animalType (List.tail animals)
        match List.head animals with
        | x when animalType.GetType() = x.GetType() -> x::rest
        |_ -> rest

printfn "%A" (filterAnimals (Pig "") animals)

Но прежде чем пойти по этому пути, вы должны подумать, действительно ли вам нужно моделировать вашу проблему таким образом.

Даже если вы решите использовать эту структуру, я бы предпочел использовать встроенную функцию фильтра, см. Решение, предложенное @polkduran.

Это не отвечает на ваш вопрос напрямую, но предлагает альтернативный способ добиться того, чего вы хотите. Вы можете отфильтровать свой список, используя существующую функцию высокого порядка List.filter и сопоставление с образцом:

let pigs = animals |> List.filter (function |Pig(_)-> true |_->false ) 

Я думаю, что это более идиоматический подход: вы фильтруете свой список, используя шаблон, в этом случае вы фильтруете своих животных, оставляя только тех, кто удовлетворяет шаблону Pig(_).