编程语言是整个程序活动中最重要的部分，如同人说话一样，说话是用于表达思想，与人沟通。类似，编程语言是程序员表达思想，与计算机沟通的。

对于计算机而言，能理解的只是电流高低，对应即二进制10。这称为机器语言。计算机内部由集成电路铺就，会有一些处理器元件存在，通过算术逻辑单元(ALU),能进行简单的逻辑运算：与、或、非、移位、比较以及简单的加、减、乘运算。

如今的计算机软件层出不穷，百花齐放，规模也逐年增大，但计算机底层硬件仍然是没有变化。

那么如何让计算机按照我们的意愿去工作？我们这时需要指令。指令是计算机能理解的电流信号。程序员需要编写指令，来让计算机达到计算的

目的，让计算机表现出智能。那么计算的内容又如何确定呢？

计算机只能做计算，计算机的智能是人为赋予的。这是一直没有改变的事实。

那么，如何才能赋予计算机智能呢？用计算机能理解的语言沟通，即指令。程序员编写指令，交给计算机，计算机进行计算，反馈出结果。就如同你要让一个外国人帮你做事，那么你得发出让她听得懂的语言，她才能理解，才能顺着你的意思去做。但计算机只懂二进制，那我们要写二进制吗？是的，肯定要的。先辈们就是写二进制的，最初使用打孔纸条，后来使用汇编语言，后来经过先辈们的一代代努力，为了让程序员更简单地命令计算工作，如今编程语言百花齐放，成千上万种。

只要让计算机工作，那么肯定逃不开二进制语言。所以，无论何种语言，最终都会变换成二进制语言。编程语言的选择，完全取决于程序员自己。是程序员创造了编程语言。每种编程语言有其自身适应业务，比如使用汇编语言可以直接面向硬件编程，因为汇编语言很容易转换成机器语言；使用C语言，可以面向系统编程，因为大多数系统本身是使用C语言写就；使用JavaScript可以面向浏览器编程，因为浏览器核心可以解释JavaScript代码等等。

所有的编程语言，无论其如何变化，其实质是没有改变的，所谓万变不离其宗。编程语言的核心，仍然是指示计算机工作。编程语言在机器语言之上，构建出了更利于人类使用的概念。如Ruby，Python，C++，Rust，Go等等，都是介于人类和机器之间的语言。人类通过学习编程语言，按照编程语言的语法规则表达思想，写成程序，编程语言将这些程序按照解释规则，转换成机器语言，交由机器进行运算。这是人类和机器进行沟通的方式。机器和人类沟通的方式，则由先辈们具象化了，即：机器的反馈是以人类能理解的方式表现，如声音、图像、文字、视频等。

那编程语言都有的是什么东西呢？这要从程序本身入手。程序本身是由指令和数据组成，演化为如今是算法与数据结构。指令或算法，在编程语言中，通常表现为：控制语句、逻辑判断、基础运算等；数据，更多指的是数据的存储。

在编程语言中，常常分为两派：C和Lisp。

C语言是从汇编发展而来，很多概念也继承过来。其中的核心为指令，它将指令分为了：控制语句、逻辑判断语句、运算符、跳转语句等。数据则分为整数、小数、指针等基本数据，以及数组、结构体等数据结构。

Lisp语言则承自数学，是数学与计算机相结合的结晶。它的核心是演算。它以表为基础，以函数为中心原则。它的数据就是以表指代，它的指令皆为函数。

现今的编程语言，都是从这两者发展而来。不过在它们基础之上，附加了更多概念。如，附加面向对象概念，是为了解决大型软件开发中的代码复用、扩展等问题；附加函数式概念，是为了解决并行运算中的数据安全等问题。

C系代表着性能、状态、副作用、嵌入式；Lisp系代表着灵活、太极(元能力)、慢。

编程语言通用概念

注释：解释源码的注解文字

注释常常在解释或编译时会被丢弃，用于给代码阅读者以参考。

变量：用于存储数据。

变量用于存储数据，会在内存中有其空间。静态编程语言中，每个变量都要有数据类型，用于预分配内存空间；动态编程语言变量的类型是动态的，内存不固定，所以常常伴随垃圾回收机制。

字面量：是一个固定值的表示法。

用于赋值给变量。字面量是原值，本身不可改变。如字面量10和字面量11，代表的是不同的值。如：

10,0x1001,020,"string",true,5.83,3.14e2
[1,2,3],(1,2,3)
{name:"Xiao",age:30}

符号：是指代内容的字串。

是不可更改的，是由编译器或解释器使用的文本，如：

a = 10
a = "name"
a = @b

a是变量，在最初赋值为10，之后赋值为”name”，但最后赋值为b所具有的值。其中，文本a和文本@b就是符号，10和”name”是字面量。但a和@b是变量。

函数/过程/方法/lambda表达式：运算规则

函数是从数学发展而来，用于表述参数的运算规则。函数可以有返回值，也可以没有返回值。没有返回值的函数，通常称为过程。

def ==(a,b)
    a.age == b.age
end

运算符：符号化函数

运算符是从数学发展过来，其本质还是一种运算规则，是一种符号化的函数。所以，也可以把运算符当作函数。

(+ 1 2)
(/ 3 4)
(> 3 4)

流程控制：控制程序非线性执行

流程控制通常有两种：分支和循环。分支常通过逻辑判断来进行，对不同的条件进行测试，来选择其中一个分支执行。循环通常为有限循环与无限循环。在计算机中，通常不存在无限这样的概念。因此，我们常说的循环，即是有限循环。对于不同的语言，循环有这样几种方式：迭代、递归。两者作用一致。

块、作用域与闭包：变量生存周期

有些变量是临时的，用完即销毁，这就涉及作用域。作用域是限定变量起作用的范围，也称为生命周期，出了作用域，变量即销毁。对于函数执行而言，通常会有执行环境，此运行环境通常不做存储，但闭包会读取此运行环境，以做特殊用途。常见的是用在回调函数情形下。

模块/包/命名空间/库：可供复用的代码集合

如今的程序规模越来越庞大，也越来越精细，往往一个软件的完成，需要多人共同努力完成。代码复用即为了应对这种问题。在代码复用的基础上，产生了许多概念，如库、包、模块等。

数据结构：数据组织方式

数据结构在编程语言中，或多或少都有实现，最典型的是数组/列表，几乎所有高级编程语言都有这个概念。随着软件规模扩大化，处理的数据也越来越多，简单地数据结构已经很难应付如今复杂的问题，所以很多编程语言将多种数据结构要么内置于语言，要么置于标准库。内置于语言，多见于脚本语言，它们用于解决日常问题；外置于标准库，可保证语言核心简洁。如你所见，常见数据结构放眼即是。常用数据结构有这样几种：数组、列表、哈希表。

数据结构扩展：可自由适应业务，自定义数据结构

数据结构是组织数据的形式，不仅如此，当自定数据结构时，还要有匹配的操纵这个数据结构的一系列函数存在。在C系语言中，常见struct,enum,union等，它们又称为自定数据类型

编程语言中的特殊概念

面向对象

面向对象的核心是对象——可包含数据(以字段或属性形式)和代码(以过程或方法形式)。方法可操纵字段。程序的实现是以创建大量对象并且互相交互的形式。

面向对象里的两个概念，一为类，一为实例。类是抽象的，可定义此类对象通用的属性和方法；实例是类的具象化个体。

面向对象将函数和变量分为以下几种：

• 类变量：属于整个类，所有实例共享此变量
• 实例变量或属性：术语每个实例自己的数据，每个实例都有此变量的一分副本
• 类方法：属于整个类，只能访问类变量和函数调用参数数据
• 实例方法：属于分散的对象，可访问实例变量、输入参数、类变量等。

面向对象实现3个特征：

• 封装：绑定数据和操纵这些数据的方法，并在失误使用和外部调用时保持安全。主要的是数据隐藏。主要目标是保证数据的隔离安全性。
• 动态分派/消息发送：这是对象而不是任何外部代码的职责。在响应方法调用时，在运行时查找对象关联表，以选择过程代码来执行。也就是，当通过a.do(1)函数调用时，会将消息1分发给a对象，此时a对象会从关联表中查找do方法进行调用。这称之为动态分派。当关联表中有多个同名方法时，此过程称为多重分派。
  • 多态：子类型是多态的一种形式，当调用代码时，可以不用知道它是层次结构中的哪个类。同时，继承层次结构中的同名方法其表现可不同。多态是实现动态分派的一种手段。

• 复合，继承和委托：对象可保存其他对象的实例变量，这称为对象复合。复合描述的是has-a关系。继承将所有父类的数据和方法以同名形式存在于子类，类似于完整复制，继承可以快速复用已有代码。继承描述的是is-a关系。复合和继承都能复用代码。委托也可用于替代继承。

• Mixin，Triats：是用于给类添加新的功能，既不是has-a,也不是is-a的形式。

面向对象有其好处在可重用性、可维护性。但随着并行和多线程编程越来越流行，面向对象难以处理这类问题。

面向对象的本质是抽象，越抽象，越可能称为假、大、空。面向对象代码在复用过程中，会出现冗余的情形。

OOP与其他编程语言相比，没有独特的优势，只是提供一种问题建模的方式而已，反而往往带来复杂性。创建类，就是在创建类型，往往把问题的焦点转移到了类型，而不是聚焦数据结构和算法，这有点本末倒置的嫌疑。

编程语言选择

编程语言的选择，通常选择的是编程语言的生态。只要编程语言是图灵完备的，那么它们即是等价的，即A能完成的工作B也能完成。然而，现在所有流行于市的编程语言，都是图灵完备的。所以，当面临选择时，实则是选择其生态圈。典型的例子即为C语言，C语言老而弥坚。从编程语言角度而言，C语言并非是刻意设计的编程语言，而更多的是刚好够用的设计哲学。所以，C语言本身并非坚不可催，如果不慎，就可能引发崩溃等严重错误。但，从其生态而言，C语言不可或缺——如今大多数操作系统是用C语言构建，C语言在嵌入式设备、手机、智能家电也遍地开花，也可如此说：C语言统治着智能时代的最底层基石部分。

而在互联网、网页一端，Javascript则由来已久。同样的，从语言角度出发，Javascript很低级，甚至并不高效，而且比较丑陋：怪异的模块管理方式、诡异的this关键字等等，但Javascript在逐渐演变，牢据着网页端，丝毫不松手。Javascript是网页浏览器指定官方语言，甚至蔓延至网页后端（nodejs）。

C++则巩固着游戏引擎和高性能部分，从语言层面而言，C++并没有解决C语言的易崩溃部分，原始的模块管理，低效编译、语法冗余的template等。但其继承了C语言的高效，C++的哲学是不必为你所不需要的部分买单，因此是高性能的不二之选，同时提供了面向对象，比C语言提供了更快的开发速率。当有新的语言能提供与C++相等的性能时，并且能兼容C语言所处的平台时，经过了精心设计，C++会被取缔。

Go作为新时代的编程语言，吸纳了许多编程语言的优点，其生态圈也非常丰富，占据着云服务和区块链等新生领域。从语言角度而言，Go语言是后起之秀，在设计中就规避了C++的一些问题（如编译时间长、没有包管理等），但Go语言在抉择上，也并非尽善尽美，如冗余interface、原始的错误处理机制等。

Ruby在快速网页开发中，占得一席之地，但昙花一现。Ruby从语言角度而言，非常完美、简洁，其设计哲学是为了让程序员更快乐地编程，因此很多魔法技巧都可以在Ruby中绽放，强大的DSL机制，可以快速完成任务，如同Rails其展现一样。但Ruby的生态圈并未从网站开发蔓延开来，导致其昙花一现，迅速凋零。

Python借助其简单的语法，吸收了非常多的编程新手，同时其设计哲学一件事只有一种最优解法，让有经验的程序员能专注于任务，而无须为语言层面的东西操心，提高了工作效率，也是许多专业人士的选择。Python如今基本上有取代Shell、Bat趋势，是自动化任务的首选语言，也是原型开发的试验场。基本上所有的原型开发，都可快速通过Python来实现并检测结果。由于这些原因，Python只会越来越流行，直至有某种语言比Python更易学、易用，更易于用在日常自动化工作中为止。

Java的生态，如今基本上只在Android上了。Java从语言本身而言，非常拘束，解决问题必须写类，必须了解清楚概念。甚至Java这种语言，有大批言论要应用设计模式，扬言干掉if,switch，提高程序复用性——这简直是荒唐。C#设计之初就是Java的竞争对手，C#和Java很类似，不过C#是微软的。C#语言，从语言本身而言，是经过精心设计的，但同Java一样，语法冗余。要不是Unity3D和跨平台Mono的出现和流行，C#说不定早已握死于微软之手。

Haskell、Rust、Elixir等语言，尚未形成气候，对于工作选择，面临相当大的风险——一切尚未实现的功能，都得自己实现。此时，选择这些新的语言，则需要从其设计哲学入手，来判断其未来。

那么，如此说来，总结一下现代化编程语言的语言层面：

• 模块管理或包管理、库管理：集成第三方库的形式。基本上是从网络下载并自动导入即可;当发布时，只需发布到网络即可。
• API文档自动化：管理库的文档的方式。基本上是自动生成静态网页形式，供开发者本地阅读。
• 原生并发支持：有简洁的语法，能提供并发支持，并且不易出错。现如今是async,go等子句形式，以进程、线程、协程、纤程以及原子式操作等作为底层，在其上有Actor，Channel等模式形式。函数式编程语言则直接在语言层面以非改变值形式，提供并发操作底层支持，再配合线程、Actor等，实现高并发。
• Unicode：国际码支持。
• 模式匹配、正则表达式：提供快速符号匹配支持。现在的业务基本上都是处理大量文本信息，文本信息解析效率也是比较重要的部分。
• 宏或元编程：自动生成代码，可以简化很多代码编写。在人工智能领域，有个非常重要的概念称为自我学习与自我完善，即，代码可以自更新和自修复。元编程或宏可以提供这种用途。

还有许多其他功能，可通过标准库进行扩展。语言本身应保持精简和完善，语法层面应足够完善、极富表达力，编译器或解析器层面保证复杂表达式的精确执行。

一篇有意思的文章：《跨语法语言》

Various

• 注释

  直到行尾

嵌套注释

非嵌套

• 文档注释

  直到行尾 | 标识 | 语言 | |—|—| | /// | C#, F#, Java | | -- | | Haskell | | -- ^ | Haskell |

  非嵌套 | 标识 | 语言 | |—|—| | /** ... */(3) | C, C#, E, Java, JavaScript, PHP | | (** ... *) | F# |

• 当前行和文件的信息

• 符号

  区分大小写(关键字、变量标识符等…) |规则|语言| |—|—| | case-sensitive | Awk, B, BourneShell, C, C#, C++,
  CoffeeScript, F#, FishShell, Go, Haskell,
  Io, Java, JavaScript, Lua, Maple,
  Mathematica, Matlab, merd, Modula-3,
  OCaml, Perl, Perl6, Pike, Pliant,
  Prolog, Python, Ruby, Smalltalk,
  Tcl, XML, YAML, Yorick | | case-insensitive | Ada, Assembler, Classic REXX, Common Lisp, CSS, Eiffel, Forth, HTML, Logo, Pascal, PL/I, Rebol, SGML, SQL92, Visual Basic | | case-sensitive: variablescase-insensitive: keywords, functions, constants... | PHP | | case-sensitive: identifierscase-insensitive: keywords | E | | case-sensitive: identifierscase-insensitive: commands | MUMPS | | case-sensitive: upper case disallowed | GNU-bc |

  what is the standard way for scrunching together multiple words |规则|语言| |—|—| | camelCase | CoffeeScript, JavaScript | | CamelCase or camelCase | C#, E, Go, Haskell, Io, Java, JavaScript, Mathematica, Pascal, Smalltalk, Tcl, Visual Basic | | underscores | FishShell, GNU-bc, merd | | dots | Logo | | hyphens | Common Lisp, Emacs Lisp, Rebol, Scheme | | underscores for functions / types, unclear for modules / constructors | OCaml | | UPPER_CASE | BourneShell | | lowercasenoseparator | Matlab | | underscores, UPPER_CASE for class names | Eiffel | | CamelCase for classes, underscores for methods | Python | | CamelCase for types, underscores for functions, variables, ... | Pliant | | CamelCase for methods, types and modules, underscore for functions | F# | | CamelCase for modules and classes, ALL_CAPS for constants, underscores for functions, variables, ... | Ruby | | CamelCase for modules and classes, ALLCAPS for macros, underscores for methods, constants and variables | Pike | | CamelCase for modules, ALL_CAPS for constants, unclear for functions / variables | Perl, Perl6 | | CamelCase for variables, underscores for predicates | Prolog | | usually lowercase or underscores, ALL_CAPS for macros | C | | usually underscores | C++ | | Camel_Case | Ada |

  变量标识符正则表达式 |规则|语言| |—|—| | [a-zA-Z][a-zA-Z0-9]* | FishShell, Mathematica, PL/I, Smalltalk | | [a-zA-Z][_a-zA-Z0-9]* | Eiffel, Matlab, Vimscript | | [a-zA-Z](_?[a-zA-Z0-9])* | Ada | | [_a-zA-Z][_a-zA-Z0-9]* | Awk, B, C, C#, C++, E, Go, Maple, PHP, Python, Tcl | | [_a-zA-Z0-9]+ | BourneShell, Perl, Perl6 | | [a-zA-Z0-9]+ | FishShell | | [_a-zA-Z][_a-zA-Z0-9]* or '[^']*' | Pliant | | [_a-zA-Z$][_a-zA-Z0-9$]* | Java | | [$A-Za-z_\x7f-\uffff][$\w\x7f-\uffff]* | CoffeeScript, JavaScript | | [a-zA-Z%][a-zA-Z0-9]* | MUMPS | | [_a-z][_a-zA-Z0-9]* | Ruby | | [_a-z][_a-zA-Z0-9]*[!?']* | merd | | [_a-z][_a-zA-Z0-9']* | Haskell, OCaml, SML | | [_a-zA-Z][_a-zA-Z0-9']* | F# | | [_A-Z][_a-zA-Z0-9]* | Mercury, Prolog | | [_a-zA-Z!0&*/:<=>?^][_a-zA-Z!0&*/:<=>?^0-9.+-]* | Scheme | | [a-zA-Z!?@#][a-zA-Z0-9!?@#]* | Classic REXX | | [_a-zA-Z?!.'+*&|=~-][_a-zA-Z0-9?!.'+*&|=~-]* or [^0-9[](){}":;/][^ \n\t[](){}":;/]* | Rebol | | [a-z][a-z0-9_]* | GNU-bc | | anything without a space and is not a number | Common Lisp, Forth |

  函数标识符正则表达式 (if different from variable identifier regexp) |规则|语言| |—|—| | [_a-zA-Z][_a-zA-Z0-9]*[!?]? | Ruby | | [_a-z][_a-zA-Z0-9]* | Mercury, Prolog | | [A-Z][_a-zA-Z0-9]*(7) | Vimscript | | [^ \t\n\r\f]+ | Tcl | | [^ \t\n\r\f/]+ | FishShell |

  关键字正则表达式 (if different from variable identifier regexp) |规则|语言| |—|—| | [A-Z]+ | Modula-3 | | | |

  类型正则表达式 (if different from variable identifier regexp) |规则 | 语言 | | ———————- | ————– | | [_A-Z][_a-zA-Z0-9']* | Haskell | | [_a-z][_a-zA-Z0-9']* | Mercury, OCaml |

  常量正则表达式 (if different from variable identifier regexp) |规则 | 语言 | | ———————- | ————– | | [A-Z][_a-zA-Z0-9]* | Ruby | | [_A-Z][_a-zA-Z0-9']* | Haskell, OCaml | | [_a-z][_a-zA-Z0-9']* | Mercury |

• breaking lines (useful when end-of-line and/or indentation has a special meaning)

• 变量赋值或声明

  赋值 |规则 | 语言 | | ———————- | ————– | | = | Awk, B, Basic, BourneShell, C, C#, C++, Classic REXX, Erlang, Go, Icon, Io, Java, JavaScript, Lua, Mathematica, Matlab, Oz, Perl, Perl6, PHP, Pike, YCP, Yorick | | := | Ada, BCPL, Cecil, Dylan, E, Eiffel, Maple, Mathematica, Modula-3, Pascal, Pliant, Sather, Simula, Smalltalk, SML | | <- | F#, OCaml | | _(8) | Squeak | | : | BCPL, Rebol | | ->(9) | Beta | | def | PostScript | | setq | Common Lisp, Emacs Lisp | | setf | Common Lisp | | set | Common Lisp, FishShell, Rebol | | SET v=... | MUMPS | | set! | Scheme | | is | Prolog | | make "v e | Logo | | e v ! | Forth |

  声明 |规则 | 语言 | | ———————- | ————– | | = | Haskell, Mercury, Prolog | | <- | Haskell | | :- | Prolog | | := | Io | | let v = e in | F#, OCaml | | let val v = e in | SML | | let v = e(10) | BCPL, F#, Vimscript | | def v := e / var v := e | E | | my / our / local / use vars | Perl | | my / our / temp | Perl6 | | define | Dylan, Scheme | | let let* | Common Lisp, Scheme | | letrec | Scheme | | flet labels defun defmethod defvar defparameter defsetf .. | Common Lisp | | local V1 = e V2 = e2 in ... end | Oz | | global v1, v2 | Python | | global v1 v2 | Matlab, Scilab | | :@ | Beta | | NEW v | MUMPS | | v: t | Ada, Eiffel, Pascal | | t v | C, C#, C++, Java | | var v t | Go | | | v1 v2 | | Smalltalk | | auto v1, v2; extrn v3, v4; | B | | auto | GNU-bc | | var | JavaScript, Pliant | | gvar | Pliant | | variable v(11) | Forth | | e value v | Forth | | Module[{x, y = v}, ... ] | Mathematica | | Block[{x, y = v}, ... ] | Mathematica | | With[{c1 = v1, c2 = v2, ... }, ...] | Mathematica | | <xsl:variable name="v" select="e"/> | XSLT |

  两者一起：

• 组合表达式

• block (grouping statements, especially when statements are not expressions) 块（组合语句，特别是语句不是表达式时）

• use a block as a return value (when statements are not expressions) 块作为返回值（当语句不是表达式时）

• equality / inequality

  shallow |规则 | 语言 | | ———————- | ————– | | == != | Awk, B, C, C++, CoffeeScript, F#, Go, Io, Java, OCaml, Perl, Perl6, Pike, Yorick | | = /= | Eiffel, Fortran90 | | = <> | Forth, Logo, Maple, Modula-2, Pliant, Rebol | | = #(16) | Modula-2, Modula-3 | | = != | BourneShell, FishShell | | == === != !==(17) | JavaScript, PHP | | === !== | Perl6, PHP5 | | == ~= | Lua | | == ~~ | Smalltalk | | == ~== | Dylan | | = '= | MUMPS | | = ~= neqv(15) | BCPL | | f= f<> | Forth | | is_equal(18) | Eiffel | | eq ne | Emacs Lisp, PostScript | | eq, eql | Common Lisp | | eq? eqv? | Scheme | | .EQ. .NE. | Fortran | | is / is not | Python | | is / isnot | Vimscript |

  deep |规则 | 语言 | | ———————- | ————– | | == != | Awk, C#, C++, E, merd, PHP5, Python, Ruby, Tcl, Vimscript, YCP | | == <> | Python | | == /= | Haskell | | == \= | Oz | | == \== | Classic REXX, Prolog | | = /= | Ada | | = != | Maple, XPath | | = <> | Beta, F#, OCaml, Pascal, Rebol, SML, SQL92, Visual Basic | | = ~= | Dylan, Smalltalk | | == ~= eq ne isequal isequalwithequalnans | Matlab | | == ~= eq ne isequal | Scilab | | =@= \=@= / = \= / =:= =\=(19) | Prolog | | === =!= / == !=(20) | Mathematica | | .eq | Logo | | equal? | Scheme | | equals | Java | | equal | Common Lisp, Emacs Lisp, Pike | | equalp | Common Lisp | | eqv | Perl6 | | deep_is_equal | Eiffel | | isEqual | Objective-C |

• comparison

returns 3 values (i.e. inferior, equal or superior) |规则 | 语言 | | ———————- | ————– | | a <=> b | merd, Perl, Perl6, Ruby | | cmp | Perl, Perl6, Python | | compare | F#, Forth, Haskell, Mercury, OCaml, Pliant, Prolog, Smalltalk | | strcmp | C, PHP | | three_way_comparison | Eiffel | | string compare | Tcl | | compareTo | Java | | strings.Compare() | Go |

returns 4 values (i.e. inferior, equal, superior or not comparable)

min / max (binary or more)

• runtime evaluation

• manual memory allocation

  allocation |规则 | 语言 | | ———————- | ————– | | malloc | C | | allocate throw | Forth | | new | Ada |

  deallocation

• force garbage collection

Functions

• function call

with no parameter |规则 | 语言 | | ———————- | ————– | | f | Ada, BourneShell, Eiffel, Forth, Haskell,
Io, Logo, Matlab, Mercury, MSH, Pascal, Perl,
Perl6, Pliant, PostScript, Prolog, Rebol, Ruby,
Tcl, Yorick | | f() | Awk, C, C#, C++, CoffeeScript, E, Erlang, F#, Go,
Java, JavaScript, Lua, Maple, merd, OCaml, Perl,
PHP, Pike, Python, SML, YCP | | (f) | Common Lisp, Emacs Lisp, Scheme | | (funcall f) | Common Lisp, Emacs Lisp | | {f} | Oz | | f[] | Mathematica | | f[] or f.call | Ruby | | &$f or $f->() | Perl | | $f.() | Perl6 | | v = f() | Classic REXX | | call f | Classic REXX, Fortran | | f value(30) | Smalltalk | | <xsl:call-template name="f">/ | XSLT |

partial application

(in the examples below, a normal call is “f(a,b)”)

give the first argument |规则 | 语言 | | ———————- | ————– | | f a | F#, Haskell, OCaml, SML | | f(a) | Mercury | | f(a,) | merd | | &f.assuming(var_name => a) | Perl6 | | functools.partial(f, a)(31) | Python | | interp alias {} f_a {} f a | Tcl |

give the second argument |规则 | 语言 | | ———————- | ————– | | f(,b) | merd | | &f.assuming(b => b) | Perl6 | | flip f b(32) | Haskell |

give the first argument to operator “>” |规则 | 语言 | | ———————- | ————– | | (a >) | Haskell, merd | | (>) a | F#, OCaml |

give the second argument to operator “>” |规则 | 语言 | | ———————- | ————– | | (> a) | Haskell, merd |

• function definition

procedures |规则 | 语言 | | ———————- | ————– | | procedure f(para1 : typ1; para2, para3 : typ2); begin ... end | Pascal | | f (para1 : typ1; para2, para3 : typ2; ...) is do ... end | Eiffel | | procedure f(para1 : typ1; para2 : MODE type2; ...) is begin ... end f; MODE ::= | OUT | IN OUT | Ada | | void f(typ1 para1, typ2 para2, ...) { ... } | C, C#, C++, Pike | | let f(para1, para2, ...) be $( ... $) | BCPL | | proc { F Para1 Para2 } ... end | Oz | | f := proc(para1, para2, ...) ... end proc | Maple | | Sub f(para1, para2) ... End Sub | Visual Basic | | function f(para1, para2) ... | Matlab, Scilab | | f : procedure ... return | Classic REXX | | func f(para1 typ1, para2 typ2, ...) { ... } | Go |

variable number of arguments

predicates

• anonymous function

• function return value

  breaks the control flow

function body is the result |规则 | 语言 | | ———————- | ————– | | no syntax needed(44) | CoffeeScript, Common Lisp, Dylan, Emacs Lisp, Erlang, F#, Haskell, Io, Maple, Mathematica, Matlab, OCaml, Oz, Perl, Perl6, Rebol, Ruby, Scheme, SML, Tcl |

setting the result |规则 | 语言 | | ———————- | ————– | | Result := val | Eiffel | | <function name> = val | Visual Basic | | <function name> := val | Pascal | | <retvar name> = val; | Ada, Matlab |

• function called when a function is not defined (in dynamic languages)

• runtime inspecting the caller information

• function composition

• identity function

Control Flow

• sequence

• if_then

• if_then_else

• ifnot_then (unless)

• multiple selection (switch)

• loop

  forever loop |规则 | 语言 | | ———————- | ————– | | loop | CoffeeScript, merd, Perl6, PostScript, Ruby | | loop(...) | Io | | loop ... end loop | Ada | | LOOP ... END | Modula-3 | | (loop do ...) | Common Lisp | | cycle (# do ... #) | Beta | | repeat | Squeak | | begin ... again | Forth | | forever | Logo, Rebol | | Do ... Loop | Visual Basic | | do forever ... end | Classic REXX | | for {} | Go |

  while condition do something |规则 | 语言 | | ———————- | ————– | | while (c) ... | Awk, B, C, C#, C++, E, Java, JavaScript, Perl, PHP, Pike, Ruby, YCP, Yorick | | while c ... | CoffeeScript, Perl6, Tcl | | while c loop ... end loop | Ada | | while c do ... | BCPL, Pascal, SML | | while c do ... done | F#, OCaml | | while c do ... end do | Maple | | while c do ... end | Lua | | WHILE c DO ... END | Modula-3 | | while c: ... | Python | | while c; do ...; done | BourneShell | | while c; ...; end | FishShell | | while c, ..., end | Matlab | | while [c][...] | Rebol | | while c [...] | Logo | | while(c, ...) | Io | | While[c, ...] | Mathematica | | do.while [...] c | Logo | | c whileTrue: ... | Smalltalk | | (loop while c do ...) | Common Lisp | | loop (# while ::< (# do c -> value #) do ... #) | Beta | | begin c while ... repeat | Forth | | from until not c loop ... end | Eiffel | | while c ... | Pliant | | while c do ... | F# | | Do While c ... Loop | Visual Basic | | while c ... endwhile | Vimscript | | do while c ... end | Classic REXX | | for c {...} | Go |

  do something until condition |规则 | 语言 | | ———————- | ————– | | do ... until c | Perl6 | | do {...} until c | Perl | | do ... while (!c) | Awk, C, C#, C++, Java, JavaScript, Pike, Yorick | | begin ... end until c | Ruby | | begin ... c until | Forth | | REPEAT ... UNTIL c | Modula-3 | | loop (# until ::< (# do c -> value #) do ... #) | Beta | | loop ... exit when c; end loop | Ada | | (loop do ... until c) | Common Lisp | | ... repeatuntil c | BCPL | | repeat ... until c | Lua, Pascal | | repeat ... until (c) | YCP | | repeat, ..., c | Prolog | | until [... c] | Rebol | | until c [...] | Logo | | do.while [...] c | Logo | | While[...; c] | Mathematica | | [...] whileFalse: [c] | Smalltalk | | Do ... Loop Until c | Visual Basic |

  for each value in a numeric range, 1 increment (see also the entries about ranges) |规则 | 语言 | | ———————- | ————– | | for (int i = 1; i <= 10; i++) ... | C, C#, C++ | | for (i = 1; i <= 10; i++) ... | Awk, JavaScript | | for ($i = 1; $i <= 10; $i++) ... | PHP | | foreach my $i (1 .. 10) { ... } | Perl | | foreach ($i in 1..10) { ... } | MSH | | for (1 .. 10) -> $i { ... } | Perl6 | | for i = 1:10, ..., end | Matlab | | for i = 1, 10 do ... end | Lua | | for i := 1 to 10 do ... | Pascal | | for i = 1 to 10 do ... done | F#, OCaml | | For i = 1 To 10 ... Next | Visual Basic | | for i in 1 .. 10 loop ... end loop | Ada | | for i in 1 .. 10 do ... done | F# | | for i in [1..10] ... | CoffeeScript | | for i in xrange(1, 11) | Python | | for i in (seq 10); ...; end | FishShell | | FOR I=1:1:10 ... | MUMPS | | for i from 1 to 10 do ... end do | Maple | | for [i 1 10 +1] [...] | Logo | | for {set i 1} {$i <= 10} {incr i} {...} | Tcl | | 1 1 10 ... for | PostScript | | 11 1 do ... loop | Forth | | (1..10).each {|i| ... } | Ruby | | 1.upto(10) {|i| ... } | Ruby | | 1 to(10) foreach(...) | Io | | 1 to: 10 do: [...] | Smalltalk | | (loop for i from 1 to 10 do ...) | Common Lisp | | do label i = 1, 10 | Fortran | | Do[..., {i, 1, 10}](50) | Mathematica | | do i = 1 for 10 ... end | Classic REXX | | for i := 1; i <= 10; i++ {...} | Go |

  for each value in a numeric range, 1 decrement |规则 | 语言 | | ———————- | ————– | | for X := 10 downto 1 do ... | Pascal | | for i = 10 downto 1 do ... done | F#, OCaml | | for i in reverse 1 .. 10 loop ... end loop | Ada | | for i in 10 .. -1 .. 1 do ... done | F# | | for (int i = 10; i >= 1; i--) ... | C, C#, C++ | | for (my $i = 10; $i >= 1; $i--) { ... } | Perl | | loop (my $i = 10; $i >= 1; $i--) { ... } | Perl6 | | for (i = 10; i >= 1; i--) ... | Awk, JavaScript | | for ($i = 10; $i >= 1; $i--) ... | PHP | | from i := 10 until i < 1 loop ... i := i - 1 end | Eiffel | | for i = 10:-1:1, ..., end | Matlab | | for i = 10, 1, -1 do ... end | Lua | | For i = 10 To 1 Step -1 ... Next | Visual Basic | | for i in xrange(10, 0, -1) | Python | | for i in seq 10 -1 1; do ...; done | BourneShell | | for i in (seq 10 -1 1); ...; end | FishShell | | for i from 10 to 1 by -1 do ... end do | Maple | | for [i 1 10 -1] [...] | Logo | | FOR I=10:-1:1 ... | MUMPS | | for {set i 10} {$i >= 1} {incr i -1} {...} | Tcl | | 10 -1 1 ... for | PostScript | | 1 10 do ... -1 +loop | Forth | | 1 to: 10 by: -1 do: [...] | Smalltalk | | 10 to(1) foreach(...) | Io | | 10.downto(1) {|i| ... } | Ruby | | (loop for i from 1 to 10 by -1 do ...) | Common Lisp | | do label i = 10, 1, -1 | Fortran | | Do[..., {i, 10, 1, -1}] | Mathematica | | do i = 10 to 1 by -1 ... end | Classic REXX | | for i in [10..1] ... | CoffeeScript | | for i := 10; i >= 1; i-- {...} | Go |

  for each value in a numeric range, free increment |规则 | 语言 | | ———————- | ————– | | for (int i = 1; i <= 10; i += 2) ... | C, C#, C++, Pike | | for (i = 1; i <= 10; i += 2) ... | Awk, JavaScript | | for ($i = 1; $i <= 10; $i += 2) ... | PHP | | for (my $i = 1; $i <= 10; $i += 2) { ... } | Perl | | loop (my $i = 1; $i <= 10; $i += 2) { ... } | Perl6 | | from i := 1 until i > 10 loop ... i := i + 2 end | Eiffel | | for i = 1:3:10, ..., end | Matlab | | for i = 1, 10, 2 do ... end | Lua | | For i = 1 To 10 Step 2 ... Next | Visual Basic | | for i in 1 .. 2 .. 10 do ... done | F# | | for i in xrange(1, 11, 2) | Python | | for i in (seq 1 2 10); ...; end | FishShell | | for i from 1 to 10 by 2 do ... end do | Maple | | for [i 1 10 2] [...] | Logo | | FOR I=1:2:10 ... | MUMPS | | for {set i 0} {$i <= 10} {incr i 2} {...} | Tcl | | 1 2 10 ... for | PostScript | | 11 1 do ... 2 +loop | Forth | | 1 to: 10 by: 2 do: [...] | Smalltalk | | (1..10).step(2) {|i| ... } | Ruby | | 1 to (9,2) foreach(...) | Io | | (loop for i from 1 to 10 by 2 do ...) | Common Lisp | | do label i = 1, 10, 2 | Fortran | | Do[..., {i, 1, 10, 2}] | Mathematica | | do i = 1 to 10 by 2 ... end | Classic REXX | | for i in [1..10] by 2 ... | CoffeeScript | | for i := 1; i <= 10; i += 2 {...} | Go |

  for “a la C” (while + initialisation) |规则 | 语言 | | ———————- | ————– | | for | Awk, C, C#, C++, Go, Java, JavaScript, Mathematica, MSH, Perl, PHP, Pike, Tcl, Yorick | | loop | Perl6 | | for ((x = 0; x < 10; x++)); do ...; done | BourneShell | | from init_code until c loop ... incr_statement end | Eiffel | | (loop with VAR = INITIAL-VALUE ... while CONDITION finally INCREMENT ...) | Common Lisp |

• breaking control flow

  returning a value |规则 | 语言 | | ———————- | ————– | | return(42) | Ada, Awk, B, BCPL, BourneShell, C, C#, C++, Classic REXX, CoffeeScript, Common Lisp, E, FishShell, Go, Io, Java, JavaScript, Lua, Maple, Matlab, Perl, Perl6, PHP, Pike, Pliant, Python, Rebol, Ruby, Tcl, Vimscript, YCP, Yorick | | Return | Mathematica, Visual Basic | | RETURN | Modula-3 | | resultis(43) | BCPL | | return-from xxx | Common Lisp | | ^ | Smalltalk | | Exit Function / Exit Sub | Visual Basic | | exit | Forth | | output | Logo |

  goto (unconditional jump)

continue / break

redo / retry

• exception

  throwing

catching

cleanup: code executed before leaving

retrying: after catching an exception, tell the snippet to be re-run

resume execution where the exception took place

• call-with-current-continuation

Types

• declaration

• annotation (or variable declaration)

• cast

  upcast |规则 | 语言 | | ———————- | ————– | | (t) e | C, C#, C++, Java, PHP | | t(e) | Ada, Pascal | | [t] e | Pike | | static_cast<t>(e) | C++ | | e :> t | OCaml | | e : t | F# | | upcast e | F# | | CAST(e as t) | SQL92 | | typecast(e,t) | Matlab | | (t)(e) | Go |

  downcast (need runtime checking)

computed conversion (calls an internal or a user-defined function)

• mutability, constness

  type of a mutable value

type of a constant value |规则 | 语言 | | ———————- | ————– | | const T | C++, C99 | | constant T | Ada | | const x: T | Pascal | | constness is the default | F#, Haskell, OCaml, SML | | const e t | Go |

special cases

Object Oriented & Reflexivity

• method invocation

with no parameter

• object creation

• object cloning

• manually call an object’s destructor

• class declaration

• testing class membership

• get the type/class corresponding to an object/instance/value

• methods available

• inheritance

• has the method

• current instance

• accessing parent method

• accessing child method

Package, Module

• package scope

• declare

selective export |规则 | 语言 | | ———————- | ————– | | module p (name1, name2, ...) where ... | Haskell | | @ISA = qw(Exporter); @EXPORT = qw(name1 name2 ...); | Perl | | package p is ... end; package body p is ... end; | Ada | | p = module() export name1, name2, ...; ... end module | Maple | | (export 'name1 'name2) | Common Lisp | | attached to each name (public, private...) | Java, Pike | | namespace export name1 | Tcl | | namespace p val name1 : type1 ... | F# | | append_features | Ruby | | module type PType = sig val name1 : type1 ... end module P : PType = struct ... end | OCaml | | all files in package directory are exported. files in /private sub-directory are not exported, but can be used by the package itself | Matlab | | __all__ = [ ... ] | Python | | Identifier is only exported if the first character of its name is an Unicode upper case letter; and the identifier is declared in the package block or it is a field name or method name. No other identifiers are exported | Go |

• import

  everything into current namespace |规则 | 语言 | | ———————- | ————– | | use p(71) | Perl | | uses p | Pascal | | using p | C# | | using namespace p; | C++ | | (use-package 'p) | Common Lisp | | open p | F#, OCaml | | import | Pike | | import p | Haskell | | IMPORT p; | Modula-2 | | import p.* | Java | | import "p" | YCP | | from p import * | Python | | with p; use p; | Ada | | namespace import p * | Tcl | | inherit c export {NONE} all end | Eiffel | | include or even extend | Ruby | | do | Rebol | | addpath | Matlab | | . p | BourneShell | | source p | BourneShell | | builtin -f /path/to/lib.so | KornShell | | << p | Mathematica | | Get[“p"] | Mathematica | | Needs["p”] | Mathematica | | use P1\P; | PHP5 | | use P1\P as Q;` | PHP5 |

  selectively

package (ie. load the package)

Strings

• type name

• character type name

• character “z”

• strings

  with no interpolation of variables |规则 | 语言 | | ———————- | ————– | | '...' | Beta, BourneShell, Classic REXX, CoffeeScript, CSS, FishShell, JavaScript, Lua, Matlab, Pascal, Perl, Perl6, PHP, Prolog, Python, Ruby, Smalltalk, SQL92, Vimscript, XPath, YAML | | "..." | Ada, Awk, C, C#, C++, Classic REXX, Common Lisp, CSS, Dylan, E, Eiffel, Emacs Lisp, F#, FL, Go, Haskell, Io, Java, JavaScript, Lua, Maple, Mathematica, Modula-3, MUMPS, OCaml, Oz, Pike, Pliant, Prolog, Python, Rebol, Scheme, SML, XPath, YAML, YCP | | "... | Logo | | '''...''' | Python | | """...""" | Io, Python | | [[ ... ]] | Lua | | R"[ ... ]" | C++-0x | | <<'MARK' ... MARK | BourneShell, Perl, Ruby | | <<<'MARK' ... MARK(76) | PHP5 | | {...{...}...} | Tcl | | (...) | PostScript | | q(...(...)...), q[...], q{...}, q<...>, q/.../ | Perl, Perl6 | | %q(...(...)...), %q[...], %q{...}, %q<...>, %q/.../ | Ruby | | q(...(...)...) | merd | | @"...""..." | C# | | s"..." | Forth | | @"..." | Objective-C |

  with interpolation of variables |规则 | 语言 | | ———————- | ————– | | ...(77) | Tcl | | "... $v ..." | BourneShell, FishShell, Perl, Perl6, PHP, Tcl | | "... {v} ..." | merd | | "... #{v} ..." "... #$v ..." "... #@v ..." "... #@@v ..." | CoffeeScript, Ruby | | <<MARK ... $v ... MARK | BourneShell, Perl | | <<MARK ... #{v} ... MARK | Ruby | | <<<MARK ... $v ... MARK | PHP | | qq(...(... $v ...)...), qq[...], qq{...}, qq<...>, qq/.../ | Perl, Perl6 | | %Q(...(... #{v} ...)...), %Q[...], %Q{...}, %Q<...>, %Q/.../ | Ruby | | qq(...(... {v} ...)...) | merd | | "... #{v} ..." interpolate | Io | | "... %(v)s ..." % vars() | Python |

  end-of-line (without writing the real CR or LF character)

• multi-line

• convert something to a string (see also string interpolation)

• serialize (marshalling)

• unserialize (un-marshalling)

• sprintf-like

• simple print

  on strings |规则 | 语言 | | ———————- | ————– | | puts | C, Dylan, Tcl | | print | Awk, Basic, Java, Maple, merd, PHP, SML | | write | JavaScript, Pascal, Pike, Yorick | | putStr | Haskell | | print_string | F#, OCaml | | console | Pliant | | writeln | JavaScript, Pascal | | write-string | Common Lisp | | putStrLn | Haskell | | Put_Line | Ada | | display | Cobol | | message | Emacs Lisp | | put_string | Eiffel | | show | Smalltalk | | print_endline(83) | OCaml | | println(83) | Java, merd | | put_chars | Erlang | | echo(84) | BourneShell, FishShell, PHP | | type | Forth | | putText | Beta | | say | Classic REXX | | p or i | GNU-sed | | fmt.Print | Go | | echom | Vimscript |

  on simple objects |规则 | 语言 | | ———————- | ————– | | print | Perl, Perl6 | | say(83) | Perl6 | | puts(83) | Tcl | | puts -nonewline | Tcl |

  on any objects |规则 | 语言 | | ———————- | ————– | | print | Io, Logo, Lua, Ruby | | print(83) | Dylan, Haskell, Python, Rebol | | Print | Mathematica | | print e, | Python | | println(83) | Io | | prin | Rebol | | Put | Ada | | p(83) | Ruby | | puts(85) | Ruby | | display | Scheme | | write | Common Lisp, Io, Prolog, Scheme | | writeln(83) | Io | | print | Common Lisp | | printOn | Smalltalk | | princ prin1 | Common Lisp, Emacs Lisp | | print_any | F# | | WriteLine | C#, F# | | nothing - just remove ";" at the end of the expression, and it will print it | Matlab | | disp | Matlab |

  printf-like |规则 | 语言 | | ———— | ———————————————————— | | printf | Awk, C, C++, F#, Haskell, KornShell, Maple, Matlab, merd, OCaml, Perl, PHP, Ruby | | write | Pike | | WriteLine | C# | | putFormat | Beta | | format(82) | Common Lisp, Prolog | | fmt.Printf | Go |

• string equality & inequality

• string size

• string concatenation

• duplicate n times

• upper / lower case character

• uppercase / lowercase / capitalized string

• ascii to character

• character to ascii

• accessing n-th character

• extract a substring

• locate a substring

• locate a substring (starting at the end)

Booleans

• type name

• false value

• true value

• logical not

• logical or / and

  short circuit |规则 | 语言 | | ——————– | ———————————————————— | | || / && | Awk, C, C#, C++, CoffeeScript, E, F#, Go, Haskell, Java, JavaScript, Mathematica, Matlab, merd, OCaml, Perl, Perl6, PHP, Pike, Ruby, Tcl, Vimscript, YCP, Yorick | | | / & | B, BCPL, Dylan | | or / and | CoffeeScript, Common Lisp, Emacs Lisp, Io, Logo, Lua, Modula-2, Perl, Perl6, PHP, Pliant, Python, Ruby, Scheme, Smalltalk | | OR / AND | Modula-3 | | or / &(95) | Modula-2 | | any / all | Rebol | | orelse / andalso | SML | | orelse / andthen | Oz | | or else / and then | Ada, Eiffel | | ; / , | Prolog | | & / ! | MUMPS |

  non short circuit (always evaluates both arguments) |规则 | 语言 | | ————– | ———————————————————— | | | / & | C#, Classic REXX, Java, Matlab, Smalltalk | | or / and | Ada, Beta, Eiffel, Maple, Pascal, PostScript, Rebol, SML, XPath | | Or / And(96) | Oz, Visual Basic | | \/ / /\(15) | BCPL | | ?| / | Perl6 |

Bags and Lists

• type name

• list concatenation

• list flattening

  one level depth |规则 | 语言 | | ———————— | ——————————– | | concat | F#, Haskell, Mercury, SML | | flatten | F#, Io, merd, OCaml, Prolog, YCP | | Flatten | Oz | | eval concat | Tcl | | ListTools[FlattenOnce] | Maple | | {*}$l | Tcl8.5 | | "$l" | FishShell |

  recursive |规则 | 语言 | | ——————– | ———– | | flatten | Pike, Ruby | | ListTools[Flatten] | Maple | | Flatten | Mathematica |

• list constructor

• list/array indexing

• adding an element at the beginning (list cons)

  return the new list (no side-effect) |规则 | 语言 | | ———– | ——————————- | | : | Haskell, merd | | :: | F#, OCaml, SML | | | | Oz | | [ e | l ] | Erlang, Prolog | | [e l[]] | Maple | | [e l] | Matlab | | cons | Common Lisp, Emacs Lisp, Scheme | | pair | Dylan | | fput | Logo | | Prepend | Ada, Mathematica |

  side-effect |规则 | 语言 | | ————— | ——————————————- | | unshift | CoffeeScript, JavaScript, Perl, Perl6, Ruby | | prepend | YCP | | push_front | C++ | | addFirst | Smalltalk | | insert | Rebol | | put_first | Eiffel | | push | Common Lisp, Io | | array_unshift | PHP | | PrependTo | Mathematica |

• adding an element at index

  return the new list (no side-effect) |规则 | 语言 | | ————— | —————- | | linsert l i e | Tcl | | Insert | Ada, Mathematica |

  side-effect |规则 | 语言 | | ————————————————– | ———— | | [a insertObject:e atIndex:i] | Objective-C | | a.insert(i, e) | Python, Ruby | | a insertAt(e, i) | Io | | a add: e beforeIndex: i / a add: e afterIndex: i | Smalltalk | | splice(@a, $i, 0, $e) | Perl |

• adding an element at the end

  return the new list (no side-effect) |规则 | 语言 | | ——————— | —————- | | [l e] | Matlab | | push | merd | | arrayByAddingObject | Objective-C | | lput | Logo | | linsert l end e | Tcl | | Append | Ada, Mathematica |

  side-effect |规则 | 语言 | | ———— | ——————————————- | | push | CoffeeScript, JavaScript, Perl, Perl6, Ruby | | push_back | C++ | | append | Go, Io, Pliant, Python, Rebol | | AppendTo | Mathematica | | lappend | Tcl | | += | Pliant | | add | Java, Smalltalk, YCP | | put_last | Eiffel | | array_push | PHP | | addObject | Objective-C |

• first element

iterator |规则 | 语言 | | ——- | —- | | head | Beta | | begin | C++ | | First | Ada |

• all but the first element

• last element

iterator |规则 | 语言 | | —— | —- | | Last | Ada | | | |

• all but the last element

• get the first element and remove it

• get the last element and remove it

• for each element do something

• transform a list (or bag) in another one

• transform two lists in parallel

• find an element

• keep elements

  matching |规则 | 语言 | | ——————————- | ———————————————————— | | find_all | F#, OCaml, Ruby | | filter | F#, Haskell, Mercury, merd, OCaml, Pike, Python, Scheme-SRFI1, SML, YCP | | filter! | Scheme-SRFI1 | | Filter | Oz | | grep | Perl, Perl6 | | where | MSH | | select | Io, Maple, Ruby, Smalltalk | | Select / Case | Mathematica | | selectInPlace | Io | | remove-if-not delete-if-not | Common Lisp | | choose | Dylan | | array_filter | PHP5 | | [ x | x <- l, p x ](104) | Haskell | | [ x for x in l if p(x) ](104) | Python | | a(a == 3) | Matlab |

  non matching |规则 | 语言 | | ——————— | ———– | | remove-if delete-if | Common Lisp | | reject | Ruby |

• partition a list: elements matching, elements non matching

• split a list

  in 2 based on a predicate |规则 | 语言 | | ——- | ——- | | break | Haskell | | span | Haskell |

  into sublists delimited by elements matching a predicate |规则 | 语言 | | ——————— | ———– | | split-sequence(105) | Common Lisp | | ListTools[Split] | Maple |

  into a list of lists of same value |规则 | 语言 | | ——- | ———– | | group | Haskell | | Split | Mathematica |

  into sublists based on a predicate |规则 | 语言 | | ——— | ———– | | groupBy | Haskell | | Split | Mathematica |

• is an element in the list

• is the predicate true for an element

• is the predicate true for every element

• smallest / biggest element

• join a list of strings in a string using a glue string

• list size

• iterate with index