F# matching records and discriminated unions - f#

Question

I want to use calculateWage function, it gives an error that expected to have Employee type but here has type Person.
type Person =
{ first_name: string
last_name: string
age: int
salary_hour: int }
type Employee =
| Administrator of Person
| OfficeWorker of Person
| WarehouseWorker of Person
let calculateWage (employee:Employee) (hours:int) =
match employee with
| {salary_hour= sh} -> (sh * hours)*TAX/100

Answer 1

You need to match on the discriminated union like so:
let calculateWage (employee:Employee) (hours:int) =
match employee with
| Administrator {salary_hour= sh}
| OfficeWorker {salary_hour= sh}
| WarehouseWorker {salary_hour= sh} -> (sh * hours)*TAX/100
In this case it may seem stupid, but remember that each discriminated union case can have different data.
Often when I end up with data like this I do this in two steps. I have a function that extracts the common data. And a function that works with the data itself:
let extractPerson employee =
match employee with
| Administrator p
| OfficeWorker p
| WarehouseWorker p -> p
let calculateWage person (hours:int) =
(person.salary_hour * hours)*TAX/100
So you end up with some functions that you can easily compose:
let calculate employee =
employee
|> extractPerson
|> calculateWage

Answer 2

I'd go with Tom Moers's answer, but if you are insisting on having the deconstruction of Employee inside the pattern match, you can easily convert it into an active recognizer enclosed by "banana clips":
let (|Employee|) = function
| Administrator p
| OfficeWorker p
| WarehouseWorker p -> p
let calculateWage (employee:Employee) (hours:int) =
match employee with
| Employee{salary_hour= sh} -> (sh * hours)*TAX/100

Answer 3

You need to match on employee to to get the information:
let calculateWage (employee:Employee) (hours:int) =
match employee with
| Administrator person ->
(person.salary_hour * hours)*TAX/100})
| OfficeWorker person -> ...
| WarehouseWorker person -> ...
Alternatively, change calculate wage to accept a Person as argument.
This would be especially useful if all use the same calculation, but need to be wrapped with the DU.
Ive edited this twice, because of an embarassing typo. Tom had the right of it from the start