NAME¶
Eliom_parameter - Ad-hoc runtime type representation for service parameters.
Module¶
Module Eliom_parameter
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