379 search results for "function"

Showing 151 - 200

  1. Values and Functions

    The Application Operator

    The @@ application operator applies an argument (on the right) to a function (on the left). It is useful when chaining several calls, as it avoids writing parentheses, which creates easier-to-read code. Here is an example with and without parentheses: The application operat

    Introduction

  2. Values and Functions

    The Pipe Operator

    This is just like a Unix shell pipe. The pipe operator ( |> ) also avoids parentheses but in reversed order: function on right, argument on left.

    Introduction

  3. Higher Order Functions

    Iterating

    Iterating in OCaml means that if there is one value (or more), we'd like to apply a function to it. But in OCaml the pattern for iteration can be extended to other kinds of data types, like optional values or results, or trees and lazy sequences. loop through elements in a list go over the

    Introduction

  4. Higher Order Functions

    Mapping

    ave a list of users, maybe we want to get a list of usernames. Or if we have an optional password, we may want to encrypt it only if it is set. In contrast to iterating, sometimes we want to apply a function over some data and we want to keep the results without changing the shape of the data.

    Introduction

  5. Higher Order Functions

    Binding as early returns

    a user from a database, and only if there is a user try access the user's email, you could use Option.bind to short-circuit on the first operation: This same pattern is useful to build chains of functions that short circuit on specific values.

    Introduction

  6. Basic Data Types and Pattern Matching

    Constructors With Data

    gle parameter. We need to pass an inspected expression to the match … with … construct. The function … is a special form of an anonymous function that takes a parameter and forwards it to a match … with … construct, as shown above. Abov

    Introduction

  7. Basic Data Types and Pattern Matching

    A Recursive and Polymorphic Type: tree

    ors. Here are the terms applicable to data types: In the OCaml community, as well as in the larger functional programming community, the word polymorphism [...] map has two type variables, 'a and 'b . The function it receives may change the element type, so an 'a tree can become a 'b tree . For instance, map

    Introduction

  8. Lists

    List Searching

    elements for which the predicate is true, the second those for which it is false. The filter function again takes a predicate and tests it against ea [...] the list of all elements which test true: The function find returns the first element of a list matching a given predicate (a predicate is a testing

    Introduction

  9. Labelled and Optional Arguments

    Labelling Parameters

    sing the same name as label and parameter. Here is how range is used: lo and hi inside the function's body, as usual first and last when calling the function; these are the labels. The parameters of range are named Here is how to name parameters in a

    Introduction

  10. Labelled and Optional Arguments

    Passing Labelled Arguments Using the Pipe Operator

    Let's modify the range function previously defined by adding an additional parameter step . Declaring a function's unlabelled argument as the first one simplifies reading the

    Introduction

  11. Mutability and Imperative Control Flow

    Remark: References Are Single Field Records

    create does the same as the ref function provided by the standard library. assign does th [...] deref does the same as the ( ! ) operator. The functions: Since references are single field records, we can define

    Introduction

  12. Mutability and Imperative Control Flow

    Semicolon

    er containing value n Updates the reference's contents to 2 × (n + 1) Imagine we want to write a function that: In OCaml, begin … end and parentheses [...] olon is not truly an operator because it is not a function of type unit -> 'a -> 'a . It is rather a construct of the language. It allows adding a semicolo

    Introduction

  13. Arrays

    Introduction

    ch as: This tutorial aims to introduce the subject of arrays in OCaml and showcase the most useful functions and use cases. Despite these differences, many of the functions readily available on arrays are similar to the ones available for lists. Please refer to the List

    Data Structures

  14. Arrays

    Creating Arrays

    Array.init generates an array of a given length by applying a function to each index of the array, starting at 0. The fo [...] array containing the first 5 even numbers using a function which doubles its argument: Alternatively, you can create an array using the Array.make

    Data Structures

  15. Arrays

    Copying Part of an Array into Another Array

    tarting at index 1 into the last part of zeroes , starting at index 3 . We can also use this function to copy part of an array onto itself: This copie [...] hin the bounds of each array. The Array.blit function efficiently copies a contiguous part of an array into an array. Similar to the array.(x) <- y ope

    Data Structures

  16. Maps

    Finding Entries in a Map

    ote that find_first_opt and find_last_opt return the key-value pair, not just the value. The functions find_first and find_last behave similarly, e [...] d find_last_opt if we want to use a predicate function: find_opt returns None find throws the Not_found exception When the searched key is absent fr

    Data Structures

  17. Maps

    Changing the Value Associated With a Key

    You should experiment with different update functions; several behaviors are possible. To change a key's associated value, use the update function. It takes a key, a map, and an update

    Data Structures

  18. Sets

    Sets With Custom Comparators

    e Insensitive String Set"). We can accomplish this by passing an ad-hoc module to the Set.Make function: Let's say we want to create a set of strings th [...] et module we created uses the built-in compare function provided by the String module. The Set.Make functor expects a module with two definitions: a t

    Data Structures

  19. Sequences

    Constructing Sequences

    tains a module for sequences called Seq . It contains Seq.int , which we implemented above. The function ints n looks as if building the infinite sequen [...] in_int . We can also construct sequences using functions. Here is how to build an infinite sequence of integers: Note: The second component of each Se

    Data Structures

  20. Sequences

    Sequences for Conversions

    Similar functions are also provided for sets, maps, hash tables ( [...] , it is advised to expose to_seq and of_seq functions. Lists Arrays Strings Throughout the OCaml Standard Library, sequences are used as a bri

    Data Structures

  21. Sequences

    Miscellaneous Considerations

    ps it would be enlightening to illustrate the use of Seq.unfold by re-implementing the already seen function primes? Perhaps in an exercise rather than in the [...] accumulator, and also the fact that the producer function loops until it finds a new prime to yield, because Seq.unfold does not allow the producer to “ski

    Data Structures

  22. Monads

    Monad Laws

    e the right type to be on the right-hand side of >>= . So we have to insert an extra anonymous function fun x -> ... to make the types correct. (m >>= [...] ing the trivial effect on a value, then binding a function on it, is the same as just calling the

    Data Structures

  23. Memory Representation of Values

    Polymorphic Variants

    ts with constructors thus use one word of memory more than normal variant constructors. The hash function is designed to give the same results on 32-bit an [...] integer value is determined by applying a hash function to the name of the variant. The hash

    Runtime & Compiler

  24. Understanding the Garbage Collector

    Attaching Finalizer Functions to Values

    <div class="note"> OCaml's automatic memory management guarantees that a value will eventually be freed when it's no longer in use, either via the GC sweeping it or the program terminating. It'

    Runtime & Compiler

  25. The Compiler Backend: Bytecode and Native code

    Executing Bytecode

    ces bytecode that targets the standard OCaml runtime by default, and so needs to know about any C functions that are referenced from other libraries that [...] s: the bytecode interpreter, GC, and a set of C functions that implement the primitive operations. The bytecode contains instructions to call these C

    Runtime & Compiler

  26. Calling Fortran Libraries

  27. Calling Fortran Libraries

    Step 3: Compile the Shared Library

    This will create a shared object library called wrapper.so containing the fortran function and the wrapper function. The -lg2c option is required to provide the implementations of the built in fortran

    Tutorials

  28. Error Handling

    Predefined Exceptions

    reexisting exceptions Raise custom exceptions When implementing a software component which exposes functions raising exceptions, a design decision must be made: Functions are provided by the standard library to raise Invalid_argument and Failure using a string par

    Guides

  29. Error Handling

    Printing

    own exceptions: To print an exception, the module Printexc comes in handy. For instance, the function notify_user : (unit -> 'a) -> 'a below calls a function, and if it fails, prints the exception on stderr . If stack traces are enabled, this

    Guides

  30. Error Handling

    Throwing Exceptions From option or result

    ons, pattern matching and raise must be used. From option to Invalid_argument exception, use function Option.get : From result to Invalid_argument exception, use functions Result.get_ok and Result.get_error : This is done by using the following

    Guides

  31. Error Handling

    Conversion Between option and result

    From option to result , use function Option.to_result : From result to option , use function Result.to_option : This is done by using the following

    Guides

  32. 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

  33. OCaml Programming Guidelines

    Never copy-paste code when programming

    ten lines of code is repeated twenty times throughout the program. By contrast, if an auxiliary function defines those ten lines, it is fairly easy to see [...] find where those lines are used: simply where the function is called. If code is copy-pasted all over the place, then the program is more difficult to und

    Resources

  34. OCaml Programming Guidelines

    Always give the same name to function arguments which have the same meaning

    If necessary, make this nomenclature explicit in a comment at the top of the file. If there are several arguments with the same meaning, then attach numeral suffixes to them.

    Resources

  35. OCaml Programming Guidelines

    Local identifiers can be brief and should be reused from one function to another

    A tolerated exception to the recommendation not to use capitalisation to separate words within identifiers when interfacing with existing libraries which use this naming convention. This lets OCa

    Resources

  36. OCaml Programming Guidelines

    Exceptions

    -> Handling all exceptions by try ... with _ -> is usually reserved for the program's main function. If you must catch every exception in order to [...] e system as possible. For example, every search function that fails should raise the predefined exception Not_found . Be careful to handle the exceptions

    Resources

  37. OCaml Programming Guidelines

    How to Choose Between Classes and Modules

    Use modules when the data structures are fixed and their functionality is equally fixed or it's enough to add new functions in the programs which use them. Use conventional data structures (in particular, variant type

    Resources

  38. OCaml Programming Guidelines

    Clarity of OCaml Code

    r programming paradigms): imperative programming (based on the notion of state and assignment), functional programming (based on the notion of function,

    Resources

  39. OCaml Programming Guidelines

    How to Indent Function Calls

    Resources

  40. Basic Data Types and Pattern Matching

    Byte Sequences

    rray . Operations on bytes values are provided by the Stdlib and the Bytes modules. Only the function Bytes.get allows direct access to the character [...] bytes literally, so they must be produced by a function. <!--CR Moved intro pp to after example, as it contains the definition. Perhaps a short intro se

    Introduction

  41. Basic Data Types and Pattern Matching

    Lists

    ce with respect to lists: Operations on lists are provided by the List module. The List.append function concatenates two lists. It can be used as an oper [...] values they contain. Lists play a central role in functional programming, so they have a dedicated tutorial . As literals, lists are very much like arrays

    Introduction

  42. Basic Data Types and Pattern Matching

    Tuples

    t associative . In the standard library, both are defined using pattern matching. Here is how a function extracts the third element of the product of four types: The predefined function fst returns the first element of a pair, while snd returns the second element of a pair. This

    Introduction

  43. Basic Data Types and Pattern Matching

    Recursive Variants

    , which catches everything. It returns false on all data that is neither Array nor Object . Functions defined using pattern matching on recursive variants are often recursive too. This function checks if a name is present in a whole JSON tree: Both constructors Array and Object contain v

    Introduction

  44. 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 floats can be seen as enumerated-like variant types, with many constructors an

    Introduction

  45. Loops and Recursions

    For Loops and While Loops

    owing an exception, so this means that while loops have fairly limited use. Again, remember that functional programmers like recursion, so while loops [...] DX skip --> While loops in OCaml are written: Functional programmers tend to use recursion instead of explicit loops, and it's wise to regard for loop

    Introduction

  46. Loops and Recursions

    Looping Over Strings

    String.copy copies a string, like strdup . There is also a String.iter function which works like List.iter , except over the cha [...] e also contains dozens of useful string-related functions, and some of them are concerned with looping over strings.

    Introduction

  47. Lists

    Association Lists

    e able to make a list of pairs from a pair of lists and vice versa. The List module provides the functions split and combine for this purpose: Ass [...] library's Map or Hashtbl modules. But these functions from the List module are useful for lists which are generally small, and have other advantages

    Introduction

  48. Labelled and Optional Arguments

    Forwarding an Optional Argument

    ?len is sufficient to forward without unwrapping. In the definitions of take and rtake , the function sub is called with optional arguments passed wi [...] ithout unwrapping. These examples reuse the sub function defined in the Defining Optional Parameters Without Default Values section.

    Introduction

  49. Mutability and Imperative Control Flow

  50. Mutability and Imperative Control Flow

    Byte Sequences

    char array . The former should always be preferred, except when array is required by polymorphic functions handling arrays. updatable strings that can't b [...] ces can be created from string values using the function Bytes.of_string . Individual elements in the sequence can be updated or read by their index using

    Introduction
... 3 4 5 ... 8