Serializing and deserializing f# functions is not supported

Today i tried to do make a model something like this

[<CLIMutable>]
type Product =
    {
        Id: int
        Name: string
        //PrinterKey: Expression<Func<Item,obj>>
        ImposerKey: obj -> obj
    }

When i deserialized it from database, below exception was thrown

Newtonsoft.Json.JsonSerializationException: 'Could not create an instance of type Microsoft.FSharp.Core.FSharpFunc`2[System.Object,System.Object]. Type is an interface or abstract class and cannot be instantiated. Path 'Products[0].ImposerKey', line 1, position 133.'

[Zaid-Ajaj]

I am assuming you solved your issue, if it happened to be the case that you still need to serialize or deserialize functions, then just use a byte[] as the data format to store the function with FsPickler for converting between the bytes and functions. This way you don’t need to integrate FsPickler with this library internally

[Zaid-Ajaj]

Your business logic should be in your code, not in your storage system. The only reason you would store arbitrary filters inside the database, is to be able to update them by hand (without the application) which I don’t think you actually want.

You would put this kind of logic in place where you are reading the values from the database in a where query:

// order that contains any item with "CROSS DOCK" is invalid 
let orderHasInvalidItems (order : Order) = 
  Seq.forall (fun item -> item.Art.Contains("CROSS DOCK")) order.Items) 

// get all products of which the orders are valid (their items do not contain "CROSS DOCK") 
let getActiveProducts (db: ILiteDatabase) = 
  let products = db.GetCollection<Product> "products"
  products.where 
      <@ fun prod -> prod.Orders @> 
      (fun orders -> Seq.forall (fun order -> not (orderHasInvalidItems  order) orders) 

otherwise if you really needed to store F# filters, I suggest you use a simple embedded DSL that you can serialize to the database (then you will be doing what LiteDB is doing for you now):

type FilterExpr = 
  | NoFilter 
  | Equals of propName:string * value:obj 
  | LessThan of propName:string * value:float 
  | GreaterThan of propName:string * value:float 
  | Contains of propName:string * value:string 
  | And of left:FilterExpr * right:FilterExpr 
  | Or of left:FilterExpr * right:FilterExpr  
  | Not of expr:FilterExpr 
  | NestedFilter of propName:string * filter:FilterExpr 

You will also need to evaulate the expr yourself against dynamic record values from the database