Question

您希望使用通用语言的哪些功能？更准确地说，我的意思是通常根本不存在的功能，但很高兴看到，而不是“我希望动态打字很受欢迎。”

Answer 1

我经常认为“可观察”会产生很好的场修改器（如公共，私有，静态等）

GameState {
   observable int CurrentScore;
}

然后，其他类可以声明该属性的观察者：

ScoreDisplay {
   observe GameState.CurrentScore(int oldValue, int newValue) {
      ...do stuff...
   }
}

编译器将使用通知代码包装对CurrentScore属性的所有访问，并在修改值时立即通知观察者。

当然，你可以使用事件监听器和属性更改处理程序在大多数编程语言中做同样的事情，但是这是一个巨大的痛苦，需要大量的零碎管道，特别是如果你不是班级的作者你想要观察的价值观。在这种情况下，您通常必须编写包装器子类，将所有操作委托给原始对象并从mutator方法发送更改事件。为什么编译器不能生成所有那些愚蠢的样板代码？

Answer 2

我猜最明显的答案是类似Lisp的宏。能够使用您的代码处理您的代码非常“元”，并允许从（几乎）从头开发一些非常令人印象深刻的功能。

紧接其后的是C ++等语言的双重或多重发送。如果多态可以扩展到虚函数的参数，我会喜欢它。

Answer 3

我希望有更多的语言来拥有像Haskell这样的类型系统。 Haskell使用了一个非常棒的type inference系统，所以你几乎不需要声明类型，但它仍然是一种强类型语言。

我也非常喜欢在Haskell中声明新类型的方式。我认为它比例如面向对象的系统更好。例如，要在Haskell中声明二叉树，我可以执行以下操作：

data Tree a = Node a (Tree a) (Tree a) | Nothing

因此，复合数据类型更像是代数类型而不是对象。我认为这使得该计划的推理变得更加容易。

另外，混合类型类更好。类型类只是一个类实现的一组类 - 有点像Java之类的语言中的接口，但更像是像Ruby这样的语言中的mixin，我猜。这很酷。

理想情况下，我希望看到像Python这样的语言，但是使用数据类型和类型类（如Haskell而不是对象）。

Answer 4

我是闭包/匿名功能的忠实粉丝。

my $y = "world"; 

my $x = sub {  print @_ , $y }; 

&$x( 'hello' );  #helloworld

和

my $adder = sub {
    my $reg = $_[0];
    my $result = {};
    return sub { return $reg + $_[0]; }
};

print $adder->(4)->(3);

我只是希望它们更常见。

Answer 5

来自Lisp的东西我想念其他语言：

多个返回值
功能
作为第一类对象（现在变得越来越普遍）
尾调用优化
对语言进行操作的宏，而不是文本
一致的语法

Answer 6

immutable个关键字。是的，你可以制作不可变对象，但在大多数语言中都很痛苦。

class JustAClass 
{
    private int readonly id;   
    private MyClass readonly obj;
    public MyClass 
    { 
        get 
        {
            return obj;
        }
    }
}

显然JustAClass似乎是一个不可变的类。但事实并非如此。由于另一个对象具有相同的引用，因此可以修改obj对象。

因此，最好引入新的immutable关键字。使用immutable时，该对象将被视为不可变。

Answer 7

为了开始，我希望字符串的标准是使用前缀，如果你想使用转义码，而不是它们的使用是默认值。例如。在C＃中，您可以使用@作为原始字符串的前缀。同样，Python有r前缀。当我不想要原始字符串并且需要转义码时，我宁愿使用@ / r。

Answer 8

实际上设计的更强大的模板用于元编程，而不是真正为相对简单的泛型设计的C ++模板，并且几乎是偶然的图灵完成。 D编程语言有这些，但它还不是很主流。

Answer 9

类型推断。它正慢慢地进入主流语言，但它仍然不够好。 F＃是这里的黄金标准

Answer 10

我喜欢Ruby语言中的一些数组操作功能。我希望我们有一些内置于.Net和Java。当然，你总是可以创建这样一个库，但不必这样做就好了！

此外，静态索引器在您需要时非常棒。

Answer 11

我想看单方法和单操作员接口：

interface Addable<T> --> HasOperator( T = T + T)

interface Splittable<T> --> HasMethod( T[] = T.Split(T) )

......或类似的东西......

我认为它是鸭子类型的类型安全实现。接口不是原始类作者提供的保证。它们是由第三方API的消费者做出的断言，在原作者没有预料到的情况下提供有限的类型安全性。

（在实践中，这是一个很好的例子，就是人们在C＃以来就一直在为C＃写作的INumeric界面。）

在像Ruby这样的鸭式语言中，你可以调用你想要的任何方法，直到运行时才会知道是否支持该操作，因为该方法可能不存在。

我希望能够对类型安全做出小的保证，这样我就可以在异构对象上多态调用方法，只要所有这些对象都有我想要调用的方法或操作符。

我应该能够在编译时验证我想要调用的方法/运算符的存在。等到运行时间为吸盘：o）

Answer 12

Lisp样式宏。

多次发送。

尾调用优化。

头等舱继续。

Answer 13

叫我傻，但我不认为每个功能都属于每种语言。这是“所有行业的杰克，无人掌握”综合症。我喜欢提供各种工具，每种工具都是最适合特定任务的工具。

Answer 14

我希望有一个自动反转赋值运算符，它在超出范围时回滚。这将取代：

type datafoobak = item.datafoobak
item.datafoobak = 'tootle'
item.handledata()
item.datafoobak = datafoobak

用这个

item.datafoobar @=@ 'tootle'
item.handledata()

可以明确地回滚这些更改，但是它们也会在范围之外回滚。这种功能可能有点容易出错，但在某些情况下它也会使代码更加清晰。某种浅层克隆可能是一种更有效的方法：

itemclone = item.shallowclone
itemclone.datafoobak='tootle'
itemclone.handledata()

但是，如果浅层克隆的功能修改了内部数据，那么它们可能会出现问题......尽管可逆性分配也是如此。

Answer 15

功能函数，如map，flatMap，foldLeft，foldRight等。键入系统，如scala（builder-safety）。使编译器在编译时删除高级库，如果以“解释”或“编译较少”模式运行，则仍然使用它们（速度......有时你需要它）。

Answer 16

这里有几个好的答案，但我会补充一些：

1 - 能够获取当前和调用者代码的字符串表示，以便我可以轻松输出变量名称及其值，或者随时打印当前类，函数或堆栈跟踪的名称。

2 - 管道也很好。此功能在shell中很常见，但在其他类型的语言中并不常见。

3 - 能够轻松地将任意数量的方法委托给另一个类。这看起来像继承，但即使存在继承，偶尔我们也需要某种无法实现为子类的包装器或存根，转发所有方法需要大量的样板代码。

Answer 17

我想要一种限制性更强的语言，并且围绕生成良好，可维护的代码而设计，没有任何诡计。此外，它应该被设计为使编译器能够在编译时尽可能多地进行检查。

从一个基于OO语言的新VM开始。

删除运算符重载和多重继承等复杂性（如果存在）。
强制所有非最终变量为Private。
会员应该默认为“最终”，但应该有一个“变量”标签来覆盖它。（这可能需要内置支持构建器模式才能完全有效）。
默认情况下，变量不应允许“Null”值，但变量和参数应具有“可空”标记，表示该变量可接受null。

能够避免一些常见的可疑模式也很好：

一些简化IOC / DI以消除单例的内置方法，
Java - 消除已检查的异常，以便人们不再进行空捕获。

最后关注代码可读性：

命名参数
删除创建超过100行的方法的功能。
添加一些复杂性分析，以帮助检测复杂的方法和类。

我确定我没有提到可能的1/10项目，但基本上我说的是编译成与C＃或Java相同的字节码的东西，但是限制性很强，以至于程序员几乎无法帮助写好的代码。

是的，我知道有一些lint类型的工具可以完成其中的一些工作，但是我从来没有在我工作过的任何项目上看过它们（而且他们不会在代码上运行它我就是现在工作，例如）所以他们没有很大的帮助，当你输入101行方法时，我很乐意看到编译实际上失败 ...

您希望使用通用语言的哪些功能？

17 个答案: