对F＃记录的限制？

Question

I prefer records to classes in F# because I do not need to implement equality and hash-codes. However, they do not seem to provide a facility for ensuring invariants across the records values.

For example, suppose I am modelling a sudoku board. I might write a record type like this:

type Sudoku = { Values : Map<(int * int), int> }

let empty = { Values = Map.empty }

Now the problem is that I have some requirements on the Values map:

• Every key (x, y) must have x and y be between 0 and 8, inclusive
• Every value must be between 1 and 9, inclusive
• Every value must be unique across a row
• Every value must be unique across a column
• Every value must be unique inside a 3x3 cell

With a type, I could check these in the constructor and raise an exception if they are not met. That way, any code that uses a Sudoku is guaranteeed by the constructor that the invariants are met.

How might I achieve this with a record?

Answer 1

I would do this by creating single-case union types for the keys and values, giving those types private constructors:

[<Struct>] type SudokoKey = private SudokoKey of int
[<Struct>] type SudokoValue = private SudokoValue of int

Then, I would create record types for the cells and the board, again, giving the types private constructors:

type SudokoCell =
    private {
        X: SudokoKey
        Y: SudokoKey
    }

type SudokoBoard =
    private {
        Cells: Map<SudokoCell, SudokoValue>
    }

With the data types defined, I would create discriminated union with the different failure cases you've outlined:

type SudokoError =
| KeyOutOfRange of int
| ValueOutOfRange of int
| ValuesNotUniqueAcrossRow of Map<(int * int), int>
| ValuesNotUniqueAcrossColumn of Map<(int * int), int>
| ValuesNotUniqueIn3x3Cell of Map<(int * int), int>

Next, I would create modules for creating the keys and the values that perform the validations return a Result with either the key/value or the appropriate error. These modules would use the private constructors to instantiate the single-case union type:

module SudokoKey =
    let create key =
        if key < 0 || key > 8
        then Error <| KeyOutOfRange key
        else Ok <| SudokoKey key

    let value (SudokoKey key) = key

module SudokoValue =
    let create value =
        if value < 1 || value > 9
        then Error <| ValueOutOfRange value
        else Ok <| SudokoValue value

    let value (SudokoValue value) = value

Then I'd create a similar module for SudokoCell that uses the SudokoKey.create function applied over x and y integers, and the private constructor of the cell type, to create a Result with either the cell or the appropriate error:

module SudokoCell =
    let create (x,y) =
        x |> SudokoKey.create 
          |> Result.bind (fun xKey -> 
            y |> SudokoKey.create
              |> Result.bind (fun yKey -> 
                Ok { X = xKey; Y = yKey }))

Finally, you'd just need a SudokoBoard module to create the board itself, applying the remaining validation rules over the map. I've stubbed this out, but left the implementation as an exercise:

module SudokoBoard =
    // Map<(int * int), int> -> SudokoBoard
    let create cells =
        // Implementation of validations for board left as exercise

With this in place, you have a descriptive model of the Sudoko board that validates all of the values, prevents creation of an illegal key, value, cell, or board, and always returns an informative error if an invalid value is used.

Answer 2

https://stackoverflow.com/a/13925632/2314532 may have an answer to this: you can write something like the following:

type Sudoku = private { _values : Map<(int * int), int> } with
    member public this.Values = this._values
    static member public Create (values : Map<(int * int), int>) =
        // Do your constraint checking here
        { _values = values }

Note that I have not tested this myself, so if you find that this doesn't work, please post a comment with what you learn.