The OCaml Language Cheatsheets
The OCaml Language Cheatsheets
OCaml v.4.08.1
Syntax
Implementations are in .ml
files, interfaces are in .mli
files.
Comments can be nested, between delimiters (*...*)
Integers: 123
, 1_000
, 0x4533
, 0o773
, 0b1010101
Chars: 'a'
, '\255'
, '\xFF'
, '\n'
Floats: 0.1
, -1.234e-34
Data Types
unit: (* void, takes only one value: () *)
int: (* integer of either 31 or 63 bits, like 42 *)
int32: (* 32 bits Integer, like 42l *)
int64: (* 64 bits Integer, like 42L *)
float: (* double precision float, like 1.0 *)
bool: (* boolean, takes two values: true or false *)
char: (* simple ASCII characters, like 'A' *)
string: (* strings, like "Hello" or foo|Hello|foo *)
bytes: (* mutable string of chars *)
'a list : (* lists, like head :: tail or [1;2;3] *)
'a array: (* arrays, like [|1;2;3|] *)
t1 * ... * tn: (* tuples, like (1, "foo", 'b') *)
Constructed Types
type record = (* new record type *)
{ field1 : bool; (* immutable field *)
mutable field2 : int; } (* mutable field *)
type enum = (* new variant type *)
| Constant (* Constant constructor *)
| Param of string (* Constructor with arg*)
| Pair of string * int (* Constructor with args *)
| Gadt : int -> enum (* GADT constructor *)
| Inlined of { x : int } (* Inline record *)
Constructed Values
let r = { field1 = true; field2 = 3; }
let r' = { r with field1 = false }
r.field2 <- r.field2 + 1;
let c = Constant
let c = Param "foo"
let c = Pair ("bar",3)
let c = Gadt 0
let c = Inlined { x = 3 }
References, Strings and Arrays
let x = ref 3 (* integer reference (mutable) *)
x := 4 (* reference assignation *)
print_int !x; (* reference access *)
s.[0] (* string char access *)
t.(0) (* array element access *)
t.(0) <- x (* array element modification *)
Imports - Namespaces
open Unix (* global open *)
let open Unix in expr (* local open *)
Unix.(expr) (* local open *)
Functions
let f x = expr (* function with one arg *)
let rec f x = expr (* recursive function, apply: f x *)
let f x y = expr (* with two args, apply: f x y *)
let f (x,y) = expr (* with a pair as arg, apply: f (x,y) *)
List.iter (fun x -> expr) (* anonymous function *)
let f = function None -> act (* function definition *)
| Some x -> act (* function definition [by cases] *)
(* apply: f (Some x) *)
let f ~str ~len = expr (* with labeled args *)
(* apply: f ~str:s ~len:10 *)
(* apply: (for ~str:str): f ~str ~len *)
let f ?len ~str = expr (* with optional arg (option) *)
let f ?(len=0) ~str = expr (* optional arg default *)
(* apply (with omitted arg): f ~str:s *)
(* apply (with commuting): f ~str:s ~len:12 *)
(* apply (len: int option): f ?len ~str:s *)
(* apply (explicitly omitted): f ?len:None ~str:s *)
let f (x : int) = expr (* arg has constrainted type *)
let f : 'a 'b. 'a*'b -> 'a (* function with constrainted *)
= fun (x,y) -> x (* polymorphic type *)
Modules
module M = struct .. end (* module definition *)
module M: sig .. end= struct .. end (* module and signature *)
module M = Unix (* module renaming *)
include M (* include items from *)
module type Sg = sig .. end (* signature definition *)
module type Sg = module type of M (* signature of module *)
let module M = struct .. end in .. (* local module *)
let m = (module M : Sg) (* to 1st-class module *)
module M = (val m : Sg) (* from 1st-class module *)
module Make(S: Sg) = struct .. end (* functor *)
module M = Make(M') (* functor application *)
Module type items: val, external, type, exception, module, open, include, class
Pattern-matching
match expr with
| pattern -> action
| pattern when guard -> action (* conditional case *)
| _ -> action (* default case *)
Patterns:
| Pair (x,y) -> (* variant pattern *)
| { field = 3; _ } -> (* record pattern *)
| head :: tail -> (* list pattern *)
| [1;2;x] -> (* list pattern *)
| (Some x) as y -> (* with extra binding *)
| (1,x) | (x,0) -> (* or-pattern *)
| exception exn -> (* try&match *)
Conditionals
Do NOT use on closures
x = y (* (Structural) Polymorphic Equality *)
x == y (* (Physical) Polymorphic Inequality *)
x <> y (* (Structural) Polymorphic Equality *)
x != y (* (Physical) Polymorphic Inequality *)
compare x y (* negative, when x < y *)
compare x y (* 0, when x = y *)
compare x y (* positive, when x > y *)
Other Polymorphic Comparisons: >
, >=
, <
, <=
Loops
while cond do ... done;
for var = min_value to max_value do ... done;
for var = max_value downto min_value do ... done;
Exceptions
exception MyExn (* new exception *)
exception MyExn of t * t' (* same with arguments *)
exception MyFail = Failure (* rename exception with args *)
raise MyExn (* raise an exception *)
raise (MyExn (args)) (* raise with args *)
try expr (* catch MyExn *)
with MyExn -> ... (* if raised in expr *)
Objects and Classes
class virtual foo x = (* virtual class with arg *)
let y = x+2 in (* init before object creation *)
object (self: 'a) (* object with self reference *)
val mutable variable = x (* mutable instance variable *)
method get = variable (* accessor *)
method set z =
variable <- z+y (* mutator *)
method virtual copy : 'a (* virtual method *)
initializer (* init after object creation *)
self#set (self#get+1)
end
class bar = (* non-virtual class *)
let var = 42 in (* class variable *)
fun z -> object (* constructor argument *)
inherit foo z as super (* inheritance and ancestor reference *)
method! set y = (* method explicitly overridden *)
super#set (y+4) (* access to ancestor *)
method copy = {< x = 5 >} (* copy with change *)
end
let obj = new bar 3 (* new object *)
obj#set 4; obj#get (* method invocation *)
let obj = object .. end (* immediate object *)
Polymorphic variants
type t = [ `A | `B of int ] (* closed variant *)
type u = [ `A | `C of float ]
type v = [ t | u | ] (* union of variants *)
let f : [< t ] -> int = function (* argument must be a subtype of t *)
| `A -> 0 | `B n -> n
let f : [> t ] -> int = function (* t is subtype of the argument *)
|`A -> 0 | `B n -> n | _ -> 1
Reference
The OCaml Language Cheatsheets的更多相关文章
- OCaml Language Sucks
OCaml Language Sucks OCaml Language Sucks
- Github上的1000多本免费电子书重磅来袭!
Github上的1000多本免费电子书重磅来袭! 以前 StackOverFlow 也给出了一个免费电子书列表,现在在Github上可以看到时刻保持更新的列表了. 瞥一眼下面的书籍分类目录,你就能 ...
- Github 的一个免费编程书籍列表
Index Ada Agda Alef Android APL Arduino ASP.NET MVC Assembly Language Non-X86 AutoHotkey Autotools A ...
- [转]Keyword Reference (F#)
Visual F# Development Portal http://msdn.microsoft.com/en-us/library/vstudio/ff730280.aspx 本文转自:http ...
- gentoo use-flag 全局标识 大全 (官方搬运) 英文 适用funtoo
连接 https://www.gentoo.org/support/use-flags/ 提示 ctrl+F 可在页面查找 搬运 Global USE flags FlagDescription 3d ...
- function Language
什么是函数式语言: 函数式语言(functional language)一类程序设计语言.是一种非冯·诺伊曼式的程序设计语言.函数式语言主要成分是原始函数.定义函数和函数型.这种语言具有较强的组织数据 ...
- Function program language
历史 Lambda演算为描述函数及其评估提供了理论框架.它是一种数学抽象而不是编程语言 - 但它构成了几乎所有当前函数式编程语言的基础.等效的理论公式,组合逻辑,通常被认为比lambda演算更抽象,并 ...
- Functional Language
1.What is functional language? 函数式语言(functional language)一类程序设计语言,是一种非冯·诺伊曼式的程序设计语言.函数式语言主要成分是原始函数.定 ...
- 函数式编程语言(functional language)
内容根据百度词条整理! 转载请声明来源:https://baike.baidu.com/item/%E5%87%BD%E6%95%B0%E7%BC%96%E7%A8%8B%E8%AF%AD%E8%A8 ...
- 函数式编程语言(Fuction Program Language)
一.什么是函数式编程语言 函数式编程语言(functional progarm language)一类程序设计语言,是一种非冯·诺伊曼式的程序设计语言.函数式语言主要成分是原始函数.定义函数和函数型. ...
随机推荐
- [转帖]010 Linux 文本统计与去重 (wc 和 uniq)
https://my.oschina.net/u/3113381/blog/5427461 wc 命令一般是作为组合命令的一员与其他命令一同起到统计的作用.而一般情况下使用 wc -l 命令较多. u ...
- v-for动态添加表单,并且获取表单中的值
vue是数据驱动视图,所以要想改变页面的结构,就要首先改变数据. 要想动态添加一个input表单,每当你点击的时候,添加一个数据在数组里面. handler(mess){ this.list.push ...
- JQuery 源码解析一
网上已经有很多解读 jQuery 源码的文章了,作为系列开篇的第一篇,思前想去起了个[深入浅出jQuery]的标题,资历尚浅,无法对 jQuery 分析的头头是道,但是 jQuery 源码当中确实有着 ...
- OpenIM (Open-Source Instant Messaging) Mac Deployment Guide
This guide provides step-by-step instructions for deploying OpenIM on a Mac, including both source c ...
- 强化学习从基础到进阶-常见问题和面试必知必答[8]:近端策略优化(proximal policy optimization,PPO)算法
强化学习从基础到进阶-常见问题和面试必知必答[8]:近端策略优化(proximal policy optimization,PPO)算法 1.核心词汇 同策略(on-policy):要学习的智能体和与 ...
- C/C++ 实现FTP文件上传下载
FTP(文件传输协议)是一种用于在网络上传输文件的标准协议.它属于因特网标准化的协议族之一,为文件的上传.下载和文件管理提供了一种标准化的方法,在Windows系统中操作FTP上传下载可以使用WinI ...
- 10.1 C++ STL 模板适配与迭代器
STL(Standard Template Library)标准模板库提供了模板适配器和迭代器等重要概念,为开发者提供了高效.灵活和方便的编程工具.模板适配器是指一组模板类或函数,它们提供一种适配机制 ...
- Spark源码修改环境搭建
过程中存在问题: maven编译scala工程报错java.lang.NoClassDefFoundError: scala/reflect/internal/Trees,解决方案看maven编译 1 ...
- 基于SpringBoot应⽤的logback⽇志配置
SpringBoot默认整合了logback-classic⽇志框架,我们需要对logback⽇志框架进⾏配置 以⾃定义⽇志输出格式.⽇志⽂件配置.⽇志⽂件保存策略等信息 <?xml versi ...
- 创建多线程方式(Java)
一.创建自定义线程类继承Thread 自定义线程类代码 package com.demo05; public class MyThread extends Thread { @Override pub ...