Add an "abstract" method to (an F#) record - f#

Question

I have created the following record in an attempt to translate a C# class to F#:
type Days = Days of int
type Value = Value of int
type Item = {
Name: string
Expires: Days
Value: Value
}
Thing is I also need every Item to have a... "way", to run another function, yet not defined, handleDevalue, which acts on the item itself to manipulate the item's Value value.
The handleDevalue function is dependent on the Expires property of the item and thus each item's implementation of it would be different, with the only common thread being the function's name and signature (Item -> Item).
On the C# code I'm translating this method was defined as abstract on the Item class and overriden on every item instantiated (where every item is a subclass inheriting from Item).
What I've tried, unsuccessfully till now:
Add an abstract method on the record: ...} with abstract handleDevalue: Item -> Item.
1.1 Reason for failure: IDE tells me "abstract can't be added here as an augmentation" (or something close to the same effect). (I'm not F#-savvy enough to even know what it means, but the compiler won't let it compile so... no).
Add handleDevalue as a function on the record: {... HandleDevalue: Item -> Item...}.
2.1. Reason for failure: this function is dependent on the Expires property. Apparently a record's fields are mutually independent of each other, and besides... how will the function "know" which item to act on (it's supposed to act on the item itself)? The this keyword is not allowed when implementing a function when "instantiating" a record (i.e. no {...handleDevalue = fun this -> <some implementation code here>).
I could remember to define the function on every item I create (I should anyway), but that's not using the type system to my advantage.
I want the compiler to force me to implement the function and remind me if I don't.
With these ways failing I'm out of ideas how to move forward.
Thanks for any advice in advance.

Answer 1

I'm not really sure what you are trying to accomplish here, but I'll give it a shot.
Why not do something similar to this, using a discriminated union instead of inheritance?
type Days = Days of int
type Value = Value of int
type Item = {
name: string
expires: Days
value: Value
}
type ItemType =
| FooItem of Item
| BarItem of Item
| BazItem of Item
// ...
let deValue item =
match item with
| FooItem i ->
{
name = i.name
expires = i.expires -1
value = i.value -1
} |> FooItem
| BarItem i ->
{
name = i.name
expires = i.expires -1
value = i.value -10
} |> BarItem
| // etc

Answer 2

Think about what actually happens in the C# program.
You have several different implementations of handleDevalue, and every item instance has one of those implementations associated with it. But what determines which one goes with which item? Well, this is determined by the specific descendant class that the item is. Ok, but what determines which descendant class gets instantiated?
Somewhere, at some point, there must be a place that picks a descendant class somehow. Let's assume it looks something like this:
class Item { public abstract int handleDevalue() { ... } }
class FooItem : Item { public override int handleDevalue() { ... } }
class BarItem : Item { public override int handleDevalue() { ... } }
public Item createItem(string name, Days expires, Value value) {
if (foo) return new FooItem(name, expires, value)
else return BarItem(name, expires, value)
}
So, look what's happening: ultimately, whoever creates the items is choosing which handleDevalue implementation ends up being used, and then that implementation gets attached to the item instance via the method table.
Now that we know this, we can do the same thing in F#. We'd just need to make attaching of the implementation explicit:
type Item = {
Name : string
Expires : Days
Value : Value
handleDevalue : Item -> Item
}
let handleDevalueFoo item = ...
let handleDevalueBar item = ...
let createItem name expires value = {
Name = name
Expires = expires
Value = value
handleDevalue = if foo then handleDevalueFoo else handleDevalueBar
}