如果要设计一种编程语言，您将如何做？您会加入哪些功能？你会遗漏什么？静态还是动态类型？是强类型还是弱类型？编译还是解释？证明你的答案。

• 我绝对认为函数式编程语言会流行，因此我的语言将是函数式的。请参见使用函数式编程驯服效果

• 我认为CPU很快将拥有大量的内核，而线程将使他难以管理。因此，Actor模型是必须的，而不是线程。参见Erlang-并发世界的软件

• 我还认为OOP失败了，假定对象之间的通信是异步的。所以我认为我们需要传递消息，传递不可变的消息。发送和忘记。就像在Actor模型中一样。参见面向对象编程：错误的路径？

• 我认为最好使用静态类型，因此可以在开发周期的早期发现错误。但是我会像在Haskell中那样使用类型推断，以便开发人员不需要像在C，C＃和Java中那样在代码中到处都写类型。请参阅了解Haskell为您带来的好处

• 我还将设计一个具有声明式布局的出色UI库，如WPF和Android中一样。但是我希望像在功能反应式编程中那样。

因此，我的语言就像是Erlang中的并发，但是像Haskell中那样具有键入性，而WPF.NET中则具有GUI框架。

注意：我在本文中使用了类似于C的语法来描述功能，但是我对语法本身并不挑剔，只要它不像所有关键字都是CAPS那样可笑。

1.打字系统

我想要的一种语言中的第一个功能是静态键入和可选的动态键入。原因是静态类型使您可以a）尽早捕获错误，而不是延迟捕获错误； b）大多数代码都是隐式静态类型的，无论该语言是否能区分。但是，在一些用例中，动态类型非常有用。例如，当从文件中读取数据时，您通常具有各种类型的字段，而动态类型化则使异构容器变得容易。因此，我理想的语言应该是这样的：

//variable declarations
int anInt = 42 //anInt is now irrevocably an integer and assigning another type to it is an error
vartype aVariable = 42 //aVariable is currently an integer, but any type can be assigned to it in the future

//function definitions
int countElements(Collection c)
{
  return c.count();
} 

//c HAS to be a collection, since countElements doesn't make sense otherwise

void addToCollection(Collection& c, vartype v) 
{
  c.append(v)
}

//c is passed by reference here

2.编译与解释

我希望该语言可以提前编译，或者是JIT编译，但不是纯粹的解释，速度是原因。这与点1有关，因为优化编译器/抖动将使优化静态类型代码的时间变得容易得多，而动态类型代码可以简单地保持原样。

3.关闭

该语言必须支持函数式编程构造，而函数应该是一流的对象。

4.面向对象

该语言应允许您编写面向对象的代码，但也应允许使用简单的命令式代码。即，应该可以像下面这样编写一个hello world程序：

int main(string<> args=null)
{
  printf("hello, world"); 
  return 0;
}

// this code also demonstrates two other features,
// default arguments for functions (not explained further)
// and immutable lists like string<> (see 6. Built-in datatypes)

5.命名空间

命名空间是一件好事。很少的东西应该进入全局名称空间。但是，如果必须将内容放入全局名称空间中，则可以（ala C ++）。

6.内置数据类型

作为内置数据类型，该语言必须具有以下构造：

• 一个int或多个数据类型。如果只有一种int类型，则应具有无限范围。如果还有更多，则应将隐式上行转换为能够保存计算结果的最小类型，而无限范围类型最大。
• 单个内置二进制float类型，等效于IEEE 754double
• 一种可变list类型，可实现为双向链接列表或包含指向每个元素的指针的连续内存块
• 一个不可变list类型，其作用类似于数组，但其大小在创建后无法更改
• 可变和不可变string类型，默认为不可变。
• 一个可变的map或dict类型，并持有不可变的键以及可变和/或不可变的值。
• 内置集合类型默认情况下应为同构类型，但vartype如果需要，可以为d
• 一boolean型
• 甲null或none类型可以被分配给任何类型的变量。
• 可变和不可变set类型
• 甲decimal它实现十进制浮点变量类型
• 一种fixed实现定点数字的类型

的decimal，float和fixed类型应该共享的确切一样的公共接口（通过继承或鸭打字要么），允许它们被透明地传递并从函数返回。父类型可以称为real。

7.按价值和参考要求

您应该能够同时通过值和引用来调用函数，默认值是值（即，在函数中创建并操作了参数的副本）。

8.指针

该语言应具有指针并允许指针算术。指针只能是静态类型的（以避免成为的噩梦void*）。vartype明确禁止使用指针。具有指针和指针算术可以使该语言认真地用作系统编程语言。

9.内联汇编

与8.结合，对于需要的情况，该语言应允许内联汇编语言代码。

10.安全

该语言应在大多数情况下安全使用，并支持异常处理等。指针算术和内联汇编可以归于明确标记为不安全的代码部分。允许使用不安全的代码，但强烈建议不要这样做。

11.未定义的行为

语言标准应指定程序在所有情况下的行为方式，除非明确标记为不安全的代码除外，即，在不安全的块之外不应存在未定义的行为。这样一来，该语言就可以用作可行的应用程序开发语言，同时仍然可以让您说出用它来编写操作系统。

目前，这就是我能想到的，但是当我想到更多内容时，我将对其进行编辑/更新。

这就是我梦dream以求的编程语言的样子：

• 一个强大的静态类型系统，对依赖类型的支持。
• 可选的动态类型。
• 数字塔la Lisp，但为静态键入。
• Macros a la Lisp。
• 主要是一种功能性编程语言，具有对命令式编程的基本支持（例如ML系列）。
• 垃圾收集。
• 类型推断。
• 延续。
• 可选的惰性语义。
• 所有控制结构都将以库函数的形式提供。（这可以通过使用后两个功能来实现。）
• 最小语法（不如Lisps小，但有点像Ioke / Seph。）

我本来可以像C＃一样设计它，但是Microsoft击败了我。:)

^{_{（当然，除了我的思想会经过深思熟虑而更多是业余的。）}}

我不介意它是已编译还是已解释，因此我不需要证明这一点。

关于强静态类型，我很难理解为什么这甚至需要证明理由。静态类型化是一种在编译时捕获错误的功能。动态类型化是缺少该功能的，并且会将错误推迟到运行时。以我的个人经验，很少有用例可以使用动态调度并且有用，因此在4.0之前我必须在C＃中进行卷积才能获得合理的证明。在C＃4.0中，我什至不需要证明这一点，因为我们现在有了动态调度。

但是，我可能会创建一个新的语法，而不是像C＃那样忠实地遵循旧的C语法。switch语句特别可​​怕，我也不喜欢强制转换语法（这是错误的方法）。不过，我不会对语法的细节大惊小怪，因此我不需要详细说明其合理性，只是我不希望它像Visual Basic那样冗长。

您还希望我提出什么理由？

好吧，这是我要添加的功能列表：

像Lisp一样的语法

Lisp风格

优点：

• 易于扩展的语法。是否曾经尝试在C中实现foreach循环？这并不完全容易。（请注意，我已经完成了）。
• 同声性。你可以简单地(eval "your data files")

缺点：

• 嵌套的波兰语表示法通常很难阅读

功能编程

哈斯克尔风格

优点：

• 易于并发，所有代码都是线程安全的。

缺点：

• 尽管monad似乎做得很好，但是很难用纯函数代码实现副作用。

强大的动态打字

Python风格

优点：

• 动态类型使代码清晰易读，强类型可以消除类型错误

实施方式：

允许基于类型的函数重载，类似于CL defgeneric：

(define (+ (a <int>) (b <int>))
  (ints-add a b))

(define (+ (a <string>) (b <string>))
  (string-concat a b))

(define (+ a b)
  (add-generic a b))

可编译和可解释

优点：

• 如果编译，性能会提高（通常为true，并非总是如此）

缺点：

• 可以限制语言的功能，但是llvm是一个很好的支持。

系统程式设计

C风格

优点：

• 吸引了非常少量的用户。
• 如果应用程序，内核和设备驱动程序全部使用相同的语言编写，则更易于交互

缺点：

• 限制了语言的抽象性，动态类型通常不适合。

卫生宏（CL样式和Scheme样式）

优点：

• 易于扩展语言，尤其是使用Lispy™语法
• 我之前已经说过了，不是吗？

缺点：

• 如果使用Lispy™语法完成，则不会很多

想到它，这个或多或少的定义方案，除了编译和系统编程位。可以通过使用libguile并将这些位写入C来解决。

有几种我认为非常不错的语言（C＃是我目前的最爱）。由于这是我的幻想语言，因此，我真正希望它具有以下功能：

• 踢屁股官方api文档。这样的Java API很好，而C＃/。NET很好。Ruby / Rails在这里非常糟糕。
• 踢屁股官方通用文档（使用方法，常用用法，大量示例代码）。C＃/。Net对此很有用。
• 一个庞大的基于博客的文档撰写者社区和StackOverflow问题解决者社区，可以帮助我摆脱困境
• 各种各样的，受支持的，有据可查的，功能强大的插件/库/扩展（Ruby / Rails具有“强大”功能​​，而其他两个功能都没有）。
• 相当稳定-无需每年更改所有内容以破坏大多数现有代码（在您看来，Ruby / Rails）。
• 不太稳定-能够适应语言设计的进步（看着你，C ++）

编译提示

我不喜欢语言，因为我对语言设计不是很了解，但是我认为我正在谈论的功能被称为其他语言的提示。编译器提示，也许吗？

我不知道我是在Perl6初稿中阅读的还是当时读的很高，但是我想象一种语言，默认情况下一切都是松散的，糊涂的和自动的。但是，如果您想真正提高性能，然后说，嘿，这个值始终是整数，或者永远不会为null，或者可以是并行的，或者这是无状态的，诸如此类的事情……编译器可以自动运行在这些特别标记的区域上。

E：我希望您能通过评论澄清我的要求，或者引用一些已经存在的示例。

尝试新想法：

我将创建一种动态类型的函数式编程语言，它使您可以执行所有语句表达技巧，并通过模式匹配来执行最简单的lambda语法。越位规则已启用。

// a view pattern (or Active Pattern in F#)
default = \def val: !!val.Type val def

// usage of the pattern
greet = \name<(default "world") `and` hasType Str>:
  p "Hello, \{name}!"

(p "Enter your name", .input).greet // (, ) is a sequence expression, returning the last value

这里是一个解释：

default =设置存储，\def val以两个参数开始一个咖喱函数，与val.Type相同Type[val]，!!转换为布尔值，并且可以应用布尔值，因此val和def are after it.

f x= f[x]= x.f .f=f[]

在中greet，使用name<(default "world")和hasType Str>表示模式default "world"将被使用并绑定到name。默认模式指定默认值。 and是将两个模式链接在一起的另一个模式。该default模式不能失败，而hasType可能会失败。在这种情况下，它将引发异常。

变量实际上是存储，可以在功能上进行传递，并且存储表可以作为引用，在范围更改时创建和销毁。

哈希等将与Lua和JavaScript中的类似。

如果要编写一种编译语言，我将为Java创建F＃，具有类似Haskell的功能。它是一种纯函数式语言，除了有一种功能，它可以将“报价”和“计算表达式”混合在一起，以通过编写类似伪代码的块来实现命令式编程。

请记住，我所知道的唯一的语言是PHP和javascript，在设计一种语言之前，我确实应该学习一些知识：

语法：请 仔细考虑函数名称和参数顺序（即，比PHP少混乱）。

功能： 具有一组string函数，这些函数按一系列字节操作变量，但是不理解文本；还有一组text函数，可以理解许多编码，并且可以对UTF-8和其他多字节字符串进行操作。（并且在语言中内置了编码完整性检查功能，该功能具有类似text.isValidEncoding(text, encoding)该功能的功能，该功能可以告诉您字节序列是否格式错误并且不安全地视为文本。

我认为我喜欢强静态类型化的想法，但是我从未使用过它，所以我不能说真的。

在设计一种编程语言之前，我会找到一个很好的答案：为什么我们还需要另一种编程语言？在撰写本文时，Rosetta Code列出了344种语言。如果这些都不满足我的需求，那么为什么不提供这些细节将决定起点（最接近的语言）以及要添加的内容。

如果我中了彩票，并且由于某种原因没有更好的选择，那么我将从Liskell开始，使其成为一种成熟的语言，而不是GHC前端，然后使FFI更加容易（并且自动化），因此我可以使用C / C ++库。

一种好的语言是一种语言：

• 易于推理（没有晦涩的语法）
• 让您以最小的失真表达自己的想法
• 隐藏您的细节（优化/资源管理）
• 易于并行化（多核，分布式计算）

很难将其转换为功能列表，但是我认为函数式编程尽管不自然，但比命令式编程更接近此功能（尤其是隐藏了一些具体细节）

• C接口：C是编程语言的通用语言，并且用C开发的库数量惊人。通过与C的简单接口（例如Python），该语言自动从所有这些库中受益，并且还允许发送繁重的任务，而这些任务无法充分优化，无法接近金属语言。
• 分布式：我喜欢Go在多线程方面的工作，它具有轻量级例程，运行时根据线程的活动在线程上调度这些例程。这种语言鼓励程序员推理任务，并将其彼此隔离。
• 垃圾收集：如今不用多说了；）
• 不可变：更容易推断出永远不会发生变化的事物，也更容易实现多线程/分布式计算（您只需同步即可处理生命周期，这是编译器的任务）
• Lambdas：我猜想具有一流的功能
• 消息传递：不变性不意味着互斥，因此我们遵循Tony Hoares的建议
• 模块：有点类似于名称空间，但具有更好的封装
• 反思：分布式计算需要序列化，应该由编译器处理，使用某种形式的反思更容易实现反序列化。
• 静态强类型：提早发现错误，花费最少

目前，更接近此列表的语言可能是Haskell，但：

• 它缺少例程：我还没有在Haskell中看到一种表达并行性的自然方法（尽管这可能是我的无知...）
• 它有一个晦涩的语法：某种程度上，Haskell程序员看起来很喜欢使用奇怪的运算符而不是单词。它看起来似乎很圆滑，但是对了解正在发生的事情并没有太大帮助。

对于您的第一个问题，“您将如何做”-简短的回答，我不会。我没有足够的解析器/编译器理论来实现这一目标。但是我已经编程25年了，所以我确实有一些想法和观点可以分享。

首先，我将尝试提出一种OOP方法，该方法可让您创建真正的连接模型。我的意思是，模型几乎是任何类型的编程项目中最重要的事情之一-要做很多工作和不断重构才能使其正确无误，而我将其归咎于缺乏真正的连接性。 OO语言。

请允许我示范。假设某类房屋具有Door属性。

var door = house.Door;

现在，您具有一个引用Door实例的局部变量。

但是，请考虑一下发生了什么：您刚刚将门从房屋上拆下，现在您很高兴将门传递出去，而其余代码则无视此门实际上是与房屋相连的事实。

对我来说，这根本是错误的。

是的，我知道，可以根据情况“轻松”地解决此问题-在这种情况下，可以通过维护每个门到当前连接的房屋的反向引用来解决。当然，这使您的模型容易出错，因为现在您有责任准确地维护两个反向引用，因此您将House.Doors和Door.House属性设为私有，然后添加如House.AddDoor（），House.RemoveDoor（ ），Door.SetHouse（）等，并将其全部连接起来，并对其进行单元测试以确保其确实有效。

听起来不是很容易为这种直接关系建模的工作吗？要维护很多代码？随着模型的发展，需要重构很多代码吗？

问题是指针。我所见过的每种OO语言都会固有地遭受这样的事实，即对象引用实际上是一个指针，因为那是计算机使用的对象。

指针不是模拟现实世界的好方法。无论您要建模的世界是什么，几乎都可以保证该世界中的任何关系都是双向关系。指针仅指向一个方向。

我想看到一种语言，其中基本数据模型是图形-默认情况下，所有关系都有两端。几乎可以肯定，这将为现实世界的建模提供更为自然的契合度，这实际上是我们首先需要计算机的唯一条件。（以及视频游戏。）

我不知道这种语言的语法是什么样，或者甚至可以想象使用文本来表达它。（我想知道这样的语言是否必须以图形方式显示……）

我也希望看到所有形式的意外状态都消除了。

例如，在Web开发中，我们花费大量时间将数据库中的数据，业务模型，视图模型中的数据进行整形以进行表示……然后，这些数据中的某些数据以表格的形式呈现，这实际上只是另一种转换。 ..和状态从表单发布回来，然后我们对数据进行整形并将其投影回视图模型，例如视图模型活页夹等。然后，我们从视图模型将其投影回业务-模型...然后我们使用对象关系映射器（或繁琐的工作）来转换视图模型中的数据并将其投影到关系数据库中...

这听起来是否多余？在所有这些疯狂之中，我们什么时候真正完成了有用的事情？所谓有用，是指有形的东西-最终用户可以理解和关心的东西。归根结底，您花费在实际构建用户甚至可以理解的内容上的时间实际上是花得最多的时间。其他一切都是副作用。

我想要一种高度动态的语言。写入/编译/运行周期是浪费时间。理想情况下，该语言应仅找出发生了什么变化，并根据需要在后台透明地编译/加载。

理想情况下，您甚至不必点击“运行”-所做的更改应该在屏幕上发生，并立即反映出所做的更改。写/编译/运行周期的问题，或者就此而言，更直接的写/运行周期的问题是，您与所做的工作太脱节了-为了与我们的工作保持联系，我们需要即时反馈，即时结果。任何等待都太长了！

再说一次，我什至不知道这是否可以用传统的IDE来完成，或者是否需要一种全新的接口。

无论哪种类型最适合您正在解决的问题，您都应该能够同时使用弱类型和强类型。

一般而言，状态应该是该语言完全为您管理的内容。为什么需要依赖数据库来保持持久性？理想情况下，我希望能够简单地指定模型中任何变量的生命周期：一个Web请求，一个会话，24小时永久保存。

为什么我们必须在针对不同介质和生命周期的一系列存储解决方案之间进行选择？-更不用说转换和调整数据以适合每种媒体；浏览器缓存，数据库，内存，磁盘，谁在乎！数据就是数据。存储数据（以及存储多长时间）的位置应该是一个简单的选择，而不是与众神之战！

好吧，祝你好运。

它可能是一种多范式语言，支持以下内容：

• 结构化/程序化编程
• 面向对象编程
• 功能编程

为什么要这样？面向对象，因为它是组织大型程序（特别是组织数据）的好方法。因为您并非总是想要/不需要（OOP），所以结构化，人们应该有选择权。之所以具有功能性，是因为它使程序员易于调试，并使程序更清晰。

我将使用带有缩进块的Python模型来标记代码块。它非常清晰，阅读也很愉快。

实际上，我会从Python中窃取很多想法，因为Python是一种非常好的语言。我将其用于陈述，并复制其地图，列表和元组。

现在，我可能不会采用Python的动态概念：一方面，它可能是显式和静态类型的。我认为程序由此变得更加清晰。变量可能都是带有方法的对象，然后您可以执行一些操作str.length()来获取字符串的长度。在函数定义中，您必须指定返回类型和参数类型（也支持某种通用类型）。

让我们回到从Python ;-)复制。我喜欢这样的方法，它具有可选的过程参数，所以我可能会有。但是，Python不支持过程重载，我希望这样做。

让我们看一下类，我将放弃多重继承；容易被滥用。我将实现私有范围和类似范围，并且可能会以C ++的方式实现该范围。我还将有抽象类和接口；我不相信Python可以做到这一点。

它会支持内部类，实际上，我想要一种非常强大的面向对象语言。

它可能会被解释。使用良好的JIT编译可以使它真正快速地实现（我希望使用一种快速的语言，尽管程序员的工作效率是第一位的），并且编译在很多时候都不利于生产率。口译语言还可以促进平台独立性，这一点在每天越来越重要。

它将具有内置的Unicode支持；这些天国际化很重要。

肯定是垃圾收集。该死的，我讨厌自己做内存管理。也不利于生产力。

最后，它将有一个好的标准库。

哇，刚刚意识到我真的很喜欢Python。

首先，我会买几本有关编译器的书籍，一些标准，并学习一门或两门语言和编译器课程。我将提供PEP并访问C ++标准委员会会议。我会为我使用的编译器提供补丁，希望对功能和错误都有贡献。

然后我回头看看现在出现的这个列表，这很恐怖，如果我现在开始的话，这就是我要使用的语言的方向：

• 功能性的，因为我目前不精通任何一种功能性语言，因此编写一种语言将是学习一种功能性语言的好方法。万一它不是直接跟随的： 一切都是常数。
• 我将使用尽可能多的类型推断来填充它，但是可以选择显式指定接口。不确定其他类型。缺省情况下，所有功能都是通用的，因此可以翻倍。
• 您可能已经猜到了，使用Interfaces；也就是说，使用仅对可用操作提供承诺的类型。
• 据我所知，在这种情况下说语言是强类型还是弱类型并不是很有意义。我将其称为强类型，因为事情永远不会改变它们实现的接口。
• 它将有很多“ 按合同设计”支持。再次，我尽可能地满足：先决条件和后置条件是必须的；对于函数式编程，我不知道有多少不变性。
• 在讨论的过程中，我将看一看可以正式证明其正确性的语言，看看我是否可以从中获得任何东西。
• 我出去写一个很棒的测试库。即使万一我无法使它很棒，我也至少要花费大量的时间来研究它，因为我认为这是每种语言都应该具备的。
• 至于语法，语言要么有显著的空白，并期待了很多像Python，或将它基于逻辑语和共享大量的语法和词汇。在第一种情况下，我将尽全力使语法尽可能接近CFG。
• 我不在乎使用该语言的人是否会事先对其进行编译，JIT，解释，在篝火旁歌颂它，还是付钱给大学生为他们执行。我自己的实现可能会以解释器或C编译器开始，并最终转向JITter。

如果我开始实施该语言，那么即使这些相当宽泛的观点也可能会迅速改变，所以我认为无需进一步详细介绍。

如果有时间，我会设计一种基于Scala 的可本地化的编程语言，因此它将具有其大多数功能，但XML可能除外。我的目标是要使一种语言能够自然地以不同于英语的语言阅读，例如阿拉伯语（我的母语）。我正在考虑以下功能：

• 预处理程序#lang指令，用于通知预处理程序用于编程的人类语言。例如：#lang ar将允许使用单词فئة代替class，عرف代替def等等。特定于人工语言的关键字将在标准预处理器文件中定义。
• 预处理程序将删除一些唯一的关键字，其唯一目的是增加代码的清晰度。例如，它将删除in class MyClass is composed of {成为“由...组成” class MyClass {，并删除in def MyMethod(x: Int) as {成为“ as” def MyMethod(x: Int) {。在某些（人类）语言中，这将使代码更易于理解，尤其是对于学生而言。
• 编译器将允许使用前缀表示法进行属性访问。对于大多数以拉丁语为母语的人来说，这可能没有任何意义，但对于其他一些语言，则完全有道理。例如，阿拉伯语中的属性访问通常是前缀，如中的اعرض طول اسم محمد，这等同print(length(name(Mohammad)))于编程英语。（括号是为了清楚起见。）

我相信，对预处理器和编译器的这些最小改动会使非英语使用者的编程变得更加简单。