装饰器模式的功能等效吗？

Question

与装饰器设计模式等效的函数式编程是什么？

例如，您将如何在函数式中编写这个特定示例风格？

Answer 1

在函数式编程中，您可以将给定函数包装在新函数中。

给出一个与您的问题中引用的类似的人为的 Clojure 示例：

我的原始绘图函数：

(defn draw [& args]
  ; do some stuff 
  )

我的函数包装器：

; Add horizontal scrollbar
(defn add-horizontal-scrollbar [draw-fn]
  (fn [& args]
    (draw-horizontal-scrollbar)
    (apply draw-fn args)))


; Add vertical scrollbar
(defn add-vertical-scrollbar [draw-fn]
  (fn [& args]
    (draw-vertical-scrollbar)
    (apply draw-fn args)))

; Add both scrollbars
(defn add-scrollbars [draw-fn]
  (add-vertical-scrollbar (add-horizontal-scrollbar draw-fn)))

这些返回一个新函数，可以在使用原始绘图函数的任何地方使用，但也可以绘制滚动条。

Answer 2

柯里化函数参数/组合是最接近的等价物。然而，即使问这个问题也是错误的，因为模式的存在是为了弥补宿主语言的弱点。

如果 C++/Java/C#/任何其他几乎相同的语言具有内置于该语言中的装饰功能，您不会将其视为一种模式。碰巧的是，“模式”是用于在早期绑定的命令式面向目标语言中构建系统的模式，通常没有自动装箱，并且根类具有相对较薄的协议。

编辑：此外，其中很多都是作为这些语言中的模式进行研究的，因为没有明显的内置高阶函数、高阶类型，并且类型系统相对无用。显然，这不是这些语言的普遍问题，但在这些模式开始编纂时，这些问题就已经存在了。

Answer 3

您可以通过将函数包装在其他函数中来“装饰”函数，通常使用某种形式的高阶函数来执行包装。

Clojure 中的简单示例：

; define a collection with some missing (nil) values
(def nums [1 2 3 4 nil 6 7 nil 9])

; helper higher order function to "wrap" an existing function with an alternative implementation to be used when a certain predicate matches the value
(defn wrap-alternate-handler [pred alternate-f f]
  (fn [x] 
    (if (pred x) 
      (alternate-f x)
      (f x))))

; create a "decorated" increment function that handles nils differently
(def wrapped-inc 
  (wrap-alternate-handler nil? (constantly "Nil found!") inc))

(map wrapped-inc nums)
=> (2 3 4 5 "Nil found!" 7 8 "Nil found!" 10)

该技术在函数库中广泛使用。一个很好的例子是 使用 Ring 中间件包装 Web 请求处理程序 - 链接的示例将 html 请求的参数处理包装在任何现有处理程序周围。

Answer 4

像这样的东西：

class Window w where
    draw :: w -> IO ()
    description :: w -> String

data VerticalScrollingWindow w = VerticalScrollingWindow w

instance Window w => Window (VerticalScrollingWindow w) where
    draw (VerticalScrollingWindow w)
       = draw w >> drawVerticalScrollBar w  -- `drawVerticalScrollBar` defined elsewhere
    description (VerticalScrollingWindow w)
       = description w ++ ", including vertical scrollbars"

Answer 5

在 Haskell 中，这种 OO 模式几乎可以直接翻译，你只需要一本字典。请注意，直接翻译实际上并不是一个好主意。试图将面向对象的概念强加到 Haskell 中是一种隐晦的说法，但你要求它，所以它就在这里。

窗口接口

Haskell 有类，它具有接口的所有功能，甚至还有一些功能。因此，我们将使用以下 Haskell 类：

class Window w where
  draw :: w -> IO ()
  description :: w -> String

抽象 WindowDecorator 类

由于 Haskell 没有继承的概念，因此这个类有点棘手。通常我们根本不会提供这种类型，而是让装饰器直接实现Window，但让我们完全遵循示例。在此示例中，WindowDecorator 是一个带有带有窗口的构造函数的窗口，让我们用提供装饰窗口的函数来扩充它。

class WindowDecorator w where
   decorate :: (Window a) => a -> w a
   unDecorate :: (Window a) => w a -> a
   drawDecorated :: w a -> IO ()
   drawDecorated = draw . unDecorate
   decoratedDescription :: w a -> String
   decoratedDescription = description . unDecorate

instance (WindowDecorator w) => Window w where
   draw = drawDecorated
   description = decoratedDescription

请注意，我们提供了 Window 的默认实现，它可以被替换，并且 WindowDecorator 的所有实例都将是一个 Window。

装饰器

制作装饰器可以按如下方式完成：

data VerticalScrollWindow w = VerticalScrollWindow w

instance WindowDecorator VerticalScrollWindow where
  decorate = VerticalScrollWindow
  unDecorate (VerticalScrollWindow w ) = w
  drawDecorated (VerticalScrollWindow w )  = verticalScrollDraw >> draw w

data HorizontalScrollWindow w = HorizontalScrollWindow w

instance WindowDecorator HorizontalScrollWindow where
  decorate = HorizontalScrollWindow
  unDecorate (HorizontalScrollWindow w .. ) = w
  drawDecorated (HorizontalScrollWindow w ..)  = horizontalScrollDraw >> draw w

完成

最后我们可以定义一些窗口：

data SimpleWindow = SimpleWindow ...

instance Window SimpleWindow where
   draw = simpleDraw
   description = simpleDescription

makeSimpleWindow :: SimpleWindow
makeSimpleWindow = ...

makeSimpleVertical = VerticalScrollWindow . makeSimpleWindow
makeSimpleHorizontal = HorizontalScrollWindow . makeSimpleWindow
makeSimpleBoth = VerticalScrollWindow . HorizontalScrollWindow . makeSimpleWindow

Answer 6

好的，首先让我们尝试找到 OOP 方面装饰器模式的所有主要组件。该模式主要用于装饰，即向现有对象添加附加功能。这是该模式最简单的定义。现在，如果我们尝试在 FP 的世界中找到此定义中存在的相同组件，我们可以说 FP 中不存在附加功能 = 新功能和对象，而是 FP 拥有您想要的东西。调用各种形式的数据或数据结构。因此，用 FP 术语来说，这种模式就变成了为 FP 数据结构添加附加功能或通过一些附加功能增强现有功能。

Answer 7

Clojure 的乐趣 在第 13.3 章“缺乏设计模式”中讨论了这个问题。根据 JoC 的说法，-> ; 和 ->> 宏在某种程度上类似于装饰器模式。

Answer 8

我不是 100% 确定，但我认为 高级函数式编程的 C9 讲座系列很好地解释了这个问题。

除此之外，您可以在 F# 中使用相同的技术（它支持相同的 OO 机制），在这种特殊情况下我会这样做。

我想这是一个品味和你想要解决的问题的问题。

Answer 9

type Window = {Description: string}
type HorizontalScroll = {HPosition: int}
type VerticalScroll = {VPosition: int}
type Feature = 
    | HorizontalScroll of HorizontalScroll
    | VerticalScroll of VerticalScroll

let drawWithFeatures w (f: Feature) = 
    match f with
    | HorizontalScroll h ->  {Description= w.Description + "Horizontal"}
    | VerticalScroll v -> {Description= w.Description + "Vertical"} 

type FeatureTwo = Red of int| Blue of int | Green of int | Feature of Feature
let drawWithMoreFeatures (w: Window) (ft:FeatureTwo)=
        match ft with 
        | Red x     ->  {Description = w.Description + "Red"} 
        | Green x   ->  {Description = w.Description + "Green"} 
        | Blue x    ->  {Description = w.Description + "Blue"}
        | Feature f ->  drawWithFeatures w f

let window = {Description = "Window title"}
let horizontalBar =   HorizontalScroll {HPosition = 10}
let verticalBar =  VerticalScroll {VPosition = 20}

[Red 7; Green 3; Blue 2; Feature horizontalBar; Feature verticalBar] |> List.fold drawWithMoreFeatures window

F# 尝试

这是我尝试在 F# 中创建一些有意义的东西，因为您要求提供很多示例。我有点生疏，所以希望没有人会羞辱我：P。装饰器基本上需要两个部分，新行为和新数据。在函数式语言中，新行为非常容易，因为它们“只是另一个函数”，因为函数本质上与对象解耦。新数据实际上同样简单，有多种方法可以实现这一点，最简单的是元组。您可以看到我创建了一个新数据类型，它是前一个数据类型的超集，并且我已经为该现有行为调用了现有函数。因此，我们的旧数据和旧行为仍然受到尊重，但我们也有新行为和新数据。

Answer 10

下面是一个使用 JSGI（用于 JavaScript 的 Web 服务器 API）的示例：

function Log(app) {
    return function(request) {
         var response = app(request);
         console.log(request.headers.host, request.path, response.status);
         return response;
     };
 }

 var app = Logger(function(request) {
     return {
         status: 200,
         headers: { "Content-Type": "text/plain" },
         body: ["hello world"]
     };
  }

当然，可以堆叠兼容的中间件（例如 Lint(Logger(ContentLength(app)))）