Skip to content


Switch branches/tags

Name already in use

A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?

Latest commit


Git stats


Failed to load latest commit information.
Latest commit message
Commit time


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

Sponsored by Evil Martians.


import can be installed via OPAM:

$ opam install ppx_import


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:

  (name foo)
  (preprocess (staged_pps ppx_import


Single declarations

For example:

# type%import loc = 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%import longident = 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%import 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.


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.


import is distributed under the terms of MIT license.