plucky (3) Load_path.3o.gz

NAME

       Load_path - Management of include directories.

Module

       Module   Load_path

Documentation

       Module Load_path
        : sig end

       Management of include directories.

       This  module  offers a high level interface to locating files in the load path, which is constructed from
       -I and -H command line flags and a few other parameters.

       It makes the assumption that the contents of include directories doesn't change during the  execution  of
       the compiler.

       val add_dir : hidden:bool -> string -> unit

       Add a directory to the end of the load path (i.e. at lowest priority.)

       val remove_dir : string -> unit

       Remove a directory from the load path

       val reset : unit -> unit

       Remove all directories

       module Dir : sig end

       type auto_include_callback = (Dir.t -> string -> string option) -> string -> string

       The type of callback functions on for init ~auto_include

       val no_auto_include : auto_include_callback

       No automatic directory inclusion: misses in the load path raise Not_found as normal.

       val init : auto_include:auto_include_callback -> visible:string list -> hidden:string list -> unit

       init ~visible ~hidden is the same as reset ();
            List.iter add_dir (List.rev hidden);
            List.iter add_dir (List.rev visible)

       val auto_include_otherlibs : (string -> unit) -> auto_include_callback

       auto_include_otherlibs alert is a callback function to be passed to Load_path.init and automatically adds
       -I +lib to the load path after calling alert lib .

       val get_path_list : unit -> string list

       Return the list of directories passed to add_dir so far.

       type paths = {
        visible : string list ;
        hidden : string list ;
        }

       val get_paths : unit -> paths

       Return the directories passed to add_dir so far.

       val find : string -> string

       Locate a file in the load path. Raise Not_found if the file cannot be found. This function  is  optimized
       for the case where the filename is a basename, i.e. doesn't contain a directory separator.

       val find_normalized : string -> string

       Same  as  find  ,  but search also for normalized unit name (see Misc.normalized_unit_filename ), i.e. if
       name is Foo.ml , allow /path/Foo.ml and /path/foo.ml to match.

       type visibility =
        | Visible
        | Hidden

       val find_normalized_with_visibility : string -> string * visibility

       Same as find_normalized , but also reports whether the cmi was found in a -I directory (Visible) or a  -H
       directory (Hidden)

       val add : Dir.t -> unit

       Deprecated.

       Old name for Load_path.append_dir

       val append_dir : Dir.t -> unit

       append_dir d adds d to the end of the load path (i.e. at lowest priority.

       val prepend_dir : Dir.t -> unit

       prepend_dir d adds d to the start of the load path (i.e. at highest priority.

       val get_visible : unit -> Dir.t list

       Same as get_paths () , except that it returns a Dir.t list , and doesn't include the -H paths.