为区分联合类型实现快速CustomEquality和CustomComparison

2 回答

• 2

  Simple optimization
  您可以轻松做的一个基本优化是，当您只能根据 Coord 的类型做出决定时，可以避免调用 toString . 你可以写下：而不是 Build sortKey

  // Separate functions that return tag and key, so that we don't
  // have to call 'toString' if we can decide based just on the Tag
  member this.Tag = 
      match this with 
      | Spot _ -> 0 | Vol(_, None) -> 1 
      | Vol _ -> 2 | Rate _ -> 3
  member this.Key = 
      match this with 
      | Spot(key) | Vol(key, None) -> key.toString | Rate cur -> cur.toString
      | Vol(key, Some t) -> key.toString + t.ToShortString())  
  
  interface IComparable with  
      member this.CompareTo(obj) =  
          match obj with  
          | :? Coord as other -> 
              let c = compare this.Tag other.Tag
              // Try comparing based on the tag first - if the tags 
              // are the same, then get Key and compare based on the key
              if c <> 0 then c else compare this.Key other.Key
          | _ -> invalidArg "obj" "not a Coord type"
  

  如果要缓存 toString 的结果，则需要使用一些允许存储本地字段的结构 . 我可能会使用一个对象类型（表示为类或简单的结构） .

  Wrapping the type
  在这种情况下，您仍然可以使用活动模式获得良好的模式匹配，但它需要为每个类定义一个活动模式（这可能不是那么糟糕） . 这是一个例子：

  // This type will not be used directly - it is an internal implementation
  // hidden from the users that will be accessed using active patterns
  [<RequiresQualifiedAccess>]
  type AssetKeyInternal =       
    | Equity of string       
    | EquityIndex of string  
    override x.ToString() = ...
  
  // Public type with active patterns for pattern matching
  type AssetKey(key:AssteKeyInternal) = 
    let str = lazy key.ToString() // Lazily cached string
    member x.Key = str.Value      // Evaluated when accessed for the first time
  
    member x.Value = key // Returns the internal representation
  
  // Define active patterns working over AssetKey type
  let (|Equity|EquityIndex|) (k:AssetKey) =
    match k.Value with
    | AssetKeyInternal.Equity(e) -> Equity(e)
    | AssetKeyInternal.EquityIndex(e) -> EquityIndex(e)
  

  给定 AssetKey 类型的值，您现在可以编写 k.Key 来获取缓存的字符串表示形式，并且可以使用活动模式对其进行模式匹配：

  match k with 
  | Equity k -> ...
  | EquityIndex i -> ...
  

  回复于 2024-04-29T08:38:36+08:00
• 1

  你可以考虑做类似的事情

  type CoordRepr =
  | Spot of AssetKey 
  | Vol of AssetKey * DateTime option  
  | Rate of Currency              
  
  let sortKey = function
  | Spot(key) -> 1,key.ToString()
  | Vol(key,None) -> 2,key.ToString()
  | Vol(key,Some(v)) -> 2,key.ToString() + v.ToShortDateString()
  | Rate(key) -> 3,key.ToString()
  
  type Coord(repr) =
      let sortKey = sortKey repr
      member __.Repr = repr
      member __.SortKey = sortKey
      override __.Equals(that) =
          match that with
          | :? Coord as c -> sortKey = c.SortKey
          | _ -> false
      override __.GetHashCode() = sortKey.GetHashCode()
      interface System.IComparable with
          member __.CompareTo(that) =
              match that with
              | :? Coord as c -> compare sortKey c.SortKey
              | _ -> failwith "invalidArg"
  
  let Spot k = Coord(Spot k)
  let Vol(k,v) = Coord(Vol(k,v))
  let Rate(k) = Coord(Rate(k))
  
  let (|Spot|Vol|Rate|) (c:Coord) =
      match c.Repr with
      | Spot k -> Spot k
      | Vol(k,v) -> Vol(k,v)
      | Rate k -> Rate k
  

  然后使用签名文件隐藏 CoordRepr ， Coord 的构造函数， sortKey 等 .

  回复于 2024-04-29T08:38:36+08:00