package eliom

  1. Overview
  2. Docs
package eliom
Legend:
Library
Module
Module type
Parameter
Class
Class type

Creation and manipulation of Eliom services.

See the Eliom manual for a detailed introduction to the concept of <<a_manual chapter="server-services"|Eliom services>> and to <<a_manual chapter="clientserver-services"|client-side service implementation>>.

The main functions about services are documented in <<a_api | module Eliom_service_sigs.S >>.

include Eliom_service_sigs.S

Services

See Eliom_service.create (on the server) for how to create services.

include Eliom_service_sigs.TYPES
type get =
  1. | Get_method
type put =
  1. | Put_method
type post =
  1. | Post_method
type delete =
  1. | Delete_method
type co =
  1. | Co
type non_co =
  1. | Non_co
type ext =
  1. | Ext
type non_ext =
  1. | Non_ext
type http =
  1. | Http_ret
type 'a ocaml =
  1. | Ocaml of 'a
type non_ocaml =
  1. | Non_ocaml
type reg =
  1. | Reg
type non_reg =
  1. | Non_reg
type ('get, 'tipo, 'gn) params = ('get, 'tipo, 'gn) Eliom_parameter.params_type constraint 'tipo = [< `WithSuffix | `WithoutSuffix ]

Method specification

type ('m, _, _, _, _, _, _) meth =
  1. | Get : ('gp, 'tipo, 'gn) params -> (get, 'gp, 'gn, unit, unit, 'tipo, unit) meth
  2. | Post : ('gp, 'tipo, 'gn) params * ('pp, [ `WithoutSuffix ], 'pn) params -> (post, 'gp, 'gn, 'pp, 'pn, 'tipo, 'gp) meth
  3. | Put : ('gp, 'tipo, 'gn) params -> (put, 'gp, 'gn, Eliom_parameter.raw_post_data, Eliom_parameter.no_param_name, 'tipo, unit) meth
  4. | Delete : ('gp, 'tipo, 'gn) params -> (delete, 'gp, 'gn, Eliom_parameter.raw_post_data, Eliom_parameter.no_param_name, 'tipo, unit) meth

Method specification datatype

An Eliom service (see Eliom_service_sigs.S.t) can respond to one of the following HTTP methods:

  • GET (Get g)
  • POST (Post (g, p))
  • PUT (Put g)
  • DELETE (Delete g)

In all cases, the service parameters need to be provided (see Eliom_parameter_sigs.S). POST (Post (g, p)) services accept both GET (g) and POST (p) parameters. For the other methods, only GET (g) parameters apply.

The type parameters are used to impose various type constraints, and are not necessarily of interest to the programmer. Their technical meaning is as follows.

  • 0-th param : method
  • params 1-4 : GET and POST parameter types and names
  • param 5 : suffix parameters permitted or not
  • param 6 : non-unit only for the Post (g, p) case when g is not unit ; used to force unit GET parameters when needed
type 'm which_meth =
  1. | Get' : get which_meth
  2. | Post' : post which_meth
  3. | Put' : put which_meth
  4. | Delete' : delete which_meth

Like meth but without the parameters

Auxiliary types

type att
type non_att
type 'a attached_info =
  1. | Attached : att -> att attached_info
  2. | Nonattached : non_att -> non_att attached_info
type ('get, 'post, 'meth, 'attached, 'co, 'ext, 'reg, +'tipo, 'gn, 'pn, 'ret) t constraint 'tipo = [< `WithSuffix | `WithoutSuffix ]

Type of services

For a service ('get, 'post, 'meth, 'attached, 'co, 'ext, 'reg, 'tipo, 'gn, 'pn, 'ret) t:

  • 'get is the type of GET parameters expected by the service.
  • 'post is the type of POST parameters expected by the service.
  • 'meth the HTTP method
  • 'attached attached or non-attached
  • 'co co-service or regular service
  • 'ext external or internal
  • 'reg: possible to register a handler on this service
  • 'tipo the type parameter of subtype suff states the kind of parameters it uses: suffix or not.
  • 'gn is the type of GET parameters names. See Eliom_parameter.param_name and form generation functions (e. g. Eliom_content.Html.D.get_form ).
  • 'pn is the type of POST parameters names. See Eliom_parameter.param_name and form generation functions (e. g. Eliom_content.Html.D.post_form ).
  • 'ret is an information on what the service returns. See Eliom_registration.kind.
and result =
  1. | No_contents
  2. | Dom of Js_of_ocaml.Dom_html.element Js_of_ocaml.Js.t
  3. | Redirect : (unit, unit, get, _, _, _, _, [ `WithoutSuffix ], unit, unit, non_ocaml) t -> result
  4. | Reload_action of {
    1. hidden : bool;
    2. https : bool;
    }
type unit_service = (unit, unit, get, att, non_co, non_ext, non_reg, [ `WithoutSuffix ], unit, unit, non_ocaml) t
type (_, _, _) path_option =
  1. | Path : Eliom_lib.Url.path -> (att, non_co, _) path_option
  2. | No_path : (non_att, co, unit) path_option

Optional service path

Predefined services

Reload actions
val reload_action : (unit, unit, get, non_att, co, non_ext, non_reg, [ `WithoutSuffix ], unit, unit, non_ocaml) t

The service reload_action is a predefined non-attached action with special behaviour: it has no parameter at all, even non-attached parameters. Use it if you want to make a link to the current page without non-attached parameters. It is almost equivalent to a POST non-attached service without POST parameters, on which you register an action that does nothing, but you can use it with <a> links, not only forms. It does not keep non attached GET parameters.

val reload_action_https : (unit, unit, get, non_att, co, non_ext, non_reg, [ `WithoutSuffix ], unit, unit, non_ocaml) t

Like reload_action, but forces HTTPS

val reload_action_hidden : (unit, unit, get, non_att, co, non_ext, non_reg, [ `WithoutSuffix ], unit, unit, non_ocaml) t

Like reload_action, but keeps non-attached GET parameters.

val reload_action_https_hidden : (unit, unit, get, non_att, co, non_ext, non_reg, [ `WithoutSuffix ], unit, unit, non_ocaml) t

Like reload_action_hidden, but forces HTTPS

Static files

val static_dir : unit -> (string list, unit, get, att, non_co, non_ext, non_reg, [ `WithSuffix ], [ `One of string list ] Eliom_parameter.param_name, unit, non_ocaml) t

The predefined service static_dir allows one to create links to static files. This service takes the name of a static file as a parameter (a string list, slash separated). The actual directory in filesystem where static pages will be found must be set up in the configuration file with the staticmod extension.

val https_static_dir : unit -> (string list, unit, get, att, non_co, non_ext, non_reg, [ `WithSuffix ], [ `One of string list ] Eliom_parameter.param_name, unit, non_ocaml) t

Like static_dir, but forces HTTPS link

val static_dir_with_params : ?keep_nl_params:[ `All | `Persistent | `None ] -> get_params:('a, [ `WithoutSuffix ], 'an) Eliom_parameter.params_type -> unit -> (string list * 'a, unit, get, att, non_co, non_ext, non_reg, [ `WithSuffix ], [ `One of string list ] Eliom_parameter.param_name * 'an, unit, non_ocaml) t

Like static_dir, but allows one to put GET parameters

val https_static_dir_with_params : ?keep_nl_params:[ `All | `Persistent | `None ] -> get_params:('a, [ `WithoutSuffix ], 'an) Eliom_parameter.params_type -> unit -> (string list * 'a, unit, get, att, non_co, non_ext, non_reg, [ `WithSuffix ], [ `One of string list ] Eliom_parameter.param_name * 'an, unit, non_ocaml) t

Like static_dir_with_params, but forces HTTPS link

Miscellaneous

val preapply : service:('a, 'b, 'meth, att, 'co, 'ext, 'reg, _, 'e, 'f, 'return) t -> 'a -> (unit, 'b, 'meth, att, 'co, 'ext, non_reg, [ `WithoutSuffix ], unit, 'f, 'return) t

The function preapply ~service parameters creates a new service by preapplying service to the GET parameters. It is not possible to register a handler on an preapplied service; preapplied services may be used in links or as fallbacks.

val add_non_localized_get_parameters : params:('p, [ `WithoutSuffix ], 'pn) Eliom_parameter.non_localized_params -> service:('a, 'b, 'meth, 'attach, 'co, 'ext, 'reg, 'd, 'e, 'f, 'return) t -> ('a * 'p, 'b, 'meth, 'attach, 'co, 'ext, 'reg, 'd, 'e * 'pn, 'f, 'return) t

The function add_non_localized_get_parameters ~params ~service Adds non localized GET parameters params to service. See the Eliom manual for more information about <<a_manual chapter="server-params" fragment="nonlocalizedparameters"|non localized parameters>>.

val add_non_localized_post_parameters : params:('p, [ `WithoutSuffix ], 'pn) Eliom_parameter.non_localized_params -> service:('a, 'b, 'meth, 'attach, 'co, 'ext, 'g, 'd, 'e, 'f, 'return) t -> ('a, 'b * 'p, 'meth, 'attach, 'co, 'ext, 'g, 'd, 'e, 'f * 'pn, 'return) t

Like add_non_localized_get_parameters but with POST parameters.

val extern : ?keep_nl_params:[ `All | `Persistent | `None ] -> prefix:string -> path:Eliom_lib.Url.path -> meth:('m, 'gp, 'gn, 'pp, 'pn, 'tipo, _) meth -> unit -> ('gp, 'pp, 'm, att, non_co, ext, non_reg, 'tipo, 'gn, 'pn, non_ocaml) t

extern ~prefix ~path ~meth () creates an external service, i.e., a service implemented by a remote server (not necessarily running Ocsigen/Eliom).

val set_client_fun : ?app:string -> service:('a, 'b, _, _, _, _, _, _, _, _, _) t -> ('a -> 'b -> result Lwt.t) -> unit