mirror of
https://github.com/KevinMidboe/linguist.git
synced 2025-10-29 09:40:21 +00:00
538f479b60
Taken from tokenrove/parsur so I don't have to worry about license hassles. (You may relicense these samples as necessary.) It would be nice to have an example of the embedded SQL syntax in a sample.
86 lines
2.9 KiB
Plaintext
86 lines
2.9 KiB
Plaintext
functor Make(Stream : sig type t end) : sig
|
|
con t :: Type -> Type
|
|
|
|
val mreturn : a ::: Type -> a -> t a
|
|
val mbind : a ::: Type -> b ::: Type ->
|
|
(t a) -> (a -> t b) -> (t b)
|
|
val monad_parse : monad t
|
|
|
|
val parse : a ::: Type -> t a -> Stream.t -> option a
|
|
|
|
(** Combinators *)
|
|
val fail : a ::: Type -> t a
|
|
val or : a ::: Type -> t a -> t a -> t a
|
|
val maybe : a ::: Type -> t a -> t (option a)
|
|
val maybe' : a ::: Type -> t a -> t unit
|
|
val many : a ::: Type -> t a -> t (list a)
|
|
val count : a ::: Type -> int -> t a -> t (list a)
|
|
val skipMany : a ::: Type -> t a -> t unit
|
|
val sepBy : a ::: Type -> s ::: Type -> t a -> t s -> t (list a)
|
|
end
|
|
|
|
structure String : sig
|
|
con t :: Type -> Type
|
|
val monad_parse : monad t
|
|
|
|
val parse : a ::: Type -> t a -> string -> option a
|
|
|
|
(** Combinators *)
|
|
val fail : a ::: Type -> t a
|
|
val or : a ::: Type -> t a -> t a -> t a
|
|
val maybe : a ::: Type -> t a -> t (option a)
|
|
val maybe' : a ::: Type -> t a -> t unit
|
|
val many : a ::: Type -> t a -> t (list a)
|
|
val count : a ::: Type -> int -> t a -> t (list a)
|
|
val skipMany : a ::: Type -> t a -> t unit
|
|
val sepBy : a ::: Type -> s ::: Type -> t a -> t s -> t (list a)
|
|
|
|
val eof : t unit
|
|
(* We provide alternative versions of some of these predicates
|
|
* that return t unit as a monadic syntactical convenience. *)
|
|
val string : string -> t string
|
|
val string' : string -> t unit
|
|
val stringCI : string -> t string
|
|
val stringCI' : string -> t unit
|
|
val char : char -> t char
|
|
val char' : char -> t unit
|
|
val take : int -> t (string*int)
|
|
val drop : int -> t unit
|
|
val satisfy : (char -> bool) -> t char
|
|
val skip : (char -> bool) -> t unit
|
|
val skipWhile : (char -> bool) -> t unit
|
|
val takeWhile : (char -> bool) -> t (string*int)
|
|
val takeWhile' : (char -> bool) -> t string (* conses *)
|
|
(* Well, "till" is the correct form; but "til" is in common enough
|
|
* usage that I'll prefer it for terseness. *)
|
|
val takeTil : (char -> bool) -> t (string*int)
|
|
val takeTil' : (char -> bool) -> t string (* conses *)
|
|
val takeRest : t string
|
|
|
|
(** Convenience functions *)
|
|
val skipSpace : t unit
|
|
val endOfLine : t unit
|
|
val unsigned_int_of_radix : int -> t int
|
|
(*
|
|
* val signed_int_of_radix : int -> t int
|
|
* val double : t float
|
|
*)
|
|
end
|
|
|
|
structure Blob : sig
|
|
con t :: Type -> Type
|
|
val monad_parse : monad t
|
|
|
|
val parse : a ::: Type -> t a -> blob -> option a
|
|
|
|
(** Combinators *)
|
|
val fail : a ::: Type -> t a
|
|
val or : a ::: Type -> t a -> t a -> t a
|
|
val maybe : a ::: Type -> t a -> t (option a)
|
|
val maybe' : a ::: Type -> t a -> t unit
|
|
val many : a ::: Type -> t a -> t (list a)
|
|
val count : a ::: Type -> int -> t a -> t (list a)
|
|
val skipMany : a ::: Type -> t a -> t unit
|
|
val sepBy : a ::: Type -> s ::: Type -> t a -> t s -> t (list a)
|
|
end
|