For now, it’s enough to think of them as balanced parenthetical expressions whose atomic values are strings, e.g., (this (is an) (s expression)). S-expressions are a simple, flexible, and human-readable serialization format commonly used in Base and related libraries. This system will use s-expressions for formatting queries and responses, as well as the configuration for the query handler. In particular, we’re going to implement a system for responding to user-generated queries. Now let’s look at first-class modules in the context of a more complete and realistic example.
For example, we can use the same approach to construct a local module to be fed to a functor. This technique is useful beyond first-class modules. >- : (module Comparable with type t = float) = >- : (module Comparable with type t = int) = > ('a -> 'a -> int) -> (module Comparable with type t = 'a) = >module type Comparable = sig type t val compare : t -> t -> int end In that light, consider the following signature of a module with a single integer variable: We’ll get to more realistic examples in the next section. We’ll start out by covering the basic mechanics of first-class modules by working through some toy examples. But it’s worth learning, because letting modules into the core language is quite powerful, increasing the range of what you can express and making it easier to build flexible and modular systems. First-class modules are ordinary values that can be created from and converted back to regular modules.įirst-class modules are a sophisticated technique, and you’ll need to get comfortable with some advanced aspects of the language to use them effectively. OCaml provides a way around this stratification in the form of first-class modules. That means you can’t do things like define a variable whose value is a module, or a function that takes a module as an argument. These sublanguages are stratified, in that modules can contain types and values, but ordinary values can’t contain modules or module types. You can think of OCaml as being broken up into two parts: a core language that is concerned with values and types, and a module language that is concerned with modules and module signatures. Back Table of Contents First-Class Modules
0 kommentar(er)
