writing methods in f# - c

Question

I have a question:
There is such a method in C:
inline void ColorSet(int face, int pos,int col)
{
color[face*9+pos]=col;
}
I've tried to write it in F#;
type ColorSet =
member this.ColorSet (face: int, pos: int, col: int) =
color.[face*9+pos] = col
but I encountered with such an error:
The operator 'expr.[idx]' has been used on an object of indeterminate type based on information prior to this program point. Consider adding further type constraints...
Could you help me to write the exact method?

Answer 1

Reading the comments, it seems you may be trying to do this:
let itemCount = 9
let faceCount = 6
let color : int [] = Array.zeroCreate (faceCount * itemCount)
let setColor face pos col =
color.[face * itemCount + pos] <- col
Two things to note:
The object of indeterminate type error can usually be solved with a type annotation: by declaring color as : int [], it is specified that color must be an array of integers
The operator = is a test for equality in F#. To assign to a mutable variable or an array component, use <-.
Usage might look like this:
let red = 0xFFFF0000 // Assuming ARGB (machine endianness)
setColor 0 8 red // Set the last component of the first face to red
Note that this is unusual style for F#. I do use code like this, but only if it is known to be performance critical and the compiler can't optimize it. Normally, you would use a type for color, e.g. System.Drawing.Color for compatibility, and a type for the objects iterated by the face parameter.
Edit Are you storing the colors of 6 faces of dice or cuboids interleaved in an array? Just in case someone is interested, I'll assume that and write how it might look in more typical F#. I don't know if this is relevant, but I guess it can't hurt to add it.
/// A color, represented as an int. Format, from most to least
/// significant byte: alpha, red, green, blue
type Color = Color of int
let black = Color 0xFF000000
let red = Color 0xFFFF0000
type CubeColors =
{ Top : Color; Bottom : Color
Left : Color; Right : Color
Front : Color; Back : Color }
/// Creates CubeColors where all faces have the same color
static member Uniform c =
{ Top=c; Bottom=c; Left=c
Right=c; Front=c; Back=c }
// Make an array with nine completely black cubes
let cubes = Array.create 9 (CubeColors.Uniform black)
// Change the top of the second cube to red
cubes.[1] <- { cubes.[1] with Top = red }
This uses a single-case discriminated union for the Color type and a record for the CubeColors type. This is much safer to use, and often more readable, than doing low-level array stuff.

Answer 2

You should define color somewhere in the class constructor.
For example if color is an array:
type ColorSet() =
let color = Array.zeroCreate 100
member this.ColorSet (face: int, pos: int, col: int) =
color.[face*9+pos] <- col