7

你希望哪些功能是通用语言？更准确地说，我的意思是通常根本不存在但很高兴看到的功能，而不是“我希望动态类型很流行”。

4

17 回答 17

11

我经常认为“可观察”会成为一个很好的字段修饰符（如公共、私有、静态等）

GameState {
   observable int CurrentScore;
}

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

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

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

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

于 2008-11-21T16:35:08.377 回答
5

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

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

于 2008-11-21T16:32:59.223 回答
5

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

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

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

所以复合数据类型更像是代数类型而不是对象。我认为它使对程序的推理变得容易得多。

另外，在类型类中混合要好得多。类型类只是类型实现的一组类——有点像 Java 等语言中的接口，但更像是 Ruby 等语言中的 mixin，我猜。这有点酷。

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

于 2008-11-21T16:45:15.503 回答
5

我是闭包/匿名函数的忠实粉丝。

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);

我只是希望它们更普通。

于 2008-11-21T17:05:27.163 回答
4

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

  • 多个返回值
  • 函数的必需、关键字、可选和剩余参数（可自由混合）
  • 用作一流的对象（如今变得越来越普遍）
  • 尾调用优化
  • 作用于语言而不是文本的宏
  • 一致的语法
于 2008-11-21T17:24:50.477 回答
2

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

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

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

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

于 2012-05-27T02:39:13.593 回答
2

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

于 2008-11-21T16:25:40.970 回答
2

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

于 2008-11-21T18:38:31.560 回答
1

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

此外，当您需要静态索引器时，它们也很棒。

于 2008-11-21T16:27:17.067 回答
1

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

于 2008-11-21T17:58:28.757 回答
0

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

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()

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

于 2008-11-21T16:30:11.837 回答
0

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

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

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

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

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

（实践中一个很好的例子是人们从一开始就在 C# 中争相使用的 INumeric 接口。）

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

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

而且我应该能够验证我想在编译时调用的方法/运算符的存在。等到运行时是傻瓜:o)

于 2008-11-21T16:52:34.567 回答
0

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

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

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

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

于 2011-06-03T16:39:25.027 回答
0

Lisp 风格的宏。

多发。

尾调用优化。

头等舱延续。

于 2008-11-21T17:50:50.220 回答
0

叫我傻，但我不认为每个功能都属于每种语言。这是“万事通，无所事事”综合症。我喜欢拥有各种可用的工具，每一种工具都是针对特定任务的最佳工具。

于 2008-11-21T17:53:47.237 回答
0

函数式函数，如 map、flatMap、foldLeft、foldRight 等。类型系统，如 scala (builder-safety)。使编译器在编译时删除高级库，同时如果您在“解释”或“较少编译”模式下运行（速度......有时您需要它）仍然拥有它们。

于 2011-02-01T13:47:53.307 回答
-1

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

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

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

能够避免一些常见的有问题的模式也很好：

  • 一些简化 IOC/DI 以消除单例的内置方法，
  • Java——消除检查的异常，这样人们就不再投入空的catch。

最后关注代码的可读性：

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

我确定我没有命名 1/10 可能的项目，但基本上我说的是可以编译为与 C# 或 Java 相同的字节码的东西，但限制如此之大，以至于程序员几乎忍不住要编写好的代码.

是的，我知道有一些 lint 类型的工具可以做到这一点，但我从未在我从事过的任何项目中看到它们（而且它们不会在我现在正在处理的代码上实际运行，例如）所以它们不是很有帮助，我希望看到当您输入 101 行方法时编译实际上会失败......

于 2008-11-21T17:54:49.107 回答