是否可以在 F# 中引用推断类型或提取函数参数类型？

Question

对于上下文，我正在使用https://fsharpforfunandprofit.com/posts/dependency-injection-1/ 中概述的部分依赖注入模式。

如果我想将一个函数传递给另一个函数（比如在 DI 的组合根中），能够为 FSharp 类型引擎提供一些关于我正在尝试做什么的提示会很有用，否则它有点爆炸成无用的混乱，直到一切正常。 为此，我想参考“现有函数的部分应用版本的类型”

例如，假设我有设置

let _getUser logger db userId =
  logger.log("getting user")
  User.fromDB (db.get userId)

let _emailUserId sendEmail getUser emailContents userId =
  let user = getUser userId
  do sendEmail emailContents user.email

// composition root
let emailUserId =
  let db = Db()
  let logger = Logger()
  let sendEmail = EmailService.sendEmail
  let getUser = _getUser logger db
  _emailUserId sendEmail getUser

我想为 _emailUserId 提供类型提示

let _emailUserId
  // fake syntax. is this possible?
  (sendEmail: typeof<EmailService.sendEmail>)
  // obviously fake syntax, but do I have any way of defining
  // `type partially_applied = ???` ?
  (getUser: partially_applied<2, typeof<_getUser>>)
  emailContents userId
  = 
  ...

因为否则在编写 _emailUserId 时我的 IDE 提供的帮助很少。

问题

（显式添加是因为将其隐藏在代码块中有点误导）。

F# 的类型系统是否允许以任何方式引用或构建现有的推断类型？

如type t = typeof<some inferred function without a manually written type signature>

F# 的类型系统可以让我表达一个部分应用的函数，而无需手动编写它的参数类型吗？

例如type partial1<'a when 'a is 'x -> 'y -> 'z> = 'y -> 'z>，也许像partial1<typeof<some ineferred function without a manually written signature>一样使用？

虽然我仍然很感谢对我使用的模式的反馈，但这不是核心问题，只是上下文。在我看来，这个问题非常普遍地适用于 F# 开发。

我发现得到我想要的东西的唯一方法是硬编码完整的函数类型：

let _emailUserId
  (sendEmail: string -> string -> Result)
  (getUser: string -> User)
  emailContents userId
  = 
  ...

这会导致重复签名，很大程度上抵消了 F# 强大推理系统的优势，并且在将此模式扩展到玩具 StackOverflow 示例之外时很难维护。

令我惊讶的是，这是不明显或不受支持的——我使用丰富类型系统的另一个经验是 Typescript，在许多情况下，使用内置语法很容易做到这一点。

Answer 1

您可以定义类型别名，它们基本上是现有类型的新名称：

type SendMail = string -> string -> Result
type GetUser = string -> User

您可以在任何您想要/需要向编译器提供类型提示的地方使用它们，但它们不会是新类型或子类型，编译器本身仍会推断原始类型。您可以为任何类型定义它们；上面的那些用于函数签名，因为那是您的示例，但它们也可以用于记录类型或 .NET 类。

对于函数参数，您可以像这样使用它们：

let _emailUserId (sendMail : SendMail) (getUser : GetUser) emailContents userId =
/* .... */

Answer 2

在 F# 中，创建简单类型非常容易。随后，代替原始类型，如字符串、整数等，通常最好构建一个由记录/可区分联合组成的“树”，并且只将原始类型保留在最底部。在您的示例中，我认为我只会将单个函数记录传递给“组合根”，例如我会按照这些思路做一些事情：

type User =
    {
        userId : int
        userName : string
        // add more here
    }

type EmailAttachment =
    {
        name : string
        // add more to describe email attachment, like type, binary content, etc...
    }

type Email =
    {
        address : string
        subject : string option
        content : string
        attachments : list<EmailAttachment>
    }

type EmailReason =
    | LicenseExpired
    | OverTheLimit
    // add whatever is needed


type EmailResult =
    | Sucess
    | Error of string

type EmailProcessorInfo =
    {
        getUser : string -> User
        getEmail : EmailReason -> User -> Email
        sendMail : Email -> EmailResult
    }

type EmailProcessor (info : EmailProcessorInfo) =
    let sendEmailToUserIdImpl userId reason =
        info.getUser userId
        |> info.getEmail reason
        |> info.sendMail

    member p.sendEmailToUserId = sendEmailToUserIdImpl
    // add more members if needed.

EmailProcessor 是您的_emailUserId。请注意，我将|> 上一个计算的结果传递给sendEmailToUserIdImpl 中的下一个。这就解释了签名的选择。

您不必创建EmailProcessor 类，事实上，如果它只有一个成员，那么最好将其保留为函数，例如

let sendEmailToUserIdImpl (info : EmailProcessorInfo) userId reason =
    info.getUser userId
    |> info.getEmail reason
    |> info.sendMail

但是，如果最终确实有多个基于同一 info 的成员，那么使用该类会有一些好处。

作为最后一点。您在问题中使用的参考资料很棒，我经常在遇到问题时参考它。它涵盖了很多边缘情况，并展示了不同的变体来做类似的事情。但是，如果您刚刚开始学习 F#，那么其中的一些概念可能很难理解，甚至对于简单的情况（例如您考虑的情况）来说甚至不需要。一个简单的选项类型可能足以区分您可以/不能创建某个对象的情况，因此可以避免使用完全成熟的计算表达式ResultBuilder。由于没有空值（如果设计得当）、异常数量少得多、广泛的模式匹配等等，F# 中实际上并不需要大量的日志记录（这在 C# 中基本上是必须的）。