函数式编程 模式

This article targets an audience that’s graduating from functional libraries like ramda to using Algebraic Data Types. We’re using the excellent crocks library for our ADTs and helpers, although these concepts may apply to other ones as well. We’ll be focusing on demonstrating practical applications and patterns without delving into a lot of theory.

本文面向从ramda类的功能库毕业到使用代数数据类型的ramda 。 我们正在为ADT和辅助程序使用出色的crocks库，尽管这些概念也可能适用于其他概念。 我们将专注于演示实际的应用程序和模式，而无需深入研究很多理论。

安全执行危险功能 (Safely Executing Dangerous Functions)

Let’s say we have a situation where we want to use a function called darken from a third-party library. darken takes a multiplier, a color and returns a darker shade of that color.

假设有一种情况，我们想使用第三方库中的称为darken函数。 darken需要乘数，一种颜色并返回该颜色的较深阴影。

// darken :: Number -> String -> String
darken(0.1)("gray")
//=> "#343434"

Pretty handy for our CSS needs. But it turns out that the function is not as innocent as it seems. darken throws errors when it receives unexpected arguments!

非常方便满足我们CSS需求。 但事实证明，该功能并不像看起来那样简单。 当它收到意外的参数时， darken会引发错误！

darken(0.1)(null)
=> // Error: Passed an incorrect argument to a color function, please pass a string representation of a color.

This is, of course, very helpful for debugging — but we wouldn’t want our application to blow up just because we couldn’t derive a color. Here’s where tryCatch comes to the rescue.

当然，这对于调试非常有帮助-但我们不希望仅由于无法派生颜色而使应用程序崩溃。 这是tryCatch进行救援的地方。

import { darken } from "polished"
import { tryCatch, compose, either, constant, identity, curry } from "crocks"// safeDarken :: Number -> String -> String
const safeDarken = curry(n =>compose(either(constant("inherit"), identity),tryCatch(darken(n)))
)

tryCatch executes the provided function within a try-catch block and returns a Sum Type called Result. In its essence, a Sum Type is basically an “or” type. This means that the Result could be either an Ok if an operation is successful or an Error in case of failures. Other examples of Sum Types include Maybe, Either, Async and so on. The either point-free helper breaks the value out of the Result box, and returns the CSS default inherit if things went south or the darkened color if everything went well.

tryCatch在try-catch块中执行提供的功能，并返回一个称为Result的Sum Type。 本质上，Sum类型基本上是“或”类型。 这意味着该Result可能是任一种Ok是否操作成功或 Error的故障的情况下。 Sum类型的其他示例包括Maybe ， Either ， Async等。 either点辅助程序都将值从Result框中分解出来，如果一切向南，则返回CSS默认inherit如果一切顺利，则返回暗色。

safeDarken(0.5)(null)
//=> inheritsafeDarken(0.25)('green')
//=> '#004d00'

使用Maybe Helpers强制类型 (Enforcing Types using Maybe Helpers)

With JavaScript, we often run into cases where our functions explode because we’re expecting a particular data type, but we receive a different one instead. crocks provides the safe, safeAfter and safeLift functions that allow us to execute code more predictably by using the Maybe type. Let’s look at a way to convert camelCased strings into Title Case.

使用JavaScript，我们经常会遇到函数爆炸的情况，因为我们期望的是一种特定的数据类型，但是却收到了另一种数据类型。 crocks提供safe ， safeAfter和safeLift功能，使我们能够使用更多的可预见的执行代码Maybe类型。 让我们看看一种将驼峰式字符串转换为Title Case的方法。

import { safeAfter, safeLift, isArray, isString, map, compose, option } from "crocks"// match :: Regex -> String -> Maybe [String]
const match = regex => safeAfter(isArray, str => str.match(regex))// join :: String -> [String] -> String
const join = separator => array => array.join(separator)// upperFirst :: String -> String
const upperFirst = x =>x.charAt(0).toUpperCase().concat(x.slice(1).toLowerCase())// uncamelize :: String -> Maybe String
const uncamelize = safeLift(isString, compose(option(""),map(compose(join(" "), map(upperFirst))),match(/(((^[a-z]|[A-Z])[a-z]*)|[0-9]+)/g),
))uncamelize("rockTheCamel")
//=> Just "Rock The Camel"uncamelize({})
//=> Nothing

We’ve created a helper function match that uses safeAfter to iron out String.prototype.match’s behavior of returning an undefined in case there are no matches. The isArray predicate ensures that we receive a Nothing if there are no matches found, and a Just [String] in case of matches. safeAfter is great for executing existing or third-party functions in a reliable safe manner.

我们创建了一个辅助函数match ，该函数使用safeAfter消除String.prototype.match的行为，即在没有匹配项的情况下返回undefined的行为。 isArray谓词可确保在没有找到匹配项的情况下接收Nothing ，在匹配项的情况下接收Just [String] 。 safeAfter非常适合以可靠的安全方式执行现有功能或第三方功能。

(Tip: safeAfter works really well with ramda functions that return a | undefined.)

(提示： safeAfter与返回a | undefined ramda函数配合使用非常好。)

Our uncamelize