package merlin-lib

You can search for identifiers within the package.

in-package search v0.2.0

Merlin's libraries

Install

Dune Dependency

github.com Readme Changelog Edit opam file Versions (10)

Authors

T

The Merlin team

Maintainers

D

defree@gmail.com

Sources

merlin-5.5-503.tbz

sha256=67da3b34f2fea07678267309f61da4a2c6f08298de0dc59655b8d30fd8269af1

sha512=1fb3b5180d36aa82b82a319e15b743b802b6888f0dc67645baafdb4e18dfc23a7b90064ec9bc42f7424061cf8cde7f8839178d8a8537bf4596759f3ff4891873

doc/merlin-lib.index_format/Merlin_index_format/Granular_marshal/index.html

Module `Merlin_index_format.Granular_marshal`Source

Sourcetype 'a link

A pointer to an 'a value, either residing in memory or on disk.

Sourceval link : 'a -> 'a link

link v returns a new link to the in-memory value v.

Sourceval reuse : 'a link -> unit

reuse lnk marks the link as being used more than once, to ensure proper serialization of DAGs.

Sourceval cache : 'a. (module Hashtbl.HashedType with type t = 'a) -> 'a link -> unit

cache (module Hash) returns a function to de-duplicate links which share the same value, resulting in a compressed file.

Sourceval fetch : 'a link -> 'a

fetch lnk returns the value pointed by the link lnk.

We of course have fetch (link v) = v and link (fetch lnk) = lnk.

For Merlin we can't depend on a PPX or external dependencies, so we require a user-defined schema to describe where the links can be found. This is just an iter traversal over the values, recursively yielding on any reachable link. Since links can point to values themselves containing links, recursion is delayed by asking for the schema of each child.

For example, the following type has the following schema:

  type t = { first : string link ; second : int link list link }

  let type_first : string link Type.Id.t = Type.Id.make ()
  let type_second : int link list link Type.Id.t = Type.Id.make ()
  let type_v : int link Type.Id.t = Type.Id.make ()

  let schema : t schema = fun iter t ->
    iter.yield t.first type_first schema_no_sublinks ;
    iter.yield t.second type_second @@ fun iter lst ->
      List.iter (fun v -> iter.yield v type_v schema_no_sublinks) lst

where schema_no_sublinks indicates that the yielded value contains no reachable links.

Sourcetype 'a schema = iter -> 'a -> unit

A function to iter on every link reachable in the value 'a.

Sourceand iter = {

yield : 'a. 'a link -> 'a link Type.Id.t -> 'a schema -> unit;

}

A callback to signal the reachable links and the schema of their pointed sub-value. Since a value can contain multiple links each pointing to different types of values, the callback is polymorphic.

Sourceval schema_no_sublinks : 'a schema

A schema usable when the 'a value does not contain any links.

Source

val write : 
  ?flags:Marshal.extern_flags list ->
  out_channel ->
  'a schema ->
  'a ->
  unit

write oc schema value writes the value in the output channel oc, creating unmarshalling boundaries on every link in value specified by the schema.

Sourceval read : string -> in_channel -> 'a schema -> 'a

read ic schema reads the value marshalled in the input channel ic, stopping the unmarshalling on every link boundary indicated by the schema. It returns the root value read.