638 search results for ""

Showing 51 - 100

  1. Labelled and Optional Arguments

    Defining Optional Parameters With Default Values

    <!-- ```ocaml # let log ?(base = 10.) x = log10 x /. log10 base;; val log : ?base:float -> float -> float = <fun> # let get_ok ?(exn = fun _ -> Invalid_argument "result is Error _") = function |

    Introduction

  2. Understanding the Garbage Collector

    Controlling the Major Heap Increment

    You can use Gc.tune to set that value, but the values are a little counter-intuitive, for backwards-compatibility reasons. Values under 1000 are interpreted as percentages, and the default is

    Runtime & Compiler

  3. Preprocessors and PPXs

    Restricting PPXs for Composition, Speed, and Security

    Note that Dune combines all PPXs written using ppxlib in a single preprocessor binary, even if the PPXs come from different packages. Compared to this, rewriters that work on the whole AST can a

    Advanced Topics

  4. The Compiler Backend: Bytecode and Native code

    Generating Portable Bytecode

    <div class="note"> There are around 140 instructions in total, but most are just minor variants of commonly encountered operations (e.g., function application at a specific arity). You can find

    Runtime & Compiler

  5. Mutability and Imperative Control Flow

    if … then … else … and Side Effects

    Failing to group in the first branch results in a syntax error. What's before the semicolon is parsed as an if … then … without an else expression. What's after the semicolon appears as a d

    Introduction

  6. Error Handling

    Using the result Type for Errors

    Handling errors necessarily complicates code, making it harder to read and understand than simple code that behaves incorrectly or fails under exceptional conditions. The right tools, data, and f

    Guides

  7. The Compiler Backend: Bytecode and Native code

    Summarizing the File Extensions

    .o are compiled native object files of the module implementation. .cmx contains extra information for linking and cross-module optimization of the object file. .cmxa and .a are libraries of c

    Runtime & Compiler

  8. The Compiler Backend: Bytecode and Native code

    Compiling and Linking Bytecode

    The bytecode files are then linked together with the OCaml standard library to produce an executable program. The order in which .cmo arguments are presented on the command line defines the ord

    Runtime & Compiler

  9. OCaml Programming Guidelines

    Sequence warnings and let _ = ...

    Justification : Sequences are much clearer! Compare e1; e2; e3 to In any case, use the let _ = ... construction exactly in those cases where you want to ignore a result. Don't systematicall

    Resources

  10. Mutability and Imperative Control Flow

    Good: Application-Wide State

    Note : Here, the state is copied, which is not memory efficient. In a memory-aware implementation, state-update functions would produce a “diff” (data describing the difference between the state'

    Introduction

  11. Your First OCaml Program

    Installing and Using Modules From a Package

    Finally, execute as before: Fun fact : Dune configuration files are S-expressions. Before the example will build and run, you need to tell Dune that it needs Sexplib to compile the project. D

    First Steps

  12. Using the OCaml Compiler Toolchain

    Using the ocamlfind Front-End

    Separate compilation (one command for module1.ml , another for module2.ml and another to link the final output) is usually not performed manually but only when using an automated build system t

    Guides

  13. OCaml Programming Guidelines

    Separate words by underscores: ( int_of_string , not intOfString )

    Case modifications are meaningful in OCaml. In effect, capitalised words are reserved for constructors and module names. In contrast, regular variables (functions or identifiers) must start with

    Resources

  14. OCaml Programming Guidelines

    No beastly alignment of the -> symbols in pattern-matching clauses

    Justification : This makes it harder to maintain the program (the addition of a supplementary case can lead to changes in all indentations, so we often give up alignment at that time. In this

    Resources

  15. OCaml Programming Guidelines

    How to Write Operator Symbols

    Justification : If you left out the spaces then x+1 would be understood, but x+!y would change its meaning, since +! would be interpreted as a multicharacter operator. Criticism : The abse

    Resources

  16. Values and Functions

    What Makes Functions Different From Other Values

    <!-- - Pattern matching does not allow inspecting a function. Catch-all patterns can match against a function, but it is useless. ```ocaml # match Fun.id with _ -> ();; - : unit = () ``` --> <!-- It

    Introduction

  17. Your First OCaml Program

    Using the Preprocessor to Generate Code

    Here is the result: Finally, you'll also need to edit bin/main.ml v has the type string list . We're using String.split_on_char to turn a string into a string list by splitting the str

    First Steps

  18. Mutability and Imperative Control Flow

    Example: get_char Function

    In the second call to tcsetattr , we restore the terminal attributes to their initial state. In this implementation, the record returned by the call to tcgetattr is not modified. A copy is made u

    Introduction

  19. Managing Dependencies With opam

    Adding a Git Dependency to a dune-project File

    to install the new dependency you added. Then, run Next, regenerate the .opam file of your project by running For example, if your project's opam file is my_project.opam , create my_projec

    Projects

  20. Higher Order Functions

    Pipelines, Composition, and Chaining

    <!-- NOTE(@leostera): this example kinda sucks, i'd like one where the use of labels greatly improves the readability but since `ListLabels.nth_opt` doesn't take an argument then we still need that

    Introduction

  21. Objects

    Inheritance, Virtual Classes, Initialisers

    Let's create a label which says "Press me!" and add it to the button: Here's our comparatively trivial label class: Before defining our label class, let's play with the button class in

    Advanced Topics

  22. Memory Representation of Values

    Floating-Point Numbers and Arrays

    Only records and arrays can have the float array optimization, and for records, every single field must be a float. The first thing we tested was that a float array has the correct unboxed floa

    Runtime & Compiler

  23. The Compiler Backend: Bytecode and Native code

    Compiling Fast Native Code

    Collections of .cmx and .o files can also be linked into a .cmxa archive by passing the -a flag to the compiler. However, unlike the bytecode version, you must keep the individual cmx fi

    Runtime & Compiler

  24. The Compiler Backend: Bytecode and Native code

    Understanding Name Mangling

    Anonymous functions are hard to predict without inspecting intermediate compiler output. If you need to debug them, it's usually easier to modify the source code to let-bind the anonymous functio

    Runtime & Compiler

  25. OCaml Programming Guidelines

    How to Indent Global let ... ;; Definitions

    Justification : The first line of the definition is offset nicely, so it's easier to pass from definition to definition. Criticism : You run into the right margin too quickly. <!-- $MDX skip --

    Resources

  26. Formatting and Wrapping Text

    Most General Pretty-Printing: Using fprintf

    Given those general printing routines, procedures to print to stdout or stderr is just a matter of partial application: Using fprintf , the lambda-terms printing routines can be written as

    Tutorials

  27. The Compiler Backend: Bytecode and Native code

    Benchmarking Polymorphic Comparison

    <div class="note"> We see that the polymorphic comparison is close to 10 times slower! These results shouldn't be taken too seriously, as this is a very narrow test that, like all such microben

    Runtime & Compiler

  28. Calling Fortran Libraries

    Step 1: Compile the Fortran Routine

    Note that its up to the caller to know that dens and temp are actually arrays. Failure to pass an array will cause a segmentation violation since the gtd6_ function is using them as arrays (y

    Tutorials

  29. Preprocessors and PPXs

    The Limits of Manipulating Text Files

    Working with a much more structured representation of a program solves both the reading and writing issues. This is exactly what PPXs do! It is difficult to read parts of the program, such as the ty

    Advanced Topics

  30. The Compiler Backend: Bytecode and Native code

    Benchmarking Pattern Matching

    The lambda form is primarily a stepping stone to the bytecode executable format that we'll cover next. It's often easier to look at the textual output from this stage than to wade through the na

    Runtime & Compiler

  31. Values and Functions

    Nested Pattern Matching on User-Defined Types

    Notice that contact is now available at the top-level as a bound variable: Next, we demonstrate the two-phase approach for accessing email and phone . This brings contact into our top-lev

    Introduction

  32. Understanding the Garbage Collector

    Mark and Sweep Garbage Collection

    All blocks reachable from the roots by following edges in the graph must be retained, and unreachable blocks can be reused by the application. The algorithm used by OCaml to perform this heap tra

    Runtime & Compiler

  33. The Compiler Frontend: Parsing and Type Checking

    An Overview of the Toolchain

    Notice that the pipeline branches toward the end. OCaml has multiple compiler backends that reuse the early stages of compilation but produce very different final outputs. The bytecode can be r

    Runtime & Compiler

  34. Memory Representation of Values

    OCaml Types Disappear at Runtime

    We'll cover how these values are managed by the runtime later on in Understanding The Garbage Collector . <!----> We'll explain this compilation pipeline in more detail in The Compiler Fronte

    Runtime & Compiler

  35. Preprocessors and PPXs

    Extension Nodes and Extenders

    Extenders which allow users to write OCaml values representing another language directly in such language. For example: - ppx_yojson to generate Yojson values by writing JSON code - tyxml-

    Advanced Topics

  36. Memory Representation of Values

    Integers, Characters, and Other Basic Types

    These basic types such as empty lists and unit are very efficient to use, since integers are never allocated on the heap. They can be passed directly in registers and not appear on the stack i

    Runtime & Compiler

  37. Mutability and Imperative Control Flow

    Bad: Undocumented Mutation

    <!-- TODO: ### Bad: Stateful External Factor GOTCHA: This is the dual of the previous anti-pattern. “Mutable in disguise” is an unintended or undocumented side-effect performed by a function.

    Introduction

  38. The Compiler Frontend: Parsing and Type Checking

    Modules and Separate Compilation

    This section discusses how the compiler implements them in more detail. Modules are essential for larger projects that consist of many source files (also known as compilation units ). It's impra

    Runtime & Compiler

  39. Understanding the Garbage Collector

    The Mutable Write Barrier

    The only way to know for sure is to benchmark your program under real-world scenarios using Core_bench and experiment with the trade-offs. The command-line benchmark binaries have a number of

    Runtime & Compiler

  40. Transitioning to Multicore with ThreadSanitizer

    Write a Parallel Test Runner (Step 1)

    From the above run under a regular 5.1.0 compiler, one may get the impression that everything is OK, as the balances sum to a total of $700 as expected, indicating that no money is lost. One

    Guides

  41. The Compiler Backend: Bytecode and Native code

    Accessing Stdlib Modules from Within Core

    </div> In the benchmark above comparing polymorphic and monomorphic comparison, you may have noticed that we prepended the comparison functions with Stdlib . This is because the Core module e

    Runtime & Compiler

  42. The Compiler Frontend: Parsing and Type Checking

    Extension Attributes

    Finally, an attribute can also be attached to an individual expression. In the next example, the @warn_on_literal_pattern attribute indicates that the argument to the type constructor should

    Runtime & Compiler

  43. OCaml Programming Guidelines

    Factor out snippets of repeated code by defining them in separate functions

    Sharing code obtained in this way facilitates maintenance, since every correction or improvement automatically spreads throughout the program. Besides, the simple act of isolating and naming a sn

    Resources

  44. Values and Functions

    Functions With Side Effects

    This illustrates the relationship between functions that have side effects and the unit type. The presence of the unit type does not indicate the presence of side effects. The absence of the uni

    Introduction

  45. OCaml Programming Guidelines

    The destructuring let must be exhaustive

    Justification : There is no way to make the pattern-matching exhaustive if you use general destructuring let bindings. <!-- $MDX skip --> Global definition with destructuring let statemen

    Resources

  46. OCaml Programming Guidelines

    The relative precedences of the Boolean operators are those of mathematics

    Although mathematicians have a tendency to overuse parentheses, the Boolean “or” operator is analogous to addition and the “and” to multiplication. So, just as 1 + 2 * x means 1 + (2 *

    Resources

  47. Preprocessors and PPXs

    Why PPXs Are Especially Useful in OCaml

    Other rewriters, such as ppx_expect , show that being able to enrich the syntax via PPX rewriters is very useful, even outside of the specificity of OCaml. Secondly, one of the strong features of

    Advanced Topics

  48. Preprocessors and PPXs

    OCaml’s Parsetree: The OCaml AST

    Note that the Parsetree is an internal representation of the code that happens before typing the program, so an ill-typed program can be rewritten. The internal representation after the typing is

    Advanced Topics

  49. Basic Data Types and Pattern Matching

    Revisiting Predefined Types

    In the end, the only type construction that does not reduce to a variant is the function arrow type. Pattern matching allows the inspection of values of any type, except functions. Even integers and

    Introduction

  50. Managing Dependencies With opam

    Dealing With Development-Only Dependencies

    See opam documentation for more details on the opam syntax. Normal: no flag Build: build Test: with-test Documentation: with-doc The available flags for each dependencies are: And for the

    Projects
1 2 3 ... 13