Это шаблоны на производные типы идиоматических для F#?

- это шаблон соответствия на производные типы идиоматических для F#?

Я бы сказал нет, потому что у вас есть основное заблуждение, что код с типами в иерархии объектов является идиоматическим F#.

Я не считаю иерархии объектов типов, чтобы быть идиоматические F# или функциональной. Так что вопрос является недопустимым. Я рассматриваю историческую перспективу с F#, исходящей от ML и OCaml, в отличие от исходящей со стороны OO. Как я всегда советую при работе с функциональным кодом, забудьте о том, что вы знаете О, как это только приведет вас на путь заблуждения. Если вы должны взаимодействовать с ОО, то вам придется укусить пулю, но оставить ОО, когда это возможно.

Предназначены ли классы и наследование для использования в F#?
Или они просто для совместимости с .Net?

Если вы посмотрите на статью MSDN о классах F# в разделе When to Use Classes, Unions, Records, and Structures вы увидите

Учитывая разнообразие типов на выбор, вы должны иметь хороший понимание того, для чего каждый тип предназначен для выбора подходящий тип для конкретной ситуации. Классы предназначены для используется в контекстах объектно-ориентированного программирования. Объектно-ориентированный программирование является доминирующей парадигмой, используемой в приложениях, которые написано для платформы .NET Framework. Если ваш F# код должен работать в тесном контакте с помощью .NET Framework или другой объектно-ориентированной библиотеки, а также особенно, если вам приходится расширяться из объектно-ориентированной системы типов например, библиотека пользовательского интерфейса, занятия, вероятно, уместны.

Если вы не тесно взаимодействуете с объектно-ориентированным кодом, или если вы пишете код, который является автономным и поэтому защищенным из-за частого взаимодействия с объектно-ориентированным кодом вы должны рассмотрите возможность использования записей и дискриминируемых союзов. Один, хорошо продуманный дискриминируемый союз, вместе с соответствующим шаблоном соответствующий код часто может использоваться в качестве более простой альтернативы объекту иерархия. За дополнительной информацией о дискриминируемых профсоюзах см. Дискриминируемые Союзы (F#).

.

Должен ли я использовать записи вместо этого, и если да, то как?

Сначала не используйте дискриминированное объединение, а затем, если данные становятся более сложными, взгляните на записи. В некоторых ситуациях я часто использую записи, но в большинстве случаев этого не делаю. Это вопрос it depends.

Записи имеют то преимущество, что они проще классов, но записи не уместны, когда требования тип превышают то, что может быть выполненный с их простотой. Записи в основном просты агрегаты значений, без отдельных конструкторов, которые могут выполнять настраиваемые действия, без скрытых полей, без наследования или реализация интерфейса. Хотя такие члены, как свойства и методы могут быть добавлены к записям, чтобы сделать их поведение более сложным, поля, хранящиеся в записи, по-прежнему представляют собой простую совокупность значений. Дополнительные сведения о записях см. В разделе записи (Ф#).

Структуры также полезны для небольших агрегатов данных, но они отличается от классов и записей тем, что они являются типами значений .NET. Классы и записи являются ссылочными типами .NET. Семантика значения типы и ссылочные типы отличаются тем, что передаются типы значений по значению. Это означает, что они копируются бит за битом, когда они передается как параметр или возвращается из функции. Они также являются хранятся в стеке или, если они используются в качестве поля, встроенный внутрь родительский объект вместо того, чтобы храниться в их собственном отдельном месте на куча. Таким образом, структуры подходят для часто доступ к данным, когда накладные расходы на доступ к куче являются проблемой. Дополнительные сведения о структурах см. В разделе структуры (F#).

.

Переключение типов считается плохой практикой в C#. Это то же самое для F#?

Смотрите ответ на Is pattern matching on derived types idiomatic for F#?

Как?

namespace Game

type Location = int * int
type TargetLocation = Location
type CurrentLocation = Location
type Symbol = char
type ActorType = CurrentLocation * Symbol
type HitPoints = int
type Health = int
type Money = int
type Creature = ActorType * HitPoints

// Player = Creature * Health * Money
//        = (ActorType * HitPoints) * Health * Money
//        = ((CurrentLocation * Symbol) * HitPoints) * Health * Money
//        = ((Location * Symbol) * HitPoints) * Health * Money
//        = (((int * int) * char) * int) * int * int
type Player = Creature * Health * Money 

type Actor =
    | Medication of ActorType
    | Coin of ActorType
    | Arrow of Creature * TargetLocation    // Had to give arrow hit point damage
    | Zombie of Creature * TargetLocation

module main =

    [<EntryPoint>]
    let main argv = 

        let player = ((((0,0),'p'),15),0,0)  

        let actors : Actor List = 
            [
                 Medication((0,0),'♥'); 
                 Zombie((((3,2),'Z'),3),(0,0)); 
                 Zombie((((5,1),'Z'),3),(0,0)); 
                 Arrow((((4,3),'/'),3),(2,1));
                 Coin((4,2),'$'); 
            ]

        let updatePlayer player (actors : Actor list) : Player =
            let interact (((((x,y),symbol),hitPoints),health,money) : Player) otherActor = 
                match (x,y),otherActor with
                | (playerX,playerY),Zombie((((opponentX,opponentY),symbol),zombieHitPoints),targetLocation) when playerX = opponentX && playerY = opponentY -> 
                    printfn "Player is hit by creature for %i hit points." zombieHitPoints
                    ((((x,y),symbol),hitPoints - zombieHitPoints),health,money)
                | (playerX,playerY),Arrow((((opponentX,opponentY),symbol),arrowHitPoints),targetLocation)  when playerX = opponentX && playerY = opponentY ->  
                    printfn "Player is hit by arrow for %i hit points." arrowHitPoints
                    ((((x,y),symbol),hitPoints - arrowHitPoints),health,money)
                | (playerX,playerY),Coin((opponentX,opponentY),symbol)  when playerX = opponentX && playerY = opponentY ->  
                    printfn "Player got 1$." 
                    ((((x,y),symbol),hitPoints),health,money + 1)
                | (playerX,playerY),Medication((opponentX,opponentY),symbol)  when playerX = opponentX && playerY = opponentY ->  
                    printfn "Player is healed by 1."
                    ((((x,y),symbol),hitPoints),health+1,money)
                | _ ->  
                    // When we use guards in matching, i.e. when clause, F# requires a _ match 
                    ((((x,y),symbol),hitPoints),health,money) 
            let rec updatePlayerInner player actors =
                match actors with
                | actor::t ->
                    let player = interact player actor
                    updatePlayerInner player t
                | [] -> player
            updatePlayerInner player actors

        let rec play player actors =
            let player = updatePlayer player actors
            play player actors

        // Since this is example code the following line will cause a stack overflow.
        // I put it in as an example function to demonstrate how the code can be used.
        // play player actors

        // Test

        let testActors : Actor List = 
            [
                Zombie((((0,0),'Z'),3),(0,0))
                Arrow((((0,0),'/'),3),(2,1))
                Coin((0,0),'$')
                Medication((0,0),'♥')
            ]

        let updatedPlayer = updatePlayer player testActors

        printf "Press any key to exit: "
        System.Console.ReadKey() |> ignore
        printfn ""

        0 // return an integer exit code

С тех пор это не полная игра, я сделал несколько тестов, чтобы показать основы взаимодействия игрока с другими актерами.

Player is hit by creature for 3 hit points.
Player is hit by arrow for 3 hit points.
Player got 1$.
Player is healed by 1.

Если у вас есть конкретные вопросы о том, как это работает, пожалуйста, задайте новый вопрос и вернитесь к этому вопросу. Надеюсь, люди из ОО поймут, почему те из нас, кто перешел на функциональное программирование, наслаждаются им и почему у вас не должно быть никаких мыслей ОО в вашем уме, когда вы делаете функциональный код с нуля. Опять же, если вы взаимодействуете с другими ОО код тогда иметь ОО мысли-это прекрасно.