This project adheres to Semantic Versioning. Lines marked with 🧨 describe breaking changes.
The parser is made functional: the use of camlp-streams has been dropped in favour of sequences of the Seq module. The parser is written in a monad.
🧨 The error `Op_conflict now takes a single argument instead of two.
🧨 Introduced a type for parsers. The function expression builds a parser that can then be run on any sequence with the run function.
🧨 A token can have different fixities depending on the context its in. For instance, the - can be declared both prefix and infix, resulting in - x - y being parsed as (-x) - y. Consequently the API changed. The parser now truly parses the input, meaning that the output datatype may be different from the input datatype: the main expression function changed from
expression : ... -> 'a Stream.t -> 'a toexpression : ... -> 'a Stream.t -> 'b.Consequently, the ~appl argument of the expression function now operates on the output type, and a new argument ~token must be given which parses tokens that aren't operators.
The expression function also takes an Operators.t value instead of a function is_op: 'a -> (fixity * float) option to parse operators. To use the new datatype, the rule is the following. For any operator op
is_op op returns Some (Infix a, p), the operators parser must be built with infix f a p where f is a function that parses o and produces an output datatype.is_op op returns Some (Prefix, p), then the operators parser must be built with prefix f p, where f verifies the aforementioned properties.is_op op returns Some (Postfix, p), then the operators parser must be built with postfix f p, and f verifies the aforementioned properties.🧨 Use camel case for errors: OpConflict changed to Op_conflict and TooFewArguments to Too_few_arguments.
🧨 Errors UnexpectedPostfix and UnexpectedInfix have been removed. If a infix operator appears postfix, it's handled by the token parser rather than the operator parser.
Lower bounds on test dependencies alcotest, qcheck and qcheck-alcotest.
🧨 Removed the functor interface, the parser is a single function taking two functions and a stream of terms as parameters.
No more table type needed, the parser only needs a function is_op to distinguish operators from other tokens.
To port code, any snippet like
module S : SUPPORT = struct
type term = ...
type table = ...
let get tbl t = ...
let make_appl t u = ...
end
module P = Pratter.Make(S)should be replaced by
let is_op t = ...
let appl t u = ...where the following properties hold
appl = S.make_appl∃ tbl : S.table, get tbl = is_opUnder these assumptions, denoting tbl the value that makes the second hypothesis hold, we have P.expression tbl = Pratter.expression ~is_op ~appl
t ::= t t | t + t | - t | t * t | t = t | t !Una constructor changed to PrefixBin constructor changed to Infix🧨 Errors are encoded with a polymorphic variant rather than exceptions. To port code, replace sections of the form
try let t = SupPrat.expression tbl s in e with
| ... -> ...with
match SupPrat.expression tbl s with
| Ok t -> e
| Error ... -> ...camlp-streams (because Stdlib.Stream becomes deprecated in OCaml 4.14).Stream.Failure)get for operators in APImake_appl does not use the table of operators