Module

Documentation

Module Eliom_parameter
 :  sig end

Ad-hoc runtime type representation for service parameters.

See the Eliom manual for more information about .

type ('a, +'b, +'c) params_type

Abstract type for service parameters. See for example the parameter ~get_param of Eliom_service.service .

- 'a is the type for the OCaml type of the parameter as expected by the service handler.

- 'b is a phantom type, subtype of Eliom_parameter.suff , stating the kind of the parameter: suffix or not.

- 'c is the type of the parameter name, usually an instance of Eliom_parameter.param_name , as used by forms construction functions (e. g. the last parameter of Eliom_registration.Html5.get_form ), and specialized form widget (see for example the section Eliom_registration.Html5.form_widgets of Eliom_registration.HTML5 ). )

type suff = [ `Endsuffix | `WithSuffix | `WithoutSuffix ]

TODO

=== Typed parameter's name ===

type 'a param_name

Abstract type for parameters' name. The 'a type parameter is a phantom type, usually a subtype of Eliom_parameter.setoneradio , used to denotes the parameter's arity.

type no_param_name

Empty type used to denotes it is not possible to use the parameter in a form. See for example Eliom_parameter.raw_post_data .

type 'a setoneradio = [ `One of 'a | `Radio of 'a | `Set of 'a ]

A parameter arity could either be:

- `Set of 'a means: any number of 'a .

- `One of 'a means: exactly one 'a .

- `Radio of 'a means: zero or one 'a .

type 'a oneradio = [ `One of 'a | `Radio of 'a ]

Restriction of Eliom_parameter.setoneradio unary and optional parameters.

type 'a setone = [ `One of 'a | `Set of 'a ]

Restriction of Eliom_parameter.setoneradio unary and set parameters.

=== Types helpers ===

type ('a, 'b) binsum =
 | Inj1 of 'a
 | Inj2 of 'b
 

Helpers type used for parameters of type binary sum, see Eliom_parameter.sum .

type 'a listnames = {
 it :  'b 'c. ('a -> 'b -> 'c -> 'c) -> 'b list -> 'c -> 'c ;
 }

Helpers type used to construct forms from lists, see Eliom_parameter.list .

=== Basic types of pages parameters ===

val int : string -> (int, [ `WithoutSuffix ], [ `One of int ] param_name) params_type

The function int s tells that the service takes an integer as parameter, labeled s .

val int32 : string -> (int32, [ `WithoutSuffix ], [ `One of int32 ] param_name) params_type

The function int32 s tells that the service takes a 32 bits integer as parameter, labeled s .

val int64 : string -> (int64, [ `WithoutSuffix ], [ `One of int64 ] param_name) params_type

The function int64 s tells that the service takes a 64 bits integer as parameter, labeled s .

val float : string -> (float, [ `WithoutSuffix ], [ `One of float ] param_name) params_type

The function float s tells that the service takes a floating point number as parameter, labeled s .

val string : string -> (string, [ `WithoutSuffix ], [ `One of string ] param_name) params_type

The function string s tells that the service takes a string as parameter, labeled s .

val bool : string -> (bool, [ `WithoutSuffix ], [ `One of bool ] param_name) params_type

The function bool s tells that the service takes a boolean as parameter, labeled s . (to use for example with boolean checkboxes)

val file : string -> (Eliom_lib.file_info, [ `WithoutSuffix ], [ `One of Eliom_lib.file_info ] param_name) params_type

The function file s tells that the service takes a file as parameter, labeled s .

val unit : (unit, [ `WithoutSuffix ], unit) params_type

The function unit is used for services that don't have any parameters

val user_type : of_string:(string -> 'a) -> to_string:('a -> string) -> string -> ('a, [ `WithoutSuffix ], [ `One of 'a ] param_name) params_type

The function user_type ~of_string ~to_string s tells that the service take a parameter, labeled s , and that the server will have to use of_string and to_string to make the conversion between the OCaml representation of the parameter and it's external representation as a string. It allows one to use whatever type you want for a parameter of the service.

type coordinates = {
 abscissa :  int ;
 ordinate :  int ;
 }

The type coordinates represent the data sent by an <input type=image ...> .

val coordinates : string -> (coordinates, [ `WithoutSuffix ], [ `One of coordinates ] param_name) params_type

The function coordinates s tells that the service takes as parameters the coordinates of a point in an <input type=image ...> .

val string_coordinates : string -> (string * coordinates, [ `WithoutSuffix ], [ `One of string * coordinates ] param_name) params_type

The function string_coordinates s tells that the service takes as parameters the coordinates of a point and the associated string value in an <input type=image value=... ...> .

val int_coordinates : string -> (int * coordinates, [ `WithoutSuffix ], [ `One of int * coordinates ] param_name) params_type

Same as string_coordinates but for an integer value

val int32_coordinates : string -> (int32 * coordinates, [ `WithoutSuffix ], [ `One of int32 * coordinates ] param_name) params_type

Same as string_coordinates but for a 32 bits integer value

val int64_coordinates : string -> (int64 * coordinates, [ `WithoutSuffix ], [ `One of int64 * coordinates ] param_name) params_type

Same as string_coordinates but for a 64 integer value

val float_coordinates : string -> (float * coordinates, [ `WithoutSuffix ], [ `One of float * coordinates ] param_name) params_type

Same as string_coordinates but for a float value

val user_type_coordinates : of_string:(string -> 'a) -> to_string:('a -> string) -> string -> ('a * coordinates, [ `WithoutSuffix ], [ `One of 'a * coordinates ] param_name) params_type

Same as string_coordinates but for a value of your own type. See Eliom_parameter.user_type for a description of the of_string and to_string parameters.

=== Composing types of pages parameters ===

val ( ** ) : ('a, [ `WithoutSuffix ], 'b) params_type -> ('c, [< `Endsuffix | `WithoutSuffix ] as 'd, 'e) params_type -> ('a * 'c, 'd, 'b * 'e) params_type

The combinator p1 ** p2 allows one to define service that take a pair of parameter. The associated service handler should expect a pair (p1, p2) as parameter.

val prod : ('a, [ `WithoutSuffix ], 'b) params_type -> ('c, [< `Endsuffix | `WithoutSuffix ] as 'd, 'e) params_type -> ('a * 'c, 'd, 'b * 'e) params_type

Same as Eliom_parameter.( ** ) .

val sum : ('a, [ `WithoutSuffix ], 'b) params_type -> ('c, [ `WithoutSuffix ], 'd) params_type -> (('a, 'c) binsum, [ `WithoutSuffix ], 'b * 'd) params_type

The combinator sum p1 p2 allows one to define service that expect either the parameter p1 or the parameter p2 .

val opt : ('a, [ `WithoutSuffix ], 'b) params_type -> ('a option, [ `WithoutSuffix ], 'b) params_type

The combinator opt p allow to define an optional parameter.

val radio : (string -> ('a, [ `WithoutSuffix ], [ `One of 'b ] param_name) params_type) -> string -> ('a option, [ `WithoutSuffix ], [ `Radio of 'b ] param_name) params_type

The function radio f s tells that the service takes an optional argument labeled s and of type f s . Use radio instead of Eliom_parameter.opt if you want to use this parameter with a radio button.

val any : ((string * string) list, [ `WithoutSuffix ], unit) params_type

Use this if you want to take any parameters. The service will answer to all the request, and get all parameters as an association list of strings.

val set : (string -> ('a, [ `WithoutSuffix ], [ `One of 'b ] param_name) params_type) -> string -> ('a list, [ `WithoutSuffix ], [ `Set of 'b ] param_name) params_type

Use this if you want your service to take several parameters with the same name. The service handler will receive a list of values. To create the form, just use the same name several times. For example set int i will match the parameter string i=4&i=22&i=111 and send to the service handler a list containing the three integers 4, 22 and 111. The order is unspecified.

val list : string -> ('a, [ `WithoutSuffix ], 'b) params_type -> ('a list, [ `WithoutSuffix ], 'b listnames) params_type

The service takes a list of parameters. The first parameter of this function is the name of the list. The service handler will receive a list of values. To create the form, an iterator of type Eliom_parameter.listnames is given to generate the name for each value.

val regexp : Netstring_pcre.regexp -> string -> to_string:(string -> string) -> string -> (string, [ `WithoutSuffix ], [ `One of string ] param_name) params_type

regexp r d s tells that the service takes a string that matches the regular expression r as parameter, labeled s , and that will be rewritten in d. The syntax of regexp is PCRE's one (uses Netstring_pcre , from OCamlnet). For example: regexp (Netstring_pcre.regexp \[(.* )\]) ($1) myparam will match the parameter myparam=[hello] and send the string (hello) to the service handler.

val suffix : ?redirect_if_not_suffix:bool -> ('a, [< `Endsuffix | `WithoutSuffix ], 'b) params_type -> ('a, [ `WithSuffix ], 'b) params_type

Tells that the parameter of the service handler is the suffix of the URL of the current service. e.g. suffix (int i ** string s) will match an URL ending by 380/yo . and send (380, yo) to the service handler.

For each service with suffix, there is also a service with regular parameters (without suffix) that will be used if you create a form towards a service with suffix. If redirect_if_not_suffix is true (default), this service without suffix will be redirected to the suffix version.

val all_suffix : string -> (string list, [ `Endsuffix ], [ `One of string list ] param_name) params_type

Takes all the suffix, as long as possible, as a (slash separated) string list

val all_suffix_string : string -> (string, [ `Endsuffix ], [ `One of string ] param_name) params_type

Takes all the suffix, as long as possible, as a string

val all_suffix_user : of_string:(string -> 'a) -> to_string:('a -> string) -> string -> ('a, [ `Endsuffix ], [ `One of 'a ] param_name) params_type

Takes all the suffix, as long as possible, with a type specified by the user.

val all_suffix_regexp : Netstring_pcre.regexp -> string -> to_string:(string -> string) -> string -> (string, [ `Endsuffix ], [ `One of string ] param_name) params_type

all_suffix_regexp r d s takes all the suffix, as long as possible, matching the regular expression r , name s , and rewrite it in d .

val suffix_prod : ?redirect_if_not_suffix:bool -> ('a, [< `Endsuffix | `WithoutSuffix ], 'b) params_type -> ('c, [ `WithoutSuffix ], 'd) params_type -> ('a * 'c, [ `WithSuffix ], 'b * 'd) params_type

Tells that the function that will generate the service takes a pair whose first element is the suffix of the URL of the current service, and the second element corresponds to other (regular) parameters. e.g.: suffix_prod (int suff ** all_suffix endsuff) (int i) will match an URL ending by 777/go/go/go?i=320 and send the value ((777, [go;go;go]), 320) to the service handler.

val suffix_const : string -> (unit, [ `WithoutSuffix ], [ `One of unit ] param_name) params_type

suffix_const v is used only inside suffixes (do nothing for regular parameters). It tells that the service takes a constant parameter inside the suffix, whose value must be v . It is used for putting constant directory names inside suffix parameters (and thus make suffix parameters not be only suffixes but anywhere you want in the path, e.g. /param1/const/param2 ).

type 'a caml

marshaled OCaml values of type 'a

val caml : string -> 'a Deriving_Json.t -> ('a, [ `WithoutSuffix ], [ `One of 'a caml ] param_name) params_type

caml s tells that the service is expecting some caml (client side) program to send some value of type 'a, marshaled. As usual s is the name of the parameter.

val raw_post_data : (((string * string) * (string * string) list) option * string Ocsigen_stream.t option, [ `WithoutSuffix ], no_param_name) params_type

When the content type is neither URLencoded form data or multipart data, it is possible to get it as a stream of strings. The first element of the pair is the content-type. This kind of parameter cannot be combined with other ones, and it is not possible to create a form towards a service taking this kind of parameter.

val guard : (string -> ('a, 'b, [ `One of string ] param_name) params_type) -> string -> ('a -> bool) -> ('a, 'b, [ `One of string ] param_name) params_type

guard construct name pred returns the same parameter as construct name but with ensuring that each value must satisfy pred . For instance: int age ((>=) 0)

type ('a, +'b, +'c) non_localized_params

Non localized parameters

val make_non_localized_parameters : prefix:string -> name:string -> ?persistent:bool -> ('a, [ `WithoutSuffix ], 'b) params_type -> ('a, [ `WithoutSuffix ], 'b) non_localized_params

create a new specification for non localized parameters. You must give a name to this set of parameters. Warning: the names must be unique for the whole application. That's why the name is composed by a prefix (the name of your project) and another string (the name of your non localized parameters).

Will fail with exception Failure _ if the name contains a dot. If ?persistent is true , the non localized parameter may remain if you call another service, if this service allows this (default false ).

val get_non_localized_get_parameters : ('a, [ `WithoutSuffix ], 'b) non_localized_params -> 'a option

get_non_localized_get_parameters ~sp p decodes and returns non localized GET parameters specified by p if present.

val get_non_localized_post_parameters : ('a, [ `WithoutSuffix ], 'b) non_localized_params -> 'a option

get_non_localized_post_parameters ~sp p decodes and returns non localized POST parameters specified by p if present.

type nl_params_set

Use this type to give non localized parameters to a link or a form

val empty_nl_params_set : nl_params_set

val add_nl_parameter : nl_params_set -> ('a, [< `WithSuffix | `WithoutSuffix ], 'b) non_localized_params -> 'a -> nl_params_set

val get_nl_params_names : ('a, [< `WithSuffix | `WithoutSuffix ], 'b) non_localized_params -> 'b

val get_to_and_from : ('a, 'b, 'c) params_type -> (string -> 'a) * ('a -> string)

Given a parameter type, get the two functions that converts from and to strings. You should only use this function on

-options ;

-basic types : int, int32, int64, float, string

-marshal

-unit

-string

-bool