ocaml

The core OCaml system: compilers, runtime system, base libraries

5,755

1,136

5,755

658

View on GitHub

Top Related Projects

dune

1,709

A composable build system for OCaml.

reason

10,205

Simple, fast & type safe code that leverages the JavaScript & OCaml ecosystems

rescript

7,018

ReScript is a robustly typed language that compiles to efficient and human-readable JavaScript.

Quick Overview

OCaml is a general-purpose, multi-paradigm programming language that emphasizes functional programming while also supporting imperative and object-oriented styles. It is the main implementation of the Caml programming language, developed by INRIA, and is known for its strong static type system, pattern matching, and module system.

Pros

Strong static typing with type inference, reducing runtime errors and improving code reliability
Powerful pattern matching and algebraic data types for expressive and concise code
Efficient compilation to native code, resulting in fast execution
Advanced module system supporting abstraction and code organization

Cons

Steeper learning curve compared to some mainstream languages
Smaller ecosystem and community compared to more popular languages
Limited tooling and IDE support compared to languages like Java or Python
Syntax can be unfamiliar to developers coming from C-style languages

Code Examples

Pattern matching and recursive functions:

let rec factorial n =
  match n with
  | 0 | 1 -> 1
  | _ -> n * factorial (n - 1)

let result = factorial 5

Using the Option type for safe operations:

let safe_divide a b =
  if b = 0 then None
  else Some (a / b)

match safe_divide 10 2 with
| Some result -> Printf.printf "Result: %d\n" result
| None -> Printf.printf "Division by zero!\n"

Working with higher-order functions:

let double x = x * 2
let add_one x = x + 1

let compose f g x = f (g x)
let double_then_add_one = compose add_one double

let result = double_then_add_one 5 (* Returns 11 *)

Getting Started

To get started with OCaml:

Install OCaml using your package manager or from the official website.
Create a new file with a .ml extension, e.g., hello.ml.
Write your OCaml code:

let () =
  print_endline "Hello, OCaml!"

Compile and run the program:

ocamlc -o hello hello.ml
./hello

For interactive development, use the OCaml toplevel by running ocaml in your terminal.

Competitor Comparisons

dune

1,709

A composable build system for OCaml.

Pros of Dune

Simplified build system with a user-friendly DSL
Faster build times and improved parallelism
Better integration with external dependencies and package management

Cons of Dune

Limited to OCaml projects, while OCaml supports multiple languages
Steeper learning curve for developers familiar with traditional Makefiles
Less flexibility for complex, custom build configurations

Code Comparison

OCaml (using traditional build system):

# Makefile
all:
    ocamlc -o myprogram main.ml

clean:
    rm -f myprogram *.cmi *.cmo

Dune:

; dune file
(executable
  (name myprogram)
  (public_name myprogram)
  (libraries core))

The Dune example demonstrates a more concise and declarative approach to building OCaml projects, while the traditional OCaml build system requires more explicit commands. Dune's syntax is specifically designed for OCaml projects, making it easier to manage dependencies and build configurations. However, the traditional approach offers more flexibility for complex build scenarios and multi-language projects.

reason

10,205

Simple, fast & type safe code that leverages the JavaScript & OCaml ecosystems

Pros of Reason

More approachable syntax for JavaScript developers
Better tooling and editor integration out-of-the-box
Easier interoperability with JavaScript ecosystem

Cons of Reason

Smaller community and ecosystem compared to OCaml
Less mature and stable than OCaml
Some advanced OCaml features are not available or more complex in Reason

Code Comparison

OCaml:

let rec factorial n =
  if n = 0 then 1
  else n * factorial (n - 1)

let () = Printf.printf "Factorial of 5 is %d\n" (factorial 5)

Reason:

let rec factorial = n =>
  if (n == 0) {
    1;
  } else {
    n * factorial(n - 1);
  };

Js.log("Factorial of 5 is " ++ string_of_int(factorial(5)));

The Reason syntax is more familiar to JavaScript developers, with curly braces and arrow functions. OCaml uses a more traditional functional programming syntax. Both languages are statically typed and offer similar performance, but Reason aims to be more accessible to web developers while maintaining OCaml's power and safety.

rescript

7,018

ReScript is a robustly typed language that compiles to efficient and human-readable JavaScript.

Pros of ReScript

Designed for JavaScript interoperability, making it easier to integrate with existing JS ecosystems
Faster compilation times compared to OCaml, especially for large projects
Simpler syntax and more approachable for developers coming from JavaScript backgrounds

Cons of ReScript

Smaller ecosystem and community compared to OCaml's mature and extensive libraries
Less powerful type system, sacrificing some advanced features for simplicity
Limited support for certain OCaml language features, potentially restricting expressiveness

Code Comparison

ReScript:

let greeting = (name) => {
  `Hello, ${name}!`
}

Console.log(greeting("ReScript"))

OCaml:

let greeting name =
  "Hello, " ^ name ^ "!"

let () = print_endline (greeting "OCaml")

The ReScript code showcases its JavaScript-like syntax and built-in string interpolation, while the OCaml code demonstrates its more traditional functional programming style and explicit string concatenation.

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

[CAUTION]

The developer team released OCaml 5.0.0 in December 2022. OCaml 5.x features a full rewrite of its runtime system for shared-memory parallel programming using domains and native support for concurrent programming using effect handlers.

Owing to the large number of changes, especially to the garbage collector, OCaml 4.14 (the final release in the OCaml 4.x series, originally released in March 2022) remains supported for the time being. Maintainers of existing codebases are strongly encouraged to evaluate OCaml 5.x and to report any performance degradations on our issue tracker.

= README =

== Overview

OCaml is a functional, statically-typed programming language from the ML family, offering a powerful module system extending that of Standard ML and a feature-rich, class-based object system.

OCaml comprises two compilers. One generates bytecode which is then interpreted by a C program. This compiler runs quickly, generates compact code with moderate memory requirements, and is portable to many 32 or 64 bit platforms. Performance of generated programs is quite good for a bytecoded implementation. This compiler can be used either as a standalone, batch-oriented compiler that produces standalone programs, or as an interactive REPL system.

The other compiler generates high-performance native code for a number of processors. Compilation takes longer and generates bigger code, but the generated programs deliver excellent performance, while retaining the moderate memory requirements of the bytecode compiler. The native-code compiler currently runs on the following platforms:

|==== | | Tier 1 (actively maintained) | Tier 2 (maintained when possible)

Other operating systems for the processors above have not been tested, but the compiler may work under other operating systems with little work.

â From OCaml 5.0 onwards, native compilation is available only on 64-bit systems. Native compilation on 32-bit systems is no longer available, nor are there plans to bring it back.

== Copyright

All files marked "Copyright INRIA" in this distribution are Copyright (C) 1996-2023 Institut National de Recherche en Informatique et en Automatique (INRIA) and distributed under the conditions stated in file LICENSE.

== Installation

See the file link:INSTALL.adoc[] for installation instructions on machines running Unix, Linux, macOS, WSL and Cygwin. For native Microsoft Windows, see link:README.win32.adoc[].

== Documentation

The OCaml manual is distributed in HTML, PDF, and Emacs Info files. It is available at

https://ocaml.org/manual/latest/

== Availability

The complete OCaml distribution can be accessed at

https://ocaml.org/docs/install.html

== Releases

More information about when and how new releases of OCaml are published is available at link:release-info/introduction.md[], see also link:release-info/calendar.md[] for a prospective calendar for future OCaml versions. For past versions, link:release-info/News[] contains a short description of major changes in previous versions.

== Keeping in Touch with the Caml Community

There is an active and friendly discussion forum at

https://discuss.ocaml.org/

The OCaml mailing list is the longest-running forum for OCaml users. You can email it at

mailto:caml-list@inria.fr[]

You can subscribe and access list archives via the Web interface at

https://sympa.inria.fr/sympa/subscribe/caml-list

There also exist other mailing lists, chat channels, and various other forums around the internet for getting in touch with the OCaml and ML family language community. These can be accessed at

https://ocaml.org/community/

In particular, the IRC channel #ocaml on https://libera.chat/[Libera] has a long history and welcomes questions.

== Bug Reports and User Feedback

Please report bugs using the issue tracker at https://github.com/ocaml/ocaml/issues

To be effective, bug reports should include a complete program (preferably small) that exhibits the unexpected behavior, and the configuration you are using (machine type, etc).

== Contributing

For information on contributing to OCaml, see link:HACKING.adoc[] and link:CONTRIBUTING.md[].

== Separately maintained components

Some libraries and tools which used to be part of the OCaml distribution are now maintained separately and distributed as OPAM packages. Please use the issue trackers at their respective new homes:

|==== | Library | Removed since | OPAM package

Top Related Projects

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot