Skip to content
master
Switch branches/tags
Code

Files

Permalink
Failed to load latest commit information.
Type
Name
Latest commit message
Commit time
src
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

[%%import]

import is a syntax extension that allows to pull in types or signatures from other compiled interface files.

Sponsored by Evil Martians.

Installation

import can be installed via OPAM:

$ opam install ppx_import

Usage

In order to use import, require the package ppx_import.

Using ppx_import from Dune

To use ppx_import from Dune you should use the staged_pps field to declare the preprocessing specification. Example:

(library
  (name foo)
  (preprocess (staged_pps ppx_import ppx_deriving.show))

Syntax

Single declarations

For example:

# type loc = [%import: Location.t];;
type loc = Location.t = { loc_start : Lexing.position; loc_end : Lexing.position; loc_ghost : bool; }
# module type Hashable = [%import: (module Hashtbl.HashedType)];;
module type Hashable = sig type t val equal : t -> t -> bool val hash : t -> int end

It is also possible to import items from your own .mli file.

Combining with [@@deriving]

It's possible to combine import and deriving to derive functions for types that you do not own, e.g.:

type longident = [%import: Longident.t] [@@deriving show]
let () =
  print_endline (show_longident (Longident.parse "Foo.Bar.baz"))
(* Longident.Ldot (Longident.Ldot (Longident.Lident ("Foo"), "Bar"), "baz") *)

Note that you need to require import before any deriving plugins, as otherwise deriving will not be able to observe the complete type.

[@with] replacements

It is possible to syntactically replace a type with another while importing a definition. This can be used to import only a few types from a group, or to attach attributes to selected referenced types.

For example, this snippet imports a single type from Parsetree and specifies a custom pretty-printer for deriving show.

type package_type =
[%import: Parsetree.package_type
          [@with core_type    := Parsetree.core_type [@printer Pprintast.core_type];
                 Asttypes.loc := Asttypes.loc [@polyprinter fun pp fmt x -> pp fmt x.Asttypes.txt];
                 Longident.t  := Longident.t [@printer pp_longident]]]
[@@deriving show]

For module types, the replacements are specified using the standard with construct. However, the replacement is still syntactic.

More?

If you have a use case in mind that ppx_import does not cover (in particular, object-oriented features are not implemented), please open an issue.

License

import is distributed under the terms of MIT license.

About

Less redundancy in type declarations and signatures

Resources

License

Packages

No packages published