**提示**：此条目的主题不是**occam**。 

**OCaml**（/oʊˈkæməl/ *oh-KAM-əl*），是一个函数式、指令式、模块化、面向对象的通用的编程语言。在Xavier Leroy（英语：）和Damien Doligez（英语：），于1990年和1991年实现的ML方言Caml Light之上，Didier Rémy和Jérôme Vouillon，于1996年增加了面向对象特征，从而形成了"Objective Caml"，在2011年时重命名为"OCaml"。

OCaml工具链包括交互式顶层解释器、字节码编译器、优化的本机代码编译器，可逆调试器和一个包管理器（OPAM）。OCaml最初开发于自动定理证明的场景中，并在静态分析和形式方法软件中有超凡的存在感。此外，它在系统编程、网页编程和金融工程及其他应用领域都有严肃的应用。

历史上，Ascánder Suárez于1987年基于Guy Cousineau（法语：）的范畴抽象机器（英语：）（CAM），重新实现了Gérard Huet（英语：）早先的ML方言，并用"范畴抽象机语言"的首字母简写将其命名为Caml，Caml Light放弃了这个抽象机器又进行了重新实现。OCaml是开放源代码项目，此项目的管理和大部分维护工作，已经交由法国国家信息与自动化研究所（INRIA）。在2000年代早期，来自OCaml的元素被很多语言接纳，特别是F#和Scala。

哲学
--

ML派生语言最著称的是静态类型系统和类型推论编译器。OCaml将函数式、指令式和面向对象编程统一于类ML的类型系统之下。因此编程者不需要为了使用OCaml而非常熟悉纯函数式编程范型。

通过要求编程者在静态类型系统的约束下工作，OCaml消除了关联于动态类型语言的很多有关于类型的运行时间问题。还有，OCaml的类型推论编译器，极大的减少了在多数静态类型语言中对手工类型标注的需要。例如，变量的数据类型和函数的签名，通常不需要像Java和C#语言中那样显式的声明，因为它们可以从应用于这个变量和代码中其他值的算符和其他函数推论出来。有效的使用OCaml的类型系统可能要求一个编程者面对一些复杂性，但是这种规矩能得到可靠的、高性能软件作为回报。

OCaml与源于学术界的其他语言的最显著区别可能是强调了性能。它的静态类型系统防止了运行时间类型不匹配，从而排除了动态类型语言运行时间类型和安全检查的性能负担，却在除了关闭数组边界检查，和使用一些类型不安全特征比如序列化之外的情况下，仍能保证运行时间安全性。这些运行时间检查需求足够罕见，在实践中完全可以避免。

在类型检查开销之外，函数式编程语言，要编译成高效的机器语言代码，由于如函数参数问题（英语：）这样的要点，一般而言是具有挑战性的。与标准的循环、寄存器和指令优化一起，OCaml的优化编译器采用静态程序分析方法，来优化值包装（英语：）（boxing）和闭包分配，帮助结果代码得到最大化的性能，即使它大量使用了函数式编程构造。

Xavier Leroy（英语：）曾经宣称："OCaml至少提供了像样的C编译器的50%的性能"，尽管直接比较是不可能的。在OCaml标准库中的一些函数，是采用比在其他语言标准库中等价的函数更快的算法实现的。例如，在OCaml标准库中集合并集的实现，在理论上比指令式语言（例如C++、Java）的标准库中的等价函数，要渐进性的更快，因为OCaml实现利用了集合的不可变性，而在输出中重用了输入集合的一些部份（参见可持久化数据结构）。

特征
--

OCaml的特征包括：静态类型系统、类型推论、参数多态、尾递归、模式匹配、头等词法闭包、函子（参数化模块）、异常处理和增量分代自动垃圾回收。

OCaml著称于将ML风格类型推论，扩展到通用语言中的对象系统。这允许了结构子类型（英语：），这里的对象类型是兼容的，如果它们的方法签名是兼容的，不用管它们声明的继承，这是在静态类型语言中不寻常的特征。

OCaml提供了链接到C原语的外界函数接口（英语：），包括了兼容于C和Fortran二者格式的对高效数值数组的语言支持。OCaml还支持建立可以链接到用C写的`main`程序的OCaml函数库。

OCaml发行包含了：

* 词法分析和语法解析工具分别叫做`ocamllex`和`ocamlyacc`。
* 支持步进回溯的调试器用来调查错误。
* 文档生成器（英语：）。
* 剖析器用来测量性能。
* 很多通用函数库。

本机代码编译器可以在很多平台上获得，包括Unix、Microsoft Windows和Apple macOS。可移植性是通过至此主要架构的本机代码生成（英语：）实现的：IA-32、X86-64（AMD64）、Power（英语：）、RISC-V、ARM和ARM64。

OCaml字节码和本机代码程序可以用多线程风格书写，具有抢占式上下文切换。但是由于当前唯一可得的语言完全实现INRIA OCaml的垃圾回收器，不是为并发性而设计的，对称多处理是不支持的。在相同进程中的OCaml线程只能分时执行。但是有一些分布式计算库比如Functory和Plasma。

代码例子
----

OCaml的代码片段可以通过键入到顶层REPL中来很容易的研习。这是一个交互式的OCaml会话，它打印结果或定义的表达式的推论出的类型。OCaml顶层可以通过简单执行OCaml程序来启动：

```
$ ocaml
 OCaml version 4.13.1

#

```

可以接着在`#`提示符处键入代码。例如计算`1+2*3`:

```
# 1 + 2 \* 3;;
- : int = 7

```

OCaml推论出这个表达式的类型是`int`（机器精度整数）并给出结果`7`。

### Hello World

下面的程序`hello.ml`:

```
print\_endline "Hello World!"

```

可以被编译成字节码可执行文件：

```
$ ocamlc hello.ml -o hello

```

或者被编译成优化的本地代码可执行文件：

```
$ ocamlopt hello.ml -o hello

```

接着执行它：

```
$ ./hello
Hello World!

```

给ocamlc的第一个实际参数`hello.ml`，指定要编译的源文件而`-o hello`标志指定了输出文件。

### 阶乘函数

很多数学函数，比如阶乘，可以很自然的表示为纯粹的函数形式：

```
let rec fact n =
  if n=0 then 1 else n \* fact(n - 1);;

```

这个函数可以使用模式匹配等价的写为：

```
let rec fact = function
  | 0 -> 1
  | n -> n \* fact(n - 1);;

```

后者形式是阶乘作为递推关系的数学定义。

编译器将这个函数的类型推论为`int -> int`，意味着这个函数将`int`映射到`int`。例如，`12!`：

```
# fact 12;;
- : int = 479001600

```

### 斐波那契序列

下列代码计算输入数`n`的斐波那契数列。它使用了尾递归和模式匹配。

```
let fib n =
  let rec fib\_aux m a b =
    match m with
    | 0 -> a
    | \_ -> fib\_aux (m - 1) b (a + b)
  in fib\_aux n 0 1;;

```

### 生日问题

下列程序计算在一个屋子里面有完全唯一的生日概率小于50%的最少人数，在生日问题中，对于1个人这个概率是365/365（或100%），对于2个人是364/365，对于3个人是364/365 × 363/365，最终答案是23个人：

```
let year\_size = 365.
let rec birthday\_paradox prob people =
  let prob = (year\_size -. float people) /. year\_size \*. prob  in
  if prob < 0.5 then
    Printf.printf "answer = %d\n" (people+1)
  else
    birthday\_paradox prob (people+1);;

```

```
# birthday\_paradox 1.0 1;;
answer = 23
- : unit = ()

```

### 合计整数列表

列表是OCaml中的基础数据类型之一。下面的代码例子定义递归函数`sum`，它接受一个实际参数`integers`，而它被假定为整数的列表。注意关键字`rec`指示了这个函数是递归的。这个函数递归的在给定整数列表之上进行迭代，并提供这些元素的一个总和。`match`语句类似于C的`switch（英语：）`语句，但要更加一般性。

```
let rec sum integers =                   (\* 关键字rec含义为递归。 \*)
  match integers with
  | [] -> 0                              (\* 产生0，如果integers为空列表 []。 \*)
  | first :: rest -> first + sum rest;;  (\* 递归调用，如果integers是非空列表；
 first是这个列表的第一个元素，
 而rest是余下元素的列表，可能是[]。 \*)

```

```
# sum [1;2;3;4;5];;
- : int = 15

```

另一种方式是对列表使用标准的fold高阶函数:

```
let sum integers =
  List.fold\_left (fun accumulator x -> accumulator + x) 0 integers;;

```

```
# sum [1;2;3;4;5];;
- : int = 15

```

因为匿名函数是简单的`+`算符应用，它可以简写为：

```
let sum integers =
  List.fold\_left (+) 0 integers

```

进一步的，还可以通过采用部份应用（英语：）省略列表实际参数：

```
let sum =
  List.fold\_left (+) 0

```

### 快速排序

OCaml自身可提供对递归算法的简介表达。下列代码例子实现了类似于以升序排序一个列表的quicksort的一个算法：

```
 let rec qsort = function
   | [] -> []
   | pivot :: rest ->
     let is\_less x = x < pivot in
     let left, right = List.partition is\_less rest in
     qsort left @ [pivot] @ qsort right;;

```

### 高阶函数

函数可以接受函数作为参数并且返回函数作为结果。例如，应用`twice`到函数`f`产生应用`f`到它的实际参数两次的一个函数：

```
let twice (f : 'a -> 'a) = fun (x : 'a) -> f (f x);;
let inc (x : int) : int = x + 1;;
let add2 = twice inc;;
let inc\_str (x : string) : string = x ^ "" ^ x;;
let add\_str = twice(inc\_str);;

```

```
# add2 98;;
- : int = 100
# add\_str "Test";;
- : string = "Test Test Test Test"

```

函数`twice`使用类型变量`'a`，来指示它可以应用于映射一个类型`'a`到自身的任何`f`，而非只应用于`int->int`函数。特别是，`twice`甚至可以应用于自身：

```
# let fourtimes f = (twice twice) f;;
val fourtimes : ('a -> 'a) -> 'a -> 'a = <fun>
# let add4 = fourtimes inc;;
val add4 : int -> int = <fun>
# add4 98;;
- : int = 102

```

### 邱奇数

下列代码定义自然数的邱奇编码，具有后继（succ）和加法（add）。邱奇数`n`是接受一个函数`f`和一个值`x`的一个高阶函数，它应用`f`到`x`精确的`n`次：

```
let zero f x = x
let succ n f x = f (n f x)
let one = succ zero
let two = succ (succ zero)
let add n1 n2 f x = n1 f (n2 f x)
let to\_string n = n (fun k -> "S" ^ k) "0";;

```

为了将一个邱奇数从函数值转换成一个字符串，这里把它传递给向其输入和常量字符串`"0"`前置上字符串`"S"`的函数`to_string`：

```
# let \_ = to\_string (add (succ two) two);;
- : string = "SSSSS0"

```

### 对象例子

在OCaml中对象，通过它们的方法的名字和类型，按结构来确定类型。对象可以直接创建（立即对象），而不用通过有名称的类。例如：

```
# let x =
    object
      val mutable x = 5
      method get\_x = x
      method set\_x y = x <- y
    end;;
val x : < get\_x : int; set\_x : int -> unit > = <obj>

```

这里OCaml交互式运行时间系统打印出这个对象的推论类型。它的类型`< get_x : int; set_x : int -> unit >`，只由它的方法来定义。换句话说，`x`的类型由方法类型`get_x : int`和`set_x : int -> unit`而非任何名字来定义。类只充当建立对象的函数，例如上例中的对象可以用类来定义，并接着用`new`算符来建立：

```
# class simple\_cls =
    object (self)
      val mutable x = 5
      method get\_x = x
      method set\_x y = x <- y
    end;;
  let x = new simple\_cls;;

```

要定义有相同的方法和方法类型的另一个对象：

```
# let y =
    object
      method get\_x = 2
      method set\_x y = Printf.printf "%d\n" y
    end;;
val y : < get\_x : int; set\_x : int -> unit > = <obj>

```

OCaml将它们视为有相同的类型。例如，等式算符被确定类型为只接受有相同类型的两个值：

```
# x = y;;
- : bool = false

```

所有尽管它们有不同的值，却必定是相同类型的，否则连类型检查都不会做完。这展示了类型等价是结构性的。可以定义调用一个方法的函数：

```
# let set\_to\_10 a = a#set\_x 10;;
val set\_to\_10 : < set\_x : int -> 'a; .. > -> 'a = <fun>

```

第一个实际参数的推论类型`< set_x : int -> 'a; .. >`是值得关注的。`..`意味着第一个实际参数，可以是有接受一个`int`作为实际参数的`set_x`方法的任何对象。所以它可以用在对象`x`之上：

```
# set\_to\_10 x;;
- : unit = ()

```

另一个对象可以碰巧有这个方法和方法类型；其他方法是无关紧要的：

```
# let z =
    object
      method blahblah = 2.5
      method set\_x y = Printf.printf "%d\n" y
    end;;
val z : < blahblah : float; set\_x : int -> unit > = <obj>

```

`set_to_10`函数对它也有效：

```
# set\_to\_10 z;;
10
- : unit = ()

```

这展示了对于事物比如方法调用的兼容性是由结构来确定的。下面为只有一个`get_x`方法而没有其他方法的对象定义一个类型同义词（synonym）：

```
# type simpler\_obj = < get\_x : int >;;
type simpler\_obj = < get\_x : int >

```

对象`x`不是这个类型的；但在结构上`x`是这个类型的一个子类型，因为`x`包含它的方法的一个超集。所以`x`可以强制（coerce）成这个类型：

```
# (x :> simpler\_obj);;
- : simpler\_obj = <obj>
# (x :> simpler\_obj)#get\_x;;
- : int = 10

```

但是对象`z`不行，因为它不是一个结构子类型：

```
# (z :> simpler_obj);;
Error: Type < blahblah : float; set\_x : int -> unit > is not a subtype of
 simpler\_obj = < get\_x : int > 
 The first object type has no method get\_x

```

这展示了拓宽强制的兼容性是结构性的。

### 任意精度阶乘函数

可以从OCaml访问各种各样的库。比如，OCaml有内建的任意精度算术。由于阶乘函数增长得非常迅速，会很快溢出机器精度的整数。因此阶乘很适合选用任意精度算术。

在OCaml中，`Num`模块（现在被`ZArith`所取代）提供了任意精度算术，比如在Ubuntu中安装它：`sudo apt install libnum-ocaml-dev`，它可以如下这样装载到运行中的顶层中：

```
#use "topfind";;
#require "num";;
open Num;;

```

阶乘函数可以使用任意精度算符`=/`、`*/`和`-/`写为：

```
let rec fact n =
  if n =/ Int 0 then Int 1 else n \*/ fact(n -/ Int 1);;

```

这个函数可以计算非常大的阶乘比如`120!`：

```
# string\_of\_num (fact (Int 120));;
- : string =
"6689502913449127057588118054090372586752746333138029810295671352301633557244962989366874165271984981308157637893214090552534408589408121859898481114389650005964960521256960000000000000000000000000000"

```

### 绘制图形例子

下列程序`simple.ml`使用OpenGL呈现一个缓慢旋转的2D三角形:

```
let () =
  ignore (Glut.init Sys.argv);
  Glut.initDisplayMode ~double\_buffer:true ();
  ignore (Glut.createWindow ~title:"OpenGL Demo");
  let angle t = 10. \*. t \*. t in
  let render () =
    GlClear.clear [ `color ];
    GlMat.load\_identity ();
    GlMat.rotate ~angle: (angle (Sys.time ())) ~z:1. ();
    GlDraw.begins `triangles;
    List.iter GlDraw.vertex2 [-1. -1.; 0. 1.; 1. -1.];
    GlDraw.ends ();
    Glut.swapBuffers () in
  GlMat.mode `modelview;
  Glut.displayFunc ~cb:render;
  Glut.idleFunc ~cb:(Some Glut.postRedisplay);
  Glut.mainLoop ()

```

需要事先安装负责绑定到OpenGL的LablGL，比如在Ubuntu中安装它：`sudo apt install liblablgl-ocaml-dev`，这个程序可以如下这样编译成字节码：

```
$ ocamlc -I +lablGL lablglut.cma lablgl.cma simple.ml -o simple

```

或编译成本机代码：

```
$ ocamlopt -I +lablGL lablglut.cmxa lablgl.cmxa simple.ml -o simple

```

或者简单的使用`ocamlfind`建造命令：

```
$ ocamlfind opt simple.ml -package lablgl.glut -linkpkg -o simple

```

然后运行：

```
$ ./simple

```

可以使用OCaml开发非常复杂、高性能的2D和3D图形程序。使用OpenGL和OCaml，结果的程序可以跨平台编译而在主要平台上无需改动。

用OCaml写成的程序
-----------

* Coq，一个形式证明辅助器。
* HOL Light（英语：），一个形式证明辅助器。
* Coccinelle（英语：），用于C程序源代码变换（英语：）的实用工具。
* Frama-C（英语：），分析C程序的一个框架。
* Flow，Facebook创建的用于推论和检查JavaScript的静态类型的一个静态分析器。
* Infer，Facebook创建的用于Java、C、C++和Objective-C的静态分析器，用来检测iOS和Android应用中的缺陷。
* pyre-check，Facebook创建的用于Python的类型检查器。
* Hack编程语言编译器，Facebook创建，扩展PHP具有静态类型。
* Haxe编程语言编译器。
* WebAssembly参考解释器，它是意图在web浏览器内执行的低层字节码。
* FFTW（英语：），C的FFT库，它的多数性能关键代码是由用OCaml写的一个程序生成的。
* Owl科学计算（英语：），用于科学和工程计算的专用系统。
* MirageOS，用纯OCaml写的一个单一内核编程框架。
* Ocsigen（英语：），一个OCaml的web应用框架。
* Opa（英语：），用于Web开发的自由和开源的一个编程语言。
* 0install（英语：），一个多平台包管理器。
* MLDonkey，一个多网络P2P程序。
* Unison（英语：），一个文件同步器。

参见
--

* Caml，OCaml的先驱语言。
* F#，由MSR开发，是一个基于OCaml的一个以.NET为目标的编程语言。
* F\*，由MSR和INRIA主导开发，是一个基于OCaml的依赖类型函数式程序语言。
* Reason，OCaml的语法扩展和工具链，也可以转译成JavaScript。

有关书籍
----

* Yaron Minsky, Anil Madhavapeddy.. 2021  [2021-09-10]. （原始内容存档于2022-05-14）.
* Emmanuel Chailloux, Pascal Manoury, Bruno Pagano.  (PDF). 2000  [2021-09-10]. （原始内容 (PDF)存档于2022-02-23）.
* Jason Hickey.. 2002  [2021-09-10]. （原始内容存档于2021-09-10）.

引用
--

1. 1 2 3  Xavier Leroy.  (PDF). Principles of Programming Languages. 1994  [2021-09-06]. （原始内容 (PDF)存档于2021-10-22）.
2. 1 2  Didier Rémy.. Research Report RR-1431, INRIA. 1991  [2021-09-10]. （原始内容存档于2022-04-06）.   
Didier Rémy, Jérôme Vouillon.  (PDF). 1997  [2021-09-06]. （原始内容 (PDF)存档于2022-01-21）.   
Didier Rémy, Jérôme Vouillon.  (PDF). 1998  [2021-09-06]. （原始内容 (PDF)存档于2022-01-20）.
3. ↑ .  [2023年12月27日].
4. ↑ .  [2021-08-28]. （原始内容存档于2021-08-29）.
5. ↑  Xavier Leroy（英语：）.. 1997  [2021-09-02]. （原始内容存档于2022-03-08）.
6. ↑  Xavier Leroy.. 1997  [2021-09-02]. （原始内容存档于2022-01-23）.
7. ↑ .  [2021-09-02]. （原始内容存档于2022-04-13）. Our main reason for developing Caml was to use it for sofware development inside Formel. Indeed, it was used for developing the Coq system ……. We were reluctant to adopt a standard that could later prevent us from adapting the language to our programming needs. ……We did incorporate into Caml most of the improvements brought by Standard ML over Edinburgh ML. ……The first implementation of Caml appeared in 1987 and was further developed until 1992. It was created mainly by Ascander Suarez. ……  
In 1990 and 1991, Xavier Leroy designed a completely new implementation of Caml, based on a bytecode interpreter written in C. Damien Doligez provided an excellent memory management system. ……In 1995, Xavier Leroy released Caml Special Light, which improved over Caml Light in several ways. In 1995, Xavier Leroy released Caml Special Light, which improved over Caml Light in several ways. First, an optimizing native-code compiler was added to the bytecode compiler. ……Second, Caml Special Light offered a high-level module system, designed by Xavier Leroy and inspired by the module system of Standard ML. ……Didier Rémy, later joined by Jérôme Vouillon, designed an elegant and highly expressive type system for objects and classes. This design was integrated and implemented within Caml Special Light, leading to the Objective Caml language and implementation, first released in 1996 and renamed to OCaml in 2011.
8. ↑  G. Cousineau, P.-L. Curien, M. Mauny.. 1985  [2021-09-03]. （原始内容存档于2021-09-03）.  LNCS, 201, Functional programming languages computer architecture, pp.~50-64.  
Michel Mauny, Ascánder Suárez.  (PDF). 1986  [2021-09-07]. （原始内容 (PDF)存档于2022-01-28）.  LFP '86: Proceedings of the 1986 ACM conference on LISP and functional programming, Pages 266–278.
9. ↑  G. Cousineau, M. Gordon, G. Huet, R. Milner, L. C. Paulson, C. Wadsworth.. Internal document. Project Formel, INRIA. July 1985.   
Christoph Kreitz, Vincent Rahli.  (PDF). 2011  [2021-09-11]. （原始内容 (PDF)存档于2022-01-29）. This handbook is a revised edition of Section 2 of ‘Edinburgh LCF’, by M. Gordon, R. Milner, and C. Wadsworth, published in 1979 as Springer Verlag Lecture Notes in Computer Science no 78. ……The language is somewhere in between the original ML from LCF and standard ML, since Guy Cousineau added the constructors and call by patterns. This is a LISP based implementation, compatible for Maclisp on Multics, Franzlisp on VAX under Unix, Zetalisp on Symbolics 3600, and Le Lisp on 68000, VAX, Multics, Perkin-Elmer, etc... Video interfaces have been implemented by Philippe Le Chenadec on Multics, and by Maurice Migeon on Symbolics 3600. The ML system is maintained and distributed jointly by INRIA and the University of Cambridge.
10. ↑  Guy Cousineau, Gérard Huet（英语：）.. 1990  [2021-09-07]. （原始内容存档于2022-05-04）.  RT-0122, INRIA. pp.78.  
Pierre Weis, Maria Virginia Aponte, Alain Laville, Michel Mauny, Ascander Suarez.. 1990  [2021-09-07]. （原始内容存档于2022-04-06）.  [Research Report] RT-0121, INRIA. pp.491.
11. ↑  Xavier Leroy.. 1990  [2021-09-06]. （原始内容存档于2022-04-06）.  RT-0117, INRIA.
12. ↑  Linux Weekly News （页面存档备份，存于）.
13. ↑ . GitHub.  [2 May 2015]. （原始内容存档于2022-05-07）.
14. ↑ .  [2021-09-10]. （原始内容存档于2022-03-31）.
15. ↑ .  [2021-08-30]. （原始内容存档于2022-01-20）.
16. ↑ .  [2021-08-30]. （原始内容存档于2022-03-23）.
17. ↑ . ocaml.org.  [2021-05-17]. （原始内容存档于2021-09-11）.
18. ↑  Batch compilation (ocamlc) （页面存档备份，存于）.
19. ↑ .  [2021-09-10]. （原始内容存档于2022-03-10）.
20. ↑  Coq（页面存档备份，存于）
21. ↑ .  [2021-08-29]. （原始内容存档于2022-04-08）.
22. ↑ .  [2021-08-29]. （原始内容存档于2022-05-12）.
23. ↑ . 9 February 2019  [2021-08-29]. （原始内容存档于2022-05-05） –GitHub.
24. ↑ . World Wide Web Consortium. 5 December 2019  [2021-05-14]. （原始内容存档于2022-05-12） –GitHub.
25. ↑  FFTW（页面存档备份，存于）
26. ↑ .  [2021-08-29]. （原始内容存档于2022-04-20）.
27. ↑ .  [2021-08-28]. （原始内容存档于2021-07-12）.

外部链接
----

|  |  |
| --- | --- |
|  | 維基教科書中的相關電子：**OCaml** |

* 官方网站 在维基数据上编辑此内容
* OCaml manual （页面存档备份，存于）
* OCaml Package Manager （页面存档备份，存于）
* Awesome OCaml （页面存档备份，存于）



|  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 

| * 
* 论
* 编
程序设计语言 |
| --- |
|  |
| 按范型 | 

|  |  |
| --- | --- |
| 过程式 | 
* FORTRAN
* COBOL
* JOVIAL
* ALGOL 60
* JOSS（英语：）
* BASIC
	+ QB64（英语：）
* PL/I
* MUMPS（英语：）
* ALGOL 68
* Forth
* Pascal
	+ Turbo Pascal
* C
* Modula-2
* Ada 83
* occam
* Oberon
* Go
* Zig

 |
|  |
| 面向对象 | 
* Simula 67
* Smalltalk
* Objective-C
* Eiffel
* Object Pascal
	+ Delphi
* Self
* Visual Basic
	+ Gambas
* Ada 95
* Java
* C#
	+ Vala
* Fantom（英语：）
* Crystal（英语：）

 |
|  |
| 多范型 | 
* C++
* Modula-3
* Dylan
* Python
* Lua
* JavaScript
* Ruby
* D
* Factor
* Scala
* F#
	+ F\*
* Haxe
* Dafny（英语：）
* Nim
* Rust
* Dart
* Julia
* Swift
* Bosque（英语：）

 |
|  |
| 函数式 | 

|  |
| --- |
| 
* LISP
	+ Scheme
	+ Common Lisp
	+ Clojure
* Logo
* APL/J
* ML
	+ Standard ML
	+ OCaml
* Erlang
	+ Elixir
* Haskell
	+ Curry
* SAC
* Agda
* Idris
* Pure（英语：）
* jq（英语：）
* Cuneiform

 |

 |
|  |
| 逻辑式 | 
* Prolog
* Datalog
* Mercury
* AnsProlog

 |

 |
|  |
| 脚本语言 | 

|  |  |
| --- | --- |
| 动态语言 | 
* SNOBOL
* Icon
* REXX
* Perl
	+ Raku
* Tcl/Tk
* CLOS
* newLISP
* Python
* Lua
* Ruby
* PHP
	+ Hack
* CFML（英语：）
* REBOL
	+ Red（英语：）
* Julia

 |
|  |
| Shell语言 | 
* Unix shell
	+ sh/ash
	+ csh/tcsh
	+ ksh
	+ bash
	+ zsh
	+ rc（英语：）
	+ fish
* sed
* AWK
* PowerShell

 |
|  |
| ECMA-262 | 
* ECMAScript
	+ JavaScript
* TypeScript
* Node.js/Deno
* CoffeeScript/LiveScript（英语：）
* Elm
* PureScript
* Reason

 |

 |
|  |
| 特定平台 | 

|  |  |
| --- | --- |
| .NET | 
* C#
* C++/CLI
* F#
* PowerShell
* VB.NET
* Small Basic

 |
|  |
| JVM | 
* Java
	+ AspectJ（英语：）
* Scala
* Clojure
* Groovy
* Kotlin

 |

 |
|  |
| 特定领域 | 

|  |  |
| --- | --- |
| 科学计算 | 
* Speakeasy（英语：）
* IDL
	+ GDL
* Maxima
* Maple
* MATLAB
	+ Octave
	+ Scilab
* Wolfram
* R
* Yorick（英语：）
* SageMath
* Julia

 |
|  |
| GPU计算 | 
* Cg/HLSL
* GLSL
* Brook（英语：）
* OpenCL
* CUDA/PTX（英语：）
* Futhark
* SYCL
* SPIR-V（英语：）

 |
|  |
| 数据查询 | 
* SQL
	+ PL/SQL
	+ T-SQL
	+ SQL/PSM（英语：）
* xBase（英语：）
* XPath
* XQuery（英语：）
* GraphQL

 |
|  |
| 可视化 | 
* Simulink
* LabVIEW
* Orange（英语：）
* KNIME（英语：）
* Scratch
	+ Snap!
* Power Fx

 |
|  |
| 传媒设计 | 
* SuperCollider
* Pure Data
* Processing
* ChucK

 |

 |
|  |
| 其它 | 
* 汇编语言
* APT（英语：）
* GPSS（英语：）
* dc
* make
* PostScript
* XSLT
* LLVM IR
* WebAssembly

 |
|  |
| 
* 分类 目录
* 列表级条目 列表
* 历史
* 比较（英语：）
* 时间线（英语：）

 |

 |