使用Array.Count并匹配大小写F＃

Question

I am not sure yet what the problem is, I am trying to go through a ResizeArray and matching the item with the data type, and depending on this, take away the value in a specific field (iSpace) from thespace(which is how much space the inventory has), before returning the final value.

A snippet of my code :

let spaceleft =
    let mutable count = 0 //used to store the index to get item from array
    let mutable thespace = 60 //the space left in the inventory
    printf "Count: %i \n" inventory.Count //creates an error
    while count < inventory.Count do 
        let item = inventory.[count]
        match item with
            |Weapon weapon ->

                thespace <- (thespace - weapon.iSpace)

            |Bomb bomb ->

                thespace <-(thespace - bomb.iSpace)

            |Potion pot ->

                thespace <- (thespace - pot.iSpace)

            |Armour arm ->

                thespace <- (thespace - arm.iSpace)


        count <- count+1
    thespace

I get an error about Int32, that has to do with the

printf "Count: %i \n" inventory.Count

line

Another problem is that thespace doesn't seem to change, and always returns as 60, although I have checked and inventory is not empty, it always has at least two items, 1 weapon and 1 armour, so thespace should atleast decrease yet it never does. Other snippets that may help:

let inventory = ResizeArray[]

let initialise  = 
    let mutable listr = roominit
    let mutable curroom = 3
    let mutable dead = false
    inventory.Add(Weapon weap1)
    inventory.Add(Armour a1)
    let spacetogo = spaceleft //returns 60, although it should not

Also, apart from the iniitialise function, other functions seem not to be able to add items to the inventory properly, eg:

let ok, input = Int32.TryParse(Console.ReadLine())

match ok with
    |false ->
        printf "The weapon was left here \n"
        complete <- false
    |true ->
        if input = 1 && spaceleft>= a.iSpace then
            inventory.Add(Weapon a)
            printf "\n %s added to the inventory \n" a.name
            complete <- true
        else
            printf "\n The weapon was left here \n"
            complete <- false
complete

Answer 1

You have spaceLeft as a constant value. To make it a function you need to add unit () as a parameter. Here's that change including a modification to make it much simpler (I've included my dummy types):

type X = { iSpace : int }
type Item = Weapon of X | Bomb of X | Potion of X | Armour of X
let inventory = ResizeArray [ Weapon {iSpace = 2}; Bomb {iSpace = 3} ]

let spaceleft () =
    let mutable thespace = 60 //the space left in the inventory
    printf "Count: %i \n" inventory.Count
    for item in inventory do
        let itemSpace =
            match item with
            | Weapon w -> w.iSpace
            | Bomb b -> b.iSpace
            | Potion p -> p.iSpace
            | Armour a -> a.iSpace
        thespace <- thespace - itemSpace
    thespace

spaceleft () // 55

The above code is quite imperative. If you want to make it more functional (and simpler still) you can use Seq.sumBy :

let spaceleft_functional () =
    printf "Count: %i \n" inventory.Count
    let spaceUsed =
        inventory
        |> Seq.sumBy (function
            | Weapon w -> w.iSpace
            | Bomb b -> b.iSpace
            | Potion p -> p.iSpace
            | Armour a -> a.iSpace)
    60 - spaceUsed

Answer 2

Just adding to the accepted answer: you can also match against record labels, as long as your inner types are records. Combine with an intrinsic type extension on the outer DU:

type X = { iSpace : int }
type Y = { iSpace : int }
type Item = Weapon of X | Bomb of Y | Potion of X | Armour of X
let inventory = ResizeArray [ Weapon {iSpace = 2}; Bomb {iSpace = 3} ]

let itemSpace = function
| Weapon { iSpace = s } | Bomb { iSpace = s }
| Potion { iSpace = s } | Armour { iSpace = s } -> s
type Item with static member (+) (a, b) = a + itemSpace b

60 - (Seq.fold (+) 0 inventory)
// val it : int = 55

Otherwise, you could resort to member constraint invocation expressions.

let inline space (x : ^t) = (^t : (member iSpace : int) (x))