以相同的方式处理单个和多个元素“透明”映射运算符

如何解决以相同的方式处理单个和多个元素“透明”映射运算符

我正在研究一种应该简单、直观和简洁的编程语言（是的，我知道，我是第一个提出这个目标的人;-)）。 我正在考虑简化容器类型使用的功能之一是使容器元素类型的方法在容器类型本身上可用，基本上作为调用 map(...{{1 }} 方法。这个想法是使用多个元素应该与使用单个元素没有什么不同：我可以将 ) 应用于单个数字或整个数字列表，并且我不必编写略有不同的代码对于“一个”与“多个”场景。

例如（Java 伪代码）：

add(5)

据我所知，这个概念不仅适用于“容器”类型（流、列表、集合...），而且更普遍地适用于所有具有 import static java.math.BigInteger.*; // ZERO,ONE,... ... // NOTE: BigInteger has an add(BigInteger) method Stream<BigInteger> numbers = Stream.of(ZERO,TWO,TEN); Stream<BigInteger> one2Three11 = numbers.add(ONE); // = 1,2,3,11 // this would be equivalent to: numbers.map(ONE::add) 方法的类似函子的类型（例如，可选项、状态 monad 等）。 实现方法可能更符合编译器提供的语法糖，而不是通过操作实际类型（map 显然不扩展 Stream<BigInteger>，即使它做了“map-add " 方法必须返回 BigInteger 而不是 Stream<BigInteger>，这与大多数语言的继承规则不兼容）。

关于这样一个提议的功能，我有两个问题：

(1) 提供此类功能的已知注意事项是什么？容器类型和元素类型之间的方法名称冲突是我想到的一个问题（例如，当我在 Integer 上调用 add 时，我是想将一个元素添加到列表中还是我想要为列表的所有元素添加一个数字？参数类型应该澄清这一点，但它可能会变得棘手）

(2) 是否有任何现有的语言提供这样的功能，如果有，这是如何在幕后实现的？我做了一些研究，虽然几乎每一种现代语言都有类似 List<BigInteger> 运算符的东西，但我找不到任何一种语言，其中一对多的区别是完全透明的（这让我相信有我在这里忽略了一些技术难题）

注意：我是在不支持可变数据的纯函数上下文中看待这个问题（不确定这对回答这些问题是否重要）

解决方法

您是否具有面向对象的背景？这是我的猜测，因为您将 map 视为属于每种不同“类型”的方法，而不是考虑属于 functor 类型的各种事物。

如果 map 是每个函子的属性，请比较 TypeScript 如何处理这个问题：

declare someOption: Option<number>
someOption.map(val => val * 2) // Option<number>

declare someEither: Either<string,number>
someEither.map(val => val * 2) // Either<string,number>
someEither.mapLeft(string => 'ERROR') // Either<'ERROR',number>

您还可以创建一个常量来表示每个单独的函子实例（选项、数组、身份、异步/承诺/任务等），其中这些常量具有 map 作为方法。然后有一个独立的 map 方法，它采用这些“函子常量”之一、映射函数和起始值，并返回新的包装值：

const option: Functor = {
  map: <A,B>(f: (a:A) => B) => (o:Option<A>) => Option<B>
}
declare const someOption: Option<number>
map(option)(val => val * 2)(someOption) // Option<number>

declare const either: Functor = {
  map: <E,A,B>(f: (a:A) => B) => (e:Either<E,A>) => Either<E,B>
}
declare const either: Either<string,number>
map(either)(val => val * 2)(someEither)

本质上，您有一个函子“map”，它使用第一个参数来标识您要映射的类型，然后传入数据和映射函数。

但是，使用像 Haskell 这样的函数式语言，您不必传入“函子常量”，因为该语言会为您应用它。 Haskell 就是这样做的。不幸的是，我对 Haskell 不够流利，无法为您编写示例。但这是一个非常好的好处，意味着更少的样板。它还允许您以“无点”风格编写大量代码，因此如果您使用自己的语言，则重构会变得更加容易，因此您不必手动指定正在使用的类型以利用 { {1}}/map/chain/etc.

假设您最初编写的代码通过 HTTP 进行大量 API 调用。所以你使用了一个假设的异步 monad。如果您的语言足够聪明，可以知道正在使用哪种类型，那么您可以编写一些代码，例如

bind

现在您更改 API 以使其读取文件并改为同步：

import { map as asyncMap }

declare const apiCall: Async<number>
asyncMap(n => n*2)(apiCall) // Async<number>

看看您如何更改多段代码。现在假设您有数百个文件和数万行代码。

使用无点样式，您可以做到

import { map as syncMap }

declare const apiCall: Sync<number>
syncMap(n => n*2)(apiCall)

并重构为

import { map } from 'functor'
declare const  apiCall: Async<number>
map(n => n*2)(apiCall)

如果您有一个集中的 API 调用位置，那将是您更改任何内容的唯一位置。其他一切都足够智能，可以识别哪个您正在使用的函子并正确应用映射。

1. 就您对名称冲突的担忧而言，无论您使用何种语言或设计，这种担忧都会存在。但是在函数式编程中，import { map } from 'functor' declare const apiCall: Sync<number> map(n => n*2)(apiCall) 将是一个组合子，它是您的映射函数传递到您的 add（Haskell 术语）/fmap（许多命令式/OO 语言的术语）中。用于将新元素添加到数组/列表尾端的函数可能称为 map（“cons” from “construct” 向后拼写，其中 snoc 将元素添加到数组中； cons 附加）。您也可以将其称为 snoc 或 push。

2. 就您的一对多问题而言，这些不是同一类型。一种是 append 类型，另一种是 list/array 类型。处理它们的底层代码会有所不同，因为它们是不同的函子（一个包含单个元素，而一个包含多个元素。

我想您可以创建一种语言，通过自动将它们包装为单元素列表，然后只使用列表 identity 来禁止单个元素。但这似乎需要大量工作才能使两个截然不同的事物看起来相同。

相反，将单个元素包装为标识并将多个元素包装为列表/数组，然后数组和标识具有自己的函子方法 map 的底层处理程序的方法可能会变得更好。