“具体化”是什么？和“具体化”在（函数式？）编程的上下文中意味着什么？

Question

我在有关 haskell 和函数式编程的博客中读过很多这个术语（特别是在 sigfpe 的博客 中），但我不知道了解它的含义。大多数时候我都不知道，但如果我知道的话，我可能会更好地理解这些文本。谷歌没有帮助我。我迷失在技术方面。

此外，世界的非技术意义（“将抽象具体化”）并不能帮助我理解在代码中具体化某些内容的实际含义。

我对计算机科学概念的理解有点慢，所以带有代码的实际示例会很好。 ：P

Answer 1

所以我读了这篇文章，这几乎就是它的意思：采用抽象概念并将其具体化。或者，有一个代表抽象概念的代理。例如，在 Lisp 中，当您使用 lambda 时，过程抽象和应用的概念就会具体化。

具体化本身是一个广泛的概念，不仅仅适用于函数式编程语言。

例如，在 Java 中，有些类型在运行时可用。这些是可具体化的类型。这意味着，在运行时存在类型抽象概念的具体表示。相反，存在不可具体化的类型。这在 Java 中使用泛型时尤其明显。在 Java 中，泛型会发生类型擦除，因此泛型类型信息在运行时不可用（除非参数化类型使用无界通配符）。

另一个例子是当你尝试对一个概念建模时。例如，假设您有一个 Group 类和一个 User 类。现在有一些抽象的概念来描述两者之间的关系。例如，User 的抽象概念是Group 的成员。为了使这种关系具体化，您可以编写一个名为 isMemberOf 的方法，用于说明 User 是否是 Group 的成员。因此，您在这里所做的就是将群组成员身份的抽象概念具体化（变得真实/明确/具体）。

另一个很好的例子是一个数据库，其中对象之间具有父子关系。您可以用树的抽象概念来描述这种关系。现在假设您有一个函数/方法从数据库中获取这些数据并构造一个实际 Tree 对象。您现在所做的是将父子树状关系的抽象概念具体化为一个实际 Tree 对象。

回到一般的函数式语言，具体化的最好例子也许就是 Lisp 编程语言本身的创建。 Lisp 是一个完全抽象的理论结构（基本上只是计算机语言的数学符号）。这种情况一直持续到 Steve Russel 在 IBM 704 上实际实现 Lisp 的 eval 函数为止：

根据 Paul Graham 在 Hackers & 中的报道画家，p。 185、麦卡锡说：“史蒂夫·拉塞尔说，看，我为什么不编写这个评估......，我对他说，嗬，嗬，你把理论与实践混淆了，这个评估是为了阅读，而不是为了阅读。”但他继续这样做了，那就是，他将我论文中的 eval 编译成 IBM 704 机器代码，修复了 bug，然后将其宣传为 Lisp 解释器，而在那时 Lisp 确实做到了。本质上就是它今天的形式……”

因此，Lisp 从一个抽象概念具体化，变成了一种实际的编程语言。

Answer 2

具体化

具体化是实例化的一种形式。当您具体化一个概念时，您会将抽象的东西变得具体，就像您提供的字典定义一样。

您可以选择将类型具体化为居住在某些可能类型的抽象语法树中的术语。

您可以通过为某种语言提出通用的实现来具体化设计模式。例如，类似

template<typename T> class Singleton {
    public:
        static T& Instance() {
            static T me;
            return me;
        }

    protected:
       virtual ~Singleton() {};
       Singleton() {};
}

将单例设计模式具体化为 C++ 中的模板。

您可以将霍尔的快速排序思想具体化为您选择的编程语言的实现。本着这种精神，我花了很多时间将范畴论中的概念具体化为 Haskell 代码。

您可以将一种语言具体化为该语言的解释器。 Larry Wall 对 Perl 语言的想法被具体化为 Perl 解释器。

data-reify 和 vacuum 包将术语具体化为图表，表示它如何通过共享在内存中构建。

反思

具体化的另一面是反思，它采用具体的东西，并通常通过忘记一些细节来生成抽象。也许您想这样做是因为抽象更简单，或者以某种方式捕获了您所讨论内容的本质。

Java、C# 等中的类型系统反射采用编程语言中的具体类，并为您提供类的抽象结构，使您可以访问类提供的成员列表。在这里，我们采用类型的具体概念，并从中生成一个描述其结构的抽象术语，同时丢弃任何特定值。

就像如何将编程语言具体化为实现一样，有时您可能会走向相反的方向。尽管这通常被认为是一个坏主意，但您可能会采取一种实现并尝试从其行为的所需属性反映语言规范。 TeX 首先由 Knuth 实现，没有规范。 TeX 的任何规范都已从 Knuth 的实现中反映出来。

如果您将反射视为一个健忘的函子，它将您从具体领域带到抽象领域，那么理想情况下，具体化是左伴随反射。）

（更正式地说， 我维护的 /package/reflection" rel="noreferrer">reflection 包提供了一个 reify 方法，它接受一个术语并生成一个表示它的类型，然后是一个 Reflect 方法，让您生成一个新术语。这里的“具体”域是类型系统，抽象域是术语。

Answer 3

来自 Haskell Wiki：

“具体化”某物就是采取
抽象和尊重的东西
它作为材料。一个经典的例子是
古人采取的方式
抽象概念（例如“胜利”）和
将他们变成神（例如耐克，
希腊胜利女神）。

具体化类型是一个值
代表一种类型。使用具体化类型
而不是真正的类型意味着你
可以对它们进行任何操作
你可以用价值观来做到这一点。

Answer 4

我能想到的一个用途（我确信还有其他用途！）是将类变成字典。让我们以 Eq 类为例（暂时忘记 /= 运算符）：

class Eq a where
    (==) :: a -> a -> Bool

如果我们具体化这个类，它就变成：

data EqDict a = EqDict (a -> a -> Bool)

可以构造、检查等等。另外值得注意的是，每种类型只能有一个 Eq 实例，但可以有多个 EqDict 值。但是实例的自动构造（例如，当您拥有元素时获得列表的相等性）不起作用；您必须自己构造 EqDict [a] 值。

具体化过程就像这样简单（对于本例）：

reify :: Eq a => EqDict a
reify = EqDict (==)

使用 Eq 类的函数可以转换如下内容：

-- silly example, doesn't really do anything
findMatches :: Eq a => a -> [a] -> [a]
findMatches x ys = [ y | y <- ys, x == y ]

-- version using EqDict
findMatchesDict :: EqDict a -> a -> [a] -> [a]
findMatchesDict (EqDict f) x ys = [ y | y <- ys, f x y ]

如果您打开 EqDict 并只传递一个 a ->;一个-> Bool，您将获得 ..By 函数，例如 Data.List.nubBy 和朋友 - 与 Ord 类似的技巧> 通向 Data.List.sortBy。

Answer 5

即使仅在 Haskell 的上下文中，该术语的使用也非常广泛。 Andy Gill 的 reify 包允许您采用递归结构并将它们转换为显式图。 Sigpfe 关于延续的帖子描述了将“计算的其余部分”的概念具体化为可以传递的值。 Template Haskell 有一个 reify 函数（通常在编译时与 TH 代码一起执行），当给定 Haskell 值的名称时，该函数返回有关该值的可用信息（声明位置、类型等）。

所有这些案例有什么共同点？他们谈论的是采用一些我们可以推理和知道但我们无法直接以编程方式操作的东西，并将其转变为我们可以像其他值一样命名和传递的实际一流值。这通常是人们使用这个词时想要传达的意图。

Answer 6

我知道RDF中有具体化的概念。正如 Tim Bernes-Lee Tim Bernes-Lee 所说：

在这种情况下，具体化意味着使用该语言以某种语言表达某些事物，以便该语言可以处理该事物。

我想这有点像反思或内省。我希望你在这里得到一些好的答案！