问题标签 [language-features]

我想要这样的东西：

或者，更一般地，解构您正在循环的列表中的任意内容，例如：

通常，您希望使用Map或其他纯函数式构造，并避免使用副作用的非函数式编程风格。但这里有一个例子，我认为 for-each 结构非常有用：

假设我有一个将符号与表达式配对的选项（规则）列表，例如

现在我想制作一个哈希表，在其中将这些符号明显映射到这些数字。我认为没有比这更清洁的方法了

额外的测试用例

在这个例子中，我们转换了一个变量列表：

在上述之后，{a,b,c}应评估为{f[1],f[2],f[3]}。请注意，这意味着each如果它是一个列表，则它的第二个参数应该不被评估。

如果未计算的形式不是列表，它应该计算第二个参数。例如：

那应该打印 和 的b值c。

附录：为了正确地做for-each，它应该支持Break[]和Continue[]。我不确定如何实现。也许它需要以某种方式用 For、While 或 Do 来实现，因为这些是唯一支持Break[]and的循环结构Continue[]。

到目前为止，答案的另一个问题是：他们吃Return[]s。也就是说，如果您在函数中使用 ForEach 循环并希望从循环内从函数返回，则不能。在 ForEach 循环内发出 Return 似乎像Continue[]. 这只是（等待它）让我陷入了循环。

我感兴趣地阅读了一些最近的语言与语言问题... Perl 与 Python，Python 与 Java，一种语言可以比另一种更好吗？

我注意到的一件事是，我们中的很多人不喜欢语言都有非常肤浅的原因。我们第一眼就注意到了这些事情，它们让我们感到厌烦。我们回避那些可能非常好的语言，因为如果我们打扰的话，我们可能会在 2 秒内学会喜欢或忽略这些功能。

好吧，我和下一个人一样有罪，如果不是更多的话。开始：

• Ruby：我看到的所有 Ruby 示例代码都使用该puts命令，这是一种幼稚的意第绪语解剖术语。因此，即使我应该认真对待 Ruby 代码，我也不能认真对待。
• Python：我第一次看到它时，我对整个重要的空白都傻笑了。在接下来的几年里，我避免了它。现在我几乎不使用其他任何东西。
• Java：我不喜欢 identifiersThatLookLikeThis。我不确定为什么。
• Lisp：所有括号都有问题。不同重要性和目的的事物（函数声明、变量赋值等）在语法上没有区别，我懒得去学习什么是什么。
• Fortran：大写的一切都伤害了我的眼睛。我知道现代代码不必这样写，但大多数示例代码是......
• Visual Basic：Dim用于声明变量让我很烦恼，因为我记得 GW-BASIC 的美好时光，当时它仅用于维度数组。

哪些语言乍一看对我来说是正确的？Perl、C、QBasic、JavaScript、汇编语言、BASH shell、FORTH。

好的，现在我已经晾干了我的脏衣服……我想听听你的。 你的语言障碍是什么？哪些肤浅的特征困扰着你？你是如何克服它们的？

有没有办法强制（子）类在 C# 或 Java 中具有具有特定签名或特定静态方法的构造函数？

您显然不能为此使用接口，而且我知道它的用途有限。我发现它很有用的一个例子是当你想强制执行一些设计指南时，例如：

例外
他们应该都有四个规范的构造函数，但是没有办法强制执行它。您必须依靠像 FxCop（C# 案例）这样的工具来捕捉这些。

运算符
没有约定可以对两个类求和（在 C# 中使用 operator+）

是否有任何设计模式可以解决此限制？在未来的 C# 或 Java 版本中，可以向语言添加什么结构来克服这个限制？

Python 中的许多有用的特性都有些“隐藏”在模块中。例如，命名元组（Python 2.6中的新功能）可以在collections模块中找到。

图书馆文档页面将为您提供该语言的所有模块，但 Python 新手可能会发现自己说“哦，我不知道我可以使用 Python 以这种方式完成它！” 除非有经验的开发人员指出语言中的重要特性。

我并不是专门寻找 Python 2.6 中的新模块，而是在这个最新版本中可以找到的模块。

我们都熟悉前置和后置操作符，例如

以及扩展此原则的“组合运算符”：

我经常需要一个“后组合运算符”，这将允许：

显然，这仅对不可交换运算符真正有用，并且含义从前/后增量改变，即使语法是借用的。

您是否知道提供这种运算符的任何语言，为什么它不更常见？

每次我需要在使用 C# 的算法中执行N次操作时，我都会编写这段代码

学习 Ruby 我了解了方法times()可以与这样的相同语义一起使用

C# 中的代码片段看起来更复杂，我们应该声明无用的变量i。

我尝试编写返回IEnumerable的扩展方法，但我对结果不满意，因为我必须再次声明一个循环变量i。

是否可以使用一些新的 C# 3.0 语言特性让N次循环更优雅？

这里有一些宝石：

字面量：

默认值：

我们当然知道匿名函数，但是能够将它们视为文字并在现场（作为闭包）执行它们很棒：

问题： javascript 中还有哪些出色的语法糖？

这是一个类似的C#问题的不加掩饰的尝试。

那么您最喜欢的 F# 隐藏（或不隐藏）功能是什么？

到目前为止，我使用的大多数功能都没有完全隐藏，但非常令人耳目一新。与 C# 或 VB.NET 相比，重载运算符是多么微不足道。

并Async<T>帮助我剃掉了一些真正丑陋的代码。

我对这门语言还是很陌生，所以很高兴了解野外使用的其他功能。

有谁知道是否可以在.NET 中定义等效于“java 自定义类加载器”的内容？

提供一点背景：

我正在开发一种针对 CLR 的新编程语言，称为“Liberty”。该语言的特点之一是它能够定义“类型构造函数”，这是由编译器在编译时执行并生成类型作为输出的方法。它们是泛型的一种概括（该语言中确实有普通的泛型），并允许编写这样的代码（以“Liberty”语法）：

“元组”的定义如下：

在这个特定的示例中，类型构造函数tuple提供了类似于 VB 和 C# 中的匿名类型的东西。

但是，与匿名类型不同，“元组”具有名称并且可以在公共方法签名中使用。

这意味着我需要一种方法，让最终由编译器发出的类型可以跨多个程序集共享。例如，我想要

tuple<x as int>在程序集 A 中定义的类型最终与tuple<x as int>程序集 B 中定义的类型相同。

当然，这样做的问题是程序集 A 和程序集 B 将在不同的时间编译，这意味着它们最终都会发出自己不兼容的元组类型版本。

我研究了使用某种“类型擦除”来做到这一点，这样我就可以拥有一个包含一堆这样的类型的共享库（这是“Liberty”语法）：

然后将访问从 i、j 和 k 元组字段重定向到Field1、Field2和Field3.

然而，这并不是一个真正可行的选择。这意味着在编译时tuple<x as int>最终tuple<y as int>会成为不同的类型，而在运行时它们将被视为相同的类型。这会给诸如平等和类型标识之类的事情带来很多问题。这对我的口味来说太抽象了。

其他可能的选择是使用“状态包对象”。但是，使用状态包会破坏语言中支持“类型构造函数”的全部目的。想法是启用“自定义语言扩展”以在编译时生成新类型，编译器可以使用这些新类型进行静态类型检查。

在 Java 中，这可以使用自定义类加载器来完成。基本上可以发出使用元组类型的代码，而无需在磁盘上实际定义类型。然后可以定义一个自定义的“类加载器”，它将在运行时动态生成元组类型。这将允许在编译器内部进行静态类型检查，并将跨编译边界统一元组类型。

然而不幸的是，CLR 不提供对自定义类加载的支持。CLR 中的所有加载都是在程序集级别完成的。可以为每个“构造类型”定义一个单独的程序集，但这会很快导致性能问题（有许多只有一种类型的程序集会使用太多资源）。

所以，我想知道的是：

是否可以在 .NET 中模拟 Java 类加载器之类的东西，我可以在其中发出对不存在类型的引用，然后在需要使用它的代码运行之前在运行时动态生成对该类型的引用？

笔记：

*我实际上已经知道这个问题的答案，我在下面提供了答案。然而，我花了大约 3 天的时间进行研究，并进行了大量的 IL 黑客攻击，以便提出解决方案。我认为在这里记录它是一个好主意，以防其他人遇到同样的问题。*

名称还有哪些其他限制（除了范围内明显的唯一性）？

那些定义在哪里？